kc3-lang/angle/src/libANGLE/capture/capture_gles_2_0_autogen.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2022-08-25 11:16:23
  Hash : 64f41972
  Message : Use canonical gl.xml and update enum to string function. This replaces our copy of gl.xml with the upstream canonical copy. Note that one patch is required before we can remove ANGLE's copy: https://github.com/KhronosGroup/OpenGL-Registry/pull/538 Because the upstream version uses a new method of enum groups, we also update our enum-to-string generator to use the new groups. This new code includes many more enums and groups in the mapping. Bug: angleproject:6461 Change-Id: I1c0ab44c36afce8db04c9661b377bbe5762c913e Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3856649 Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: Jonah Ryan-Davis <jonahr@google.com> Commit-Queue: Jamie Madill <jmadill@chromium.org>

• src/libANGLE/capture/capture_gles_2_0_autogen.h

• // GENERATED FILE - DO NOT EDIT.
  // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
  //
  // Copyright 2020 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.
  //
  // capture_gles_2_0_autogen.h:
  //   Capture functions for the OpenGL ES 2.0 entry points.
  
  #ifndef LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
  #define LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
  
  #include "common/PackedEnums.h"
  #include "libANGLE/capture/FrameCapture.h"
  
  namespace gl
  {
  
  // Method Captures
  
  angle::CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture);
  angle::CallCapture CaptureAttachShader(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         ShaderProgramID shaderPacked);
  angle::CallCapture CaptureBindAttribLocation(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLuint index,
                                               const GLchar *name);
  angle::CallCapture CaptureBindBuffer(const State &glState,
                                       bool isCallValid,
                                       BufferBinding targetPacked,
                                       BufferID bufferPacked);
  angle::CallCapture CaptureBindFramebuffer(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            FramebufferID framebufferPacked);
  angle::CallCapture CaptureBindRenderbuffer(const State &glState,
                                             bool isCallValid,
                                             GLenum target,
                                             RenderbufferID renderbufferPacked);
  angle::CallCapture CaptureBindTexture(const State &glState,
                                        bool isCallValid,
                                        TextureType targetPacked,
                                        TextureID texturePacked);
  angle::CallCapture CaptureBlendColor(const State &glState,
                                       bool isCallValid,
                                       GLfloat red,
                                       GLfloat green,
                                       GLfloat blue,
                                       GLfloat alpha);
  angle::CallCapture CaptureBlendEquation(const State &glState, bool isCallValid, GLenum mode);
  angle::CallCapture CaptureBlendEquationSeparate(const State &glState,
                                                  bool isCallValid,
                                                  GLenum modeRGB,
                                                  GLenum modeAlpha);
  angle::CallCapture CaptureBlendFunc(const State &glState,
                                      bool isCallValid,
                                      GLenum sfactor,
                                      GLenum dfactor);
  angle::CallCapture CaptureBlendFuncSeparate(const State &glState,
                                              bool isCallValid,
                                              GLenum sfactorRGB,
                                              GLenum dfactorRGB,
                                              GLenum sfactorAlpha,
                                              GLenum dfactorAlpha);
  angle::CallCapture CaptureBufferData(const State &glState,
                                       bool isCallValid,
                                       BufferBinding targetPacked,
                                       GLsizeiptr size,
                                       const void *data,
                                       BufferUsage usagePacked);
  angle::CallCapture CaptureBufferSubData(const State &glState,
                                          bool isCallValid,
                                          BufferBinding targetPacked,
                                          GLintptr offset,
                                          GLsizeiptr size,
                                          const void *data);
  angle::CallCapture CaptureCheckFramebufferStatus(const State &glState,
                                                   bool isCallValid,
                                                   GLenum target,
                                                   GLenum returnValue);
  angle::CallCapture CaptureClear(const State &glState, bool isCallValid, GLbitfield mask);
  angle::CallCapture CaptureClearColor(const State &glState,
                                       bool isCallValid,
                                       GLfloat red,
                                       GLfloat green,
                                       GLfloat blue,
                                       GLfloat alpha);
  angle::CallCapture CaptureClearDepthf(const State &glState, bool isCallValid, GLfloat d);
  angle::CallCapture CaptureClearStencil(const State &glState, bool isCallValid, GLint s);
  angle::CallCapture CaptureColorMask(const State &glState,
                                      bool isCallValid,
                                      GLboolean red,
                                      GLboolean green,
                                      GLboolean blue,
                                      GLboolean alpha);
  angle::CallCapture CaptureCompileShader(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID shaderPacked);
  angle::CallCapture CaptureCompressedTexImage2D(const State &glState,
                                                 bool isCallValid,
                                                 TextureTarget targetPacked,
                                                 GLint level,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLint border,
                                                 GLsizei imageSize,
                                                 const void *data);
  angle::CallCapture CaptureCompressedTexSubImage2D(const State &glState,
                                                    bool isCallValid,
                                                    TextureTarget targetPacked,
                                                    GLint level,
                                                    GLint xoffset,
                                                    GLint yoffset,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLenum format,
                                                    GLsizei imageSize,
                                                    const void *data);
  angle::CallCapture CaptureCopyTexImage2D(const State &glState,
                                           bool isCallValid,
                                           TextureTarget targetPacked,
                                           GLint level,
                                           GLenum internalformat,
                                           GLint x,
                                           GLint y,
                                           GLsizei width,
                                           GLsizei height,
                                           GLint border);
  angle::CallCapture CaptureCopyTexSubImage2D(const State &glState,
                                              bool isCallValid,
                                              TextureTarget targetPacked,
                                              GLint level,
                                              GLint xoffset,
                                              GLint yoffset,
                                              GLint x,
                                              GLint y,
                                              GLsizei width,
                                              GLsizei height);
  angle::CallCapture CaptureCreateProgram(const State &glState, bool isCallValid, GLuint returnValue);
  angle::CallCapture CaptureCreateShader(const State &glState,
                                         bool isCallValid,
                                         ShaderType typePacked,
                                         GLuint returnValue);
  angle::CallCapture CaptureCullFace(const State &glState, bool isCallValid, CullFaceMode modePacked);
  angle::CallCapture CaptureDeleteBuffers(const State &glState,
                                          bool isCallValid,
                                          GLsizei n,
                                          const BufferID *buffersPacked);
  angle::CallCapture CaptureDeleteFramebuffers(const State &glState,
                                               bool isCallValid,
                                               GLsizei n,
                                               const FramebufferID *framebuffersPacked);
  angle::CallCapture CaptureDeleteProgram(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID programPacked);
  angle::CallCapture CaptureDeleteRenderbuffers(const State &glState,
                                                bool isCallValid,
                                                GLsizei n,
                                                const RenderbufferID *renderbuffersPacked);
  angle::CallCapture CaptureDeleteShader(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID shaderPacked);
  angle::CallCapture CaptureDeleteTextures(const State &glState,
                                           bool isCallValid,
                                           GLsizei n,
                                           const TextureID *texturesPacked);
  angle::CallCapture CaptureDepthFunc(const State &glState, bool isCallValid, GLenum func);
  angle::CallCapture CaptureDepthMask(const State &glState, bool isCallValid, GLboolean flag);
  angle::CallCapture CaptureDepthRangef(const State &glState, bool isCallValid, GLfloat n, GLfloat f);
  angle::CallCapture CaptureDetachShader(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         ShaderProgramID shaderPacked);
  angle::CallCapture CaptureDisable(const State &glState, bool isCallValid, GLenum cap);
  angle::CallCapture CaptureDisableVertexAttribArray(const State &glState,
                                                     bool isCallValid,
                                                     GLuint index);
  angle::CallCapture CaptureDrawArrays(const State &glState,
                                       bool isCallValid,
                                       PrimitiveMode modePacked,
                                       GLint first,
                                       GLsizei count);
  angle::CallCapture CaptureDrawElements(const State &glState,
                                         bool isCallValid,
                                         PrimitiveMode modePacked,
                                         GLsizei count,
                                         DrawElementsType typePacked,
                                         const void *indices);
  angle::CallCapture CaptureEnable(const State &glState, bool isCallValid, GLenum cap);
  angle::CallCapture CaptureEnableVertexAttribArray(const State &glState,
                                                    bool isCallValid,
                                                    GLuint index);
  angle::CallCapture CaptureFinish(const State &glState, bool isCallValid);
  angle::CallCapture CaptureFlush(const State &glState, bool isCallValid);
  angle::CallCapture CaptureFramebufferRenderbuffer(const State &glState,
                                                    bool isCallValid,
                                                    GLenum target,
                                                    GLenum attachment,
                                                    GLenum renderbuffertarget,
                                                    RenderbufferID renderbufferPacked);
  angle::CallCapture CaptureFramebufferTexture2D(const State &glState,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLenum attachment,
                                                 TextureTarget textargetPacked,
                                                 TextureID texturePacked,
                                                 GLint level);
  angle::CallCapture CaptureFrontFace(const State &glState, bool isCallValid, GLenum mode);
  angle::CallCapture CaptureGenBuffers(const State &glState,
                                       bool isCallValid,
                                       GLsizei n,
                                       BufferID *buffersPacked);
  angle::CallCapture CaptureGenFramebuffers(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            FramebufferID *framebuffersPacked);
  angle::CallCapture CaptureGenRenderbuffers(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             RenderbufferID *renderbuffersPacked);
  angle::CallCapture CaptureGenTextures(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        TextureID *texturesPacked);
  angle::CallCapture CaptureGenerateMipmap(const State &glState,
                                           bool isCallValid,
                                           TextureType targetPacked);
  angle::CallCapture CaptureGetActiveAttrib(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *size,
                                            GLenum *type,
                                            GLchar *name);
  angle::CallCapture CaptureGetActiveUniform(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *size,
                                             GLenum *type,
                                             GLchar *name);
  angle::CallCapture CaptureGetAttachedShaders(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLsizei maxCount,
                                               GLsizei *count,
                                               ShaderProgramID *shadersPacked);
  angle::CallCapture CaptureGetAttribLocation(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              const GLchar *name,
                                              GLint returnValue);
  angle::CallCapture CaptureGetBooleanv(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLboolean *data);
  angle::CallCapture CaptureGetBufferParameteriv(const State &glState,
                                                 bool isCallValid,
                                                 BufferBinding targetPacked,
                                                 GLenum pname,
                                                 GLint *params);
  angle::CallCapture CaptureGetError(const State &glState, bool isCallValid, GLenum returnValue);
  angle::CallCapture CaptureGetFloatv(const State &glState,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLfloat *data);
  angle::CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState,
                                                                bool isCallValid,
                                                                GLenum target,
                                                                GLenum attachment,
                                                                GLenum pname,
                                                                GLint *params);
  angle::CallCapture CaptureGetIntegerv(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLint *data);
  angle::CallCapture CaptureGetProgramInfoLog(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLchar *infoLog);
  angle::CallCapture CaptureGetProgramiv(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         GLenum pname,
                                         GLint *params);
  angle::CallCapture CaptureGetRenderbufferParameteriv(const State &glState,
                                                       bool isCallValid,
                                                       GLenum target,
                                                       GLenum pname,
                                                       GLint *params);
  angle::CallCapture CaptureGetShaderInfoLog(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID shaderPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *infoLog);
  angle::CallCapture CaptureGetShaderPrecisionFormat(const State &glState,
                                                     bool isCallValid,
                                                     GLenum shadertype,
                                                     GLenum precisiontype,
                                                     GLint *range,
                                                     GLint *precision);
  angle::CallCapture CaptureGetShaderSource(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID shaderPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLchar *source);
  angle::CallCapture CaptureGetShaderiv(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID shaderPacked,
                                        GLenum pname,
                                        GLint *params);
  angle::CallCapture CaptureGetString(const State &glState,
                                      bool isCallValid,
                                      GLenum name,
                                      const GLubyte *returnValue);
  angle::CallCapture CaptureGetTexParameterfv(const State &glState,
                                              bool isCallValid,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              GLfloat *params);
  angle::CallCapture CaptureGetTexParameteriv(const State &glState,
                                              bool isCallValid,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              GLint *params);
  angle::CallCapture CaptureGetUniformLocation(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               const GLchar *name,
                                               GLint returnValue);
  angle::CallCapture CaptureGetUniformfv(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         UniformLocation locationPacked,
                                         GLfloat *params);
  angle::CallCapture CaptureGetUniformiv(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         UniformLocation locationPacked,
                                         GLint *params);
  angle::CallCapture CaptureGetVertexAttribPointerv(const State &glState,
                                                    bool isCallValid,
                                                    GLuint index,
                                                    GLenum pname,
                                                    void **pointer);
  angle::CallCapture CaptureGetVertexAttribfv(const State &glState,
                                              bool isCallValid,
                                              GLuint index,
                                              GLenum pname,
                                              GLfloat *params);
  angle::CallCapture CaptureGetVertexAttribiv(const State &glState,
                                              bool isCallValid,
                                              GLuint index,
                                              GLenum pname,
                                              GLint *params);
  angle::CallCapture CaptureHint(const State &glState, bool isCallValid, GLenum target, GLenum mode);
  angle::CallCapture CaptureIsBuffer(const State &glState,
                                     bool isCallValid,
                                     BufferID bufferPacked,
                                     GLboolean returnValue);
  angle::CallCapture CaptureIsEnabled(const State &glState,
                                      bool isCallValid,
                                      GLenum cap,
                                      GLboolean returnValue);
  angle::CallCapture CaptureIsFramebuffer(const State &glState,
                                          bool isCallValid,
                                          FramebufferID framebufferPacked,
                                          GLboolean returnValue);
  angle::CallCapture CaptureIsProgram(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      GLboolean returnValue);
  angle::CallCapture CaptureIsRenderbuffer(const State &glState,
                                           bool isCallValid,
                                           RenderbufferID renderbufferPacked,
                                           GLboolean returnValue);
  angle::CallCapture CaptureIsShader(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID shaderPacked,
                                     GLboolean returnValue);
  angle::CallCapture CaptureIsTexture(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLboolean returnValue);
  angle::CallCapture CaptureLineWidth(const State &glState, bool isCallValid, GLfloat width);
  angle::CallCapture CaptureLinkProgram(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked);
  angle::CallCapture CapturePixelStorei(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLint param);
  angle::CallCapture CapturePolygonOffset(const State &glState,
                                          bool isCallValid,
                                          GLfloat factor,
                                          GLfloat units);
  angle::CallCapture CaptureReadPixels(const State &glState,
                                       bool isCallValid,
                                       GLint x,
                                       GLint y,
                                       GLsizei width,
                                       GLsizei height,
                                       GLenum format,
                                       GLenum type,
                                       void *pixels);
  angle::CallCapture CaptureReleaseShaderCompiler(const State &glState, bool isCallValid);
  angle::CallCapture CaptureRenderbufferStorage(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum internalformat,
                                                GLsizei width,
                                                GLsizei height);
  angle::CallCapture CaptureSampleCoverage(const State &glState,
                                           bool isCallValid,
                                           GLfloat value,
                                           GLboolean invert);
  angle::CallCapture CaptureScissor(const State &glState,
                                    bool isCallValid,
                                    GLint x,
                                    GLint y,
                                    GLsizei width,
                                    GLsizei height);
  angle::CallCapture CaptureShaderBinary(const State &glState,
                                         bool isCallValid,
                                         GLsizei count,
                                         const ShaderProgramID *shadersPacked,
                                         GLenum binaryFormat,
                                         const void *binary,
                                         GLsizei length);
  angle::CallCapture CaptureShaderSource(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID shaderPacked,
                                         GLsizei count,
                                         const GLchar *const *string,
                                         const GLint *length);
  angle::CallCapture CaptureStencilFunc(const State &glState,
                                        bool isCallValid,
                                        GLenum func,
                                        GLint ref,
                                        GLuint mask);
  angle::CallCapture CaptureStencilFuncSeparate(const State &glState,
                                                bool isCallValid,
                                                GLenum face,
                                                GLenum func,
                                                GLint ref,
                                                GLuint mask);
  angle::CallCapture CaptureStencilMask(const State &glState, bool isCallValid, GLuint mask);
  angle::CallCapture CaptureStencilMaskSeparate(const State &glState,
                                                bool isCallValid,
                                                GLenum face,
                                                GLuint mask);
  angle::CallCapture CaptureStencilOp(const State &glState,
                                      bool isCallValid,
                                      GLenum fail,
                                      GLenum zfail,
                                      GLenum zpass);
  angle::CallCapture CaptureStencilOpSeparate(const State &glState,
                                              bool isCallValid,
                                              GLenum face,
                                              GLenum sfail,
                                              GLenum dpfail,
                                              GLenum dppass);
  angle::CallCapture CaptureTexImage2D(const State &glState,
                                       bool isCallValid,
                                       TextureTarget targetPacked,
                                       GLint level,
                                       GLint internalformat,
                                       GLsizei width,
                                       GLsizei height,
                                       GLint border,
                                       GLenum format,
                                       GLenum type,
                                       const void *pixels);
  angle::CallCapture CaptureTexParameterf(const State &glState,
                                          bool isCallValid,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLfloat param);
  angle::CallCapture CaptureTexParameterfv(const State &glState,
                                           bool isCallValid,
                                           TextureType targetPacked,
                                           GLenum pname,
                                           const GLfloat *params);
  angle::CallCapture CaptureTexParameteri(const State &glState,
                                          bool isCallValid,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLint param);
  angle::CallCapture CaptureTexParameteriv(const State &glState,
                                           bool isCallValid,
                                           TextureType targetPacked,
                                           GLenum pname,
                                           const GLint *params);
  angle::CallCapture CaptureTexSubImage2D(const State &glState,
                                          bool isCallValid,
                                          TextureTarget targetPacked,
                                          GLint level,
                                          GLint xoffset,
                                          GLint yoffset,
                                          GLsizei width,
                                          GLsizei height,
                                          GLenum format,
                                          GLenum type,
                                          const void *pixels);
  angle::CallCapture CaptureUniform1f(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLfloat v0);
  angle::CallCapture CaptureUniform1fv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value);
  angle::CallCapture CaptureUniform1i(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLint v0);
  angle::CallCapture CaptureUniform1iv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value);
  angle::CallCapture CaptureUniform2f(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLfloat v0,
                                      GLfloat v1);
  angle::CallCapture CaptureUniform2fv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value);
  angle::CallCapture CaptureUniform2i(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLint v0,
                                      GLint v1);
  angle::CallCapture CaptureUniform2iv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value);
  angle::CallCapture CaptureUniform3f(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLfloat v0,
                                      GLfloat v1,
                                      GLfloat v2);
  angle::CallCapture CaptureUniform3fv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value);
  angle::CallCapture CaptureUniform3i(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLint v0,
                                      GLint v1,
                                      GLint v2);
  angle::CallCapture CaptureUniform3iv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value);
  angle::CallCapture CaptureUniform4f(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLfloat v0,
                                      GLfloat v1,
                                      GLfloat v2,
                                      GLfloat v3);
  angle::CallCapture CaptureUniform4fv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value);
  angle::CallCapture CaptureUniform4i(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLint v0,
                                      GLint v1,
                                      GLint v2,
                                      GLint v3);
  angle::CallCapture CaptureUniform4iv(const State &glState,
                                       bool isCallValid,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value);
  angle::CallCapture CaptureUniformMatrix2fv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
  angle::CallCapture CaptureUniformMatrix3fv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
  angle::CallCapture CaptureUniformMatrix4fv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
  angle::CallCapture CaptureUseProgram(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked);
  angle::CallCapture CaptureValidateProgram(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked);
  angle::CallCapture CaptureVertexAttrib1f(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           GLfloat x);
  angle::CallCapture CaptureVertexAttrib1fv(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            const GLfloat *v);
  angle::CallCapture CaptureVertexAttrib2f(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           GLfloat x,
                                           GLfloat y);
  angle::CallCapture CaptureVertexAttrib2fv(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            const GLfloat *v);
  angle::CallCapture CaptureVertexAttrib3f(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           GLfloat x,
                                           GLfloat y,
                                           GLfloat z);
  angle::CallCapture CaptureVertexAttrib3fv(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            const GLfloat *v);
  angle::CallCapture CaptureVertexAttrib4f(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           GLfloat x,
                                           GLfloat y,
                                           GLfloat z,
                                           GLfloat w);
  angle::CallCapture CaptureVertexAttrib4fv(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            const GLfloat *v);
  angle::CallCapture CaptureVertexAttribPointer(const State &glState,
                                                bool isCallValid,
                                                GLuint index,
                                                GLint size,
                                                VertexAttribType typePacked,
                                                GLboolean normalized,
                                                GLsizei stride,
                                                const void *pointer);
  angle::CallCapture CaptureViewport(const State &glState,
                                     bool isCallValid,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height);
  
  // Parameter Captures
  
  void CaptureBindAttribLocation_name(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      GLuint index,
                                      const GLchar *name,
                                      angle::ParamCapture *paramCapture);
  void CaptureBufferData_data(const State &glState,
                              bool isCallValid,
                              BufferBinding targetPacked,
                              GLsizeiptr size,
                              const void *data,
                              BufferUsage usagePacked,
                              angle::ParamCapture *paramCapture);
  void CaptureBufferSubData_data(const State &glState,
                                 bool isCallValid,
                                 BufferBinding targetPacked,
                                 GLintptr offset,
                                 GLsizeiptr size,
                                 const void *data,
                                 angle::ParamCapture *paramCapture);
  void CaptureCompressedTexImage2D_data(const State &glState,
                                        bool isCallValid,
                                        TextureTarget targetPacked,
                                        GLint level,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLint border,
                                        GLsizei imageSize,
                                        const void *data,
                                        angle::ParamCapture *paramCapture);
  void CaptureCompressedTexSubImage2D_data(const State &glState,
                                           bool isCallValid,
                                           TextureTarget targetPacked,
                                           GLint level,
                                           GLint xoffset,
                                           GLint yoffset,
                                           GLsizei width,
                                           GLsizei height,
                                           GLenum format,
                                           GLsizei imageSize,
                                           const void *data,
                                           angle::ParamCapture *paramCapture);
  void CaptureDeleteBuffers_buffersPacked(const State &glState,
                                          bool isCallValid,
                                          GLsizei n,
                                          const BufferID *buffersPacked,
                                          angle::ParamCapture *paramCapture);
  void CaptureDeleteFramebuffers_framebuffersPacked(const State &glState,
                                                    bool isCallValid,
                                                    GLsizei n,
                                                    const FramebufferID *framebuffersPacked,
                                                    angle::ParamCapture *paramCapture);
  void CaptureDeleteRenderbuffers_renderbuffersPacked(const State &glState,
                                                      bool isCallValid,
                                                      GLsizei n,
                                                      const RenderbufferID *renderbuffersPacked,
                                                      angle::ParamCapture *paramCapture);
  void CaptureDeleteTextures_texturesPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            const TextureID *texturesPacked,
                                            angle::ParamCapture *paramCapture);
  void CaptureDrawElements_indices(const State &glState,
                                   bool isCallValid,
                                   PrimitiveMode modePacked,
                                   GLsizei count,
                                   DrawElementsType typePacked,
                                   const void *indices,
                                   angle::ParamCapture *paramCapture);
  void CaptureGenBuffers_buffersPacked(const State &glState,
                                       bool isCallValid,
                                       GLsizei n,
                                       BufferID *buffersPacked,
                                       angle::ParamCapture *paramCapture);
  void CaptureGenFramebuffers_framebuffersPacked(const State &glState,
                                                 bool isCallValid,
                                                 GLsizei n,
                                                 FramebufferID *framebuffersPacked,
                                                 angle::ParamCapture *paramCapture);
  void CaptureGenRenderbuffers_renderbuffersPacked(const State &glState,
                                                   bool isCallValid,
                                                   GLsizei n,
                                                   RenderbufferID *renderbuffersPacked,
                                                   angle::ParamCapture *paramCapture);
  void CaptureGenTextures_texturesPacked(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         TextureID *texturesPacked,
                                         angle::ParamCapture *paramCapture);
  void CaptureGetActiveAttrib_length(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     GLuint index,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLint *size,
                                     GLenum *type,
                                     GLchar *name,
                                     angle::ParamCapture *paramCapture);
  void CaptureGetActiveAttrib_size(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID programPacked,
                                   GLuint index,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name,
                                   angle::ParamCapture *paramCapture);
  void CaptureGetActiveAttrib_type(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID programPacked,
                                   GLuint index,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name,
                                   angle::ParamCapture *paramCapture);
  void CaptureGetActiveAttrib_name(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID programPacked,
                                   GLuint index,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name,
                                   angle::ParamCapture *paramCapture);
  void CaptureGetActiveUniform_length(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      GLuint index,
                                      GLsizei bufSize,
                                      GLsizei *length,
                                      GLint *size,
                                      GLenum *type,
                                      GLchar *name,
                                      angle::ParamCapture *paramCapture);
  void CaptureGetActiveUniform_size(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLuint index,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *size,
                                    GLenum *type,
                                    GLchar *name,
                                    angle::ParamCapture *paramCapture);
  void CaptureGetActiveUniform_type(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLuint index,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *size,
                                    GLenum *type,
                                    GLchar *name,
                                    angle::ParamCapture *paramCapture);
  void CaptureGetActiveUniform_name(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLuint index,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *size,
                                    GLenum *type,
                                    GLchar *name,
                                    angle::ParamCapture *paramCapture);
  void CaptureGetAttachedShaders_count(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLsizei maxCount,
                                       GLsizei *count,
                                       ShaderProgramID *shadersPacked,
                                       angle::ParamCapture *paramCapture);
  void CaptureGetAttachedShaders_shadersPacked(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLsizei maxCount,
                                               GLsizei *count,
                                               ShaderProgramID *shadersPacked,
                                               angle::ParamCapture *paramCapture);
  void CaptureGetAttribLocation_name(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     const GLchar *name,
                                     angle::ParamCapture *paramCapture);
  void CaptureGetBooleanv_data(const State &glState,
                               bool isCallValid,
                               GLenum pname,
                               GLboolean *data,
                               angle::ParamCapture *paramCapture);
  void CaptureGetBufferParameteriv_params(const State &glState,
                                          bool isCallValid,
                                          BufferBinding targetPacked,
                                          GLenum pname,
                                          GLint *params,
                                          angle::ParamCapture *paramCapture);
  void CaptureGetFloatv_data(const State &glState,
                             bool isCallValid,
                             GLenum pname,
                             GLfloat *data,
                             angle::ParamCapture *paramCapture);
  void CaptureGetFramebufferAttachmentParameteriv_params(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum attachment,
                                                         GLenum pname,
                                                         GLint *params,
                                                         angle::ParamCapture *paramCapture);
  void CaptureGetIntegerv_data(const State &glState,
                               bool isCallValid,
                               GLenum pname,
                               GLint *data,
                               angle::ParamCapture *paramCapture);
  void CaptureGetProgramInfoLog_length(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *infoLog,
                                       angle::ParamCapture *paramCapture);
  void CaptureGetProgramInfoLog_infoLog(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLchar *infoLog,
                                        angle::ParamCapture *paramCapture);
  void CaptureGetProgramiv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
                                  GLenum pname,
                                  GLint *params,
                                  angle::ParamCapture *paramCapture);
  void CaptureGetRenderbufferParameteriv_params(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum pname,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
  void CaptureGetShaderInfoLog_length(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID shaderPacked,
                                      GLsizei bufSize,
                                      GLsizei *length,
                                      GLchar *infoLog,
                                      angle::ParamCapture *paramCapture);
  void CaptureGetShaderInfoLog_infoLog(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID shaderPacked,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *infoLog,
                                       angle::ParamCapture *paramCapture);
  void CaptureGetShaderPrecisionFormat_range(const State &glState,
                                             bool isCallValid,
                                             GLenum shadertype,
                                             GLenum precisiontype,
                                             GLint *range,
                                             GLint *precision,
                                             angle::ParamCapture *paramCapture);
  void CaptureGetShaderPrecisionFormat_precision(const State &glState,
                                                 bool isCallValid,
                                                 GLenum shadertype,
                                                 GLenum precisiontype,
                                                 GLint *range,
                                                 GLint *precision,
                                                 angle::ParamCapture *paramCapture);
  void CaptureGetShaderSource_length(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID shaderPacked,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *source,
                                     angle::ParamCapture *paramCapture);
  void CaptureGetShaderSource_source(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID shaderPacked,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *source,
                                     angle::ParamCapture *paramCapture);
  void CaptureGetShaderiv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID shaderPacked,
                                 GLenum pname,
                                 GLint *params,
                                 angle::ParamCapture *paramCapture);
  void CaptureGetTexParameterfv_params(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       GLfloat *params,
                                       angle::ParamCapture *paramCapture);
  void CaptureGetTexParameteriv_params(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       GLint *params,
                                       angle::ParamCapture *paramCapture);
  void CaptureGetUniformLocation_name(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      const GLchar *name,
                                      angle::ParamCapture *paramCapture);
  void CaptureGetUniformfv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
                                  UniformLocation locationPacked,
                                  GLfloat *params,
                                  angle::ParamCapture *paramCapture);
  void CaptureGetUniformiv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
                                  UniformLocation locationPacked,
                                  GLint *params,
                                  angle::ParamCapture *paramCapture);
  void CaptureGetVertexAttribPointerv_pointer(const State &glState,
                                              bool isCallValid,
                                              GLuint index,
                                              GLenum pname,
                                              void **pointer,
                                              angle::ParamCapture *paramCapture);
  void CaptureGetVertexAttribfv_params(const State &glState,
                                       bool isCallValid,
                                       GLuint index,
                                       GLenum pname,
                                       GLfloat *params,
                                       angle::ParamCapture *paramCapture);
  void CaptureGetVertexAttribiv_params(const State &glState,
                                       bool isCallValid,
                                       GLuint index,
                                       GLenum pname,
                                       GLint *params,
                                       angle::ParamCapture *paramCapture);
  void CaptureReadPixels_pixels(const State &glState,
                                bool isCallValid,
                                GLint x,
                                GLint y,
                                GLsizei width,
                                GLsizei height,
                                GLenum format,
                                GLenum type,
                                void *pixels,
                                angle::ParamCapture *paramCapture);
  void CaptureShaderBinary_shadersPacked(const State &glState,
                                         bool isCallValid,
                                         GLsizei count,
                                         const ShaderProgramID *shadersPacked,
                                         GLenum binaryFormat,
                                         const void *binary,
                                         GLsizei length,
                                         angle::ParamCapture *paramCapture);
  void CaptureShaderBinary_binary(const State &glState,
                                  bool isCallValid,
                                  GLsizei count,
                                  const ShaderProgramID *shadersPacked,
                                  GLenum binaryFormat,
                                  const void *binary,
                                  GLsizei length,
                                  angle::ParamCapture *paramCapture);
  void CaptureShaderSource_string(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID shaderPacked,
                                  GLsizei count,
                                  const GLchar *const *string,
                                  const GLint *length,
                                  angle::ParamCapture *paramCapture);
  void CaptureShaderSource_length(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID shaderPacked,
                                  GLsizei count,
                                  const GLchar *const *string,
                                  const GLint *length,
                                  angle::ParamCapture *paramCapture);
  void CaptureTexImage2D_pixels(const State &glState,
                                bool isCallValid,
                                TextureTarget targetPacked,
                                GLint level,
                                GLint internalformat,
                                GLsizei width,
                                GLsizei height,
                                GLint border,
                                GLenum format,
                                GLenum type,
                                const void *pixels,
                                angle::ParamCapture *paramCapture);
  void CaptureTexParameterfv_params(const State &glState,
                                    bool isCallValid,
                                    TextureType targetPacked,
                                    GLenum pname,
                                    const GLfloat *params,
                                    angle::ParamCapture *paramCapture);
  void CaptureTexParameteriv_params(const State &glState,
                                    bool isCallValid,
                                    TextureType targetPacked,
                                    GLenum pname,
                                    const GLint *params,
                                    angle::ParamCapture *paramCapture);
  void CaptureTexSubImage2D_pixels(const State &glState,
                                   bool isCallValid,
                                   TextureTarget targetPacked,
                                   GLint level,
                                   GLint xoffset,
                                   GLint yoffset,
                                   GLsizei width,
                                   GLsizei height,
                                   GLenum format,
                                   GLenum type,
                                   const void *pixels,
                                   angle::ParamCapture *paramCapture);
  void CaptureUniform1fv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform1iv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform2fv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform2iv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform3fv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform3iv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform4fv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniform4iv_value(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value,
                               angle::ParamCapture *paramCapture);
  void CaptureUniformMatrix2fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
  void CaptureUniformMatrix3fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
  void CaptureUniformMatrix4fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
  void CaptureVertexAttrib1fv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLfloat *v,
                                angle::ParamCapture *paramCapture);
  void CaptureVertexAttrib2fv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLfloat *v,
                                angle::ParamCapture *paramCapture);
  void CaptureVertexAttrib3fv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLfloat *v,
                                angle::ParamCapture *paramCapture);
  void CaptureVertexAttrib4fv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLfloat *v,
                                angle::ParamCapture *paramCapture);
  void CaptureVertexAttribPointer_pointer(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLint size,
                                          VertexAttribType typePacked,
                                          GLboolean normalized,
                                          GLsizei stride,
                                          const void *pointer,
                                          angle::ParamCapture *paramCapture);
  }  // namespace gl
  
  #endif  // LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_