// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2019 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/FrameCapture.h"

namespace gl
{
class Context;

// Method Captures

angle::CallCapture CaptureActiveTexture(const Context *context, bool isCallValid, GLenum texture);
angle::CallCapture CaptureAttachShader(const Context *context,
                                       bool isCallValid,
                                       GLuint program,
                                       GLuint shader);
angle::CallCapture CaptureBindAttribLocation(const Context *context,
                                             bool isCallValid,
                                             GLuint program,
                                             GLuint index,
                                             const GLchar *name);
angle::CallCapture CaptureBindBuffer(const Context *context,
                                     bool isCallValid,
                                     BufferBinding targetPacked,
                                     GLuint buffer);
angle::CallCapture CaptureBindFramebuffer(const Context *context,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint framebuffer);
angle::CallCapture CaptureBindRenderbuffer(const Context *context,
                                           bool isCallValid,
                                           GLenum target,
                                           GLuint renderbuffer);
angle::CallCapture CaptureBindTexture(const Context *context,
                                      bool isCallValid,
                                      TextureType targetPacked,
                                      GLuint texture);
angle::CallCapture CaptureBlendColor(const Context *context,
                                     bool isCallValid,
                                     GLfloat red,
                                     GLfloat green,
                                     GLfloat blue,
                                     GLfloat alpha);
angle::CallCapture CaptureBlendEquation(const Context *context, bool isCallValid, GLenum mode);
angle::CallCapture CaptureBlendEquationSeparate(const Context *context,
                                                bool isCallValid,
                                                GLenum modeRGB,
                                                GLenum modeAlpha);
angle::CallCapture CaptureBlendFunc(const Context *context,
                                    bool isCallValid,
                                    GLenum sfactor,
                                    GLenum dfactor);
angle::CallCapture CaptureBlendFuncSeparate(const Context *context,
                                            bool isCallValid,
                                            GLenum sfactorRGB,
                                            GLenum dfactorRGB,
                                            GLenum sfactorAlpha,
                                            GLenum dfactorAlpha);
angle::CallCapture CaptureBufferData(const Context *context,
                                     bool isCallValid,
                                     BufferBinding targetPacked,
                                     GLsizeiptr size,
                                     const void *data,
                                     BufferUsage usagePacked);
angle::CallCapture CaptureBufferSubData(const Context *context,
                                        bool isCallValid,
                                        BufferBinding targetPacked,
                                        GLintptr offset,
                                        GLsizeiptr size,
                                        const void *data);
angle::CallCapture CaptureCheckFramebufferStatus(const Context *context,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLenum returnValue);
angle::CallCapture CaptureClear(const Context *context, bool isCallValid, GLbitfield mask);
angle::CallCapture CaptureClearColor(const Context *context,
                                     bool isCallValid,
                                     GLfloat red,
                                     GLfloat green,
                                     GLfloat blue,
                                     GLfloat alpha);
angle::CallCapture CaptureClearDepthf(const Context *context, bool isCallValid, GLfloat d);
angle::CallCapture CaptureClearStencil(const Context *context, bool isCallValid, GLint s);
angle::CallCapture CaptureColorMask(const Context *context,
                                    bool isCallValid,
                                    GLboolean red,
                                    GLboolean green,
                                    GLboolean blue,
                                    GLboolean alpha);
angle::CallCapture CaptureCompileShader(const Context *context, bool isCallValid, GLuint shader);
angle::CallCapture CaptureCompressedTexImage2D(const Context *context,
                                               bool isCallValid,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLint border,
                                               GLsizei imageSize,
                                               const void *data);
angle::CallCapture CaptureCompressedTexSubImage2D(const Context *context,
                                                  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 Context *context,
                                         bool isCallValid,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         GLenum internalformat,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLint border);
angle::CallCapture CaptureCopyTexSubImage2D(const Context *context,
                                            bool isCallValid,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint x,
                                            GLint y,
                                            GLsizei width,
                                            GLsizei height);
angle::CallCapture CaptureCreateProgram(const Context *context,
                                        bool isCallValid,
                                        GLuint returnValue);
angle::CallCapture CaptureCreateShader(const Context *context,
                                       bool isCallValid,
                                       ShaderType typePacked,
                                       GLuint returnValue);
angle::CallCapture CaptureCullFace(const Context *context,
                                   bool isCallValid,
                                   CullFaceMode modePacked);
angle::CallCapture CaptureDeleteBuffers(const Context *context,
                                        bool isCallValid,
                                        GLsizei n,
                                        const GLuint *buffers);
angle::CallCapture CaptureDeleteFramebuffers(const Context *context,
                                             bool isCallValid,
                                             GLsizei n,
                                             const GLuint *framebuffers);
angle::CallCapture CaptureDeleteProgram(const Context *context, bool isCallValid, GLuint program);
angle::CallCapture CaptureDeleteRenderbuffers(const Context *context,
                                              bool isCallValid,
                                              GLsizei n,
                                              const GLuint *renderbuffers);
angle::CallCapture CaptureDeleteShader(const Context *context, bool isCallValid, GLuint shader);
angle::CallCapture CaptureDeleteTextures(const Context *context,
                                         bool isCallValid,
                                         GLsizei n,
                                         const GLuint *textures);
angle::CallCapture CaptureDepthFunc(const Context *context, bool isCallValid, GLenum func);
angle::CallCapture CaptureDepthMask(const Context *context, bool isCallValid, GLboolean flag);
angle::CallCapture CaptureDepthRangef(const Context *context,
                                      bool isCallValid,
                                      GLfloat n,
                                      GLfloat f);
angle::CallCapture CaptureDetachShader(const Context *context,
                                       bool isCallValid,
                                       GLuint program,
                                       GLuint shader);
angle::CallCapture CaptureDisable(const Context *context, bool isCallValid, GLenum cap);
angle::CallCapture CaptureDisableVertexAttribArray(const Context *context,
                                                   bool isCallValid,
                                                   GLuint index);
angle::CallCapture CaptureDrawArrays(const Context *context,
                                     bool isCallValid,
                                     PrimitiveMode modePacked,
                                     GLint first,
                                     GLsizei count);
angle::CallCapture CaptureDrawElements(const Context *context,
                                       bool isCallValid,
                                       PrimitiveMode modePacked,
                                       GLsizei count,
                                       DrawElementsType typePacked,
                                       const void *indices);
angle::CallCapture CaptureEnable(const Context *context, bool isCallValid, GLenum cap);
angle::CallCapture CaptureEnableVertexAttribArray(const Context *context,
                                                  bool isCallValid,
                                                  GLuint index);
angle::CallCapture CaptureFinish(const Context *context, bool isCallValid);
angle::CallCapture CaptureFlush(const Context *context, bool isCallValid);
angle::CallCapture CaptureFramebufferRenderbuffer(const Context *context,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum attachment,
                                                  GLenum renderbuffertarget,
                                                  GLuint renderbuffer);
angle::CallCapture CaptureFramebufferTexture2D(const Context *context,
                                               bool isCallValid,
                                               GLenum target,
                                               GLenum attachment,
                                               TextureTarget textargetPacked,
                                               GLuint texture,
                                               GLint level);
angle::CallCapture CaptureFrontFace(const Context *context, bool isCallValid, GLenum mode);
angle::CallCapture CaptureGenBuffers(const Context *context,
                                     bool isCallValid,
                                     GLsizei n,
                                     GLuint *buffers);
angle::CallCapture CaptureGenFramebuffers(const Context *context,
                                          bool isCallValid,
                                          GLsizei n,
                                          GLuint *framebuffers);
angle::CallCapture CaptureGenRenderbuffers(const Context *context,
                                           bool isCallValid,
                                           GLsizei n,
                                           GLuint *renderbuffers);
angle::CallCapture CaptureGenTextures(const Context *context,
                                      bool isCallValid,
                                      GLsizei n,
                                      GLuint *textures);
angle::CallCapture CaptureGenerateMipmap(const Context *context,
                                         bool isCallValid,
                                         TextureType targetPacked);
angle::CallCapture CaptureGetActiveAttrib(const Context *context,
                                          bool isCallValid,
                                          GLuint program,
                                          GLuint index,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *size,
                                          GLenum *type,
                                          GLchar *name);
angle::CallCapture CaptureGetActiveUniform(const Context *context,
                                           bool isCallValid,
                                           GLuint program,
                                           GLuint index,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *size,
                                           GLenum *type,
                                           GLchar *name);
angle::CallCapture CaptureGetAttachedShaders(const Context *context,
                                             bool isCallValid,
                                             GLuint program,
                                             GLsizei maxCount,
                                             GLsizei *count,
                                             GLuint *shaders);
angle::CallCapture CaptureGetAttribLocation(const Context *context,
                                            bool isCallValid,
                                            GLuint program,
                                            const GLchar *name,
                                            GLint returnValue);
angle::CallCapture CaptureGetBooleanv(const Context *context,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLboolean *data);
angle::CallCapture CaptureGetBufferParameteriv(const Context *context,
                                               bool isCallValid,
                                               BufferBinding targetPacked,
                                               GLenum pname,
                                               GLint *params);
angle::CallCapture CaptureGetError(const Context *context, bool isCallValid, GLenum returnValue);
angle::CallCapture CaptureGetFloatv(const Context *context,
                                    bool isCallValid,
                                    GLenum pname,
                                    GLfloat *data);
angle::CallCapture CaptureGetFramebufferAttachmentParameteriv(const Context *context,
                                                              bool isCallValid,
                                                              GLenum target,
                                                              GLenum attachment,
                                                              GLenum pname,
                                                              GLint *params);
angle::CallCapture CaptureGetIntegerv(const Context *context,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLint *data);
angle::CallCapture CaptureGetProgramInfoLog(const Context *context,
                                            bool isCallValid,
                                            GLuint program,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLchar *infoLog);
angle::CallCapture CaptureGetProgramiv(const Context *context,
                                       bool isCallValid,
                                       GLuint program,
                                       GLenum pname,
                                       GLint *params);
angle::CallCapture CaptureGetRenderbufferParameteriv(const Context *context,
                                                     bool isCallValid,
                                                     GLenum target,
                                                     GLenum pname,
                                                     GLint *params);
angle::CallCapture CaptureGetShaderInfoLog(const Context *context,
                                           bool isCallValid,
                                           GLuint shader,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLchar *infoLog);
angle::CallCapture CaptureGetShaderPrecisionFormat(const Context *context,
                                                   bool isCallValid,
                                                   GLenum shadertype,
                                                   GLenum precisiontype,
                                                   GLint *range,
                                                   GLint *precision);
angle::CallCapture CaptureGetShaderSource(const Context *context,
                                          bool isCallValid,
                                          GLuint shader,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLchar *source);
angle::CallCapture CaptureGetShaderiv(const Context *context,
                                      bool isCallValid,
                                      GLuint shader,
                                      GLenum pname,
                                      GLint *params);
angle::CallCapture CaptureGetString(const Context *context,
                                    bool isCallValid,
                                    GLenum name,
                                    const GLubyte *returnValue);
angle::CallCapture CaptureGetTexParameterfv(const Context *context,
                                            bool isCallValid,
                                            TextureType targetPacked,
                                            GLenum pname,
                                            GLfloat *params);
angle::CallCapture CaptureGetTexParameteriv(const Context *context,
                                            bool isCallValid,
                                            TextureType targetPacked,
                                            GLenum pname,
                                            GLint *params);
angle::CallCapture CaptureGetUniformLocation(const Context *context,
                                             bool isCallValid,
                                             GLuint program,
                                             const GLchar *name,
                                             GLint returnValue);
angle::CallCapture CaptureGetUniformfv(const Context *context,
                                       bool isCallValid,
                                       GLuint program,
                                       GLint location,
                                       GLfloat *params);
angle::CallCapture CaptureGetUniformiv(const Context *context,
                                       bool isCallValid,
                                       GLuint program,
                                       GLint location,
                                       GLint *params);
angle::CallCapture CaptureGetVertexAttribPointerv(const Context *context,
                                                  bool isCallValid,
                                                  GLuint index,
                                                  GLenum pname,
                                                  void **pointer);
angle::CallCapture CaptureGetVertexAttribfv(const Context *context,
                                            bool isCallValid,
                                            GLuint index,
                                            GLenum pname,
                                            GLfloat *params);
angle::CallCapture CaptureGetVertexAttribiv(const Context *context,
                                            bool isCallValid,
                                            GLuint index,
                                            GLenum pname,
                                            GLint *params);
angle::CallCapture CaptureHint(const Context *context,
                               bool isCallValid,
                               GLenum target,
                               GLenum mode);
angle::CallCapture CaptureIsBuffer(const Context *context,
                                   bool isCallValid,
                                   GLuint buffer,
                                   GLboolean returnValue);
angle::CallCapture CaptureIsEnabled(const Context *context,
                                    bool isCallValid,
                                    GLenum cap,
                                    GLboolean returnValue);
angle::CallCapture CaptureIsFramebuffer(const Context *context,
                                        bool isCallValid,
                                        GLuint framebuffer,
                                        GLboolean returnValue);
angle::CallCapture CaptureIsProgram(const Context *context,
                                    bool isCallValid,
                                    GLuint program,
                                    GLboolean returnValue);
angle::CallCapture CaptureIsRenderbuffer(const Context *context,
                                         bool isCallValid,
                                         GLuint renderbuffer,
                                         GLboolean returnValue);
angle::CallCapture CaptureIsShader(const Context *context,
                                   bool isCallValid,
                                   GLuint shader,
                                   GLboolean returnValue);
angle::CallCapture CaptureIsTexture(const Context *context,
                                    bool isCallValid,
                                    GLuint texture,
                                    GLboolean returnValue);
angle::CallCapture CaptureLineWidth(const Context *context, bool isCallValid, GLfloat width);
angle::CallCapture CaptureLinkProgram(const Context *context, bool isCallValid, GLuint program);
angle::CallCapture CapturePixelStorei(const Context *context,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLint param);
angle::CallCapture CapturePolygonOffset(const Context *context,
                                        bool isCallValid,
                                        GLfloat factor,
                                        GLfloat units);
angle::CallCapture CaptureReadPixels(const Context *context,
                                     bool isCallValid,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     void *pixels);
angle::CallCapture CaptureReleaseShaderCompiler(const Context *context, bool isCallValid);
angle::CallCapture CaptureRenderbufferStorage(const Context *context,
                                              bool isCallValid,
                                              GLenum target,
                                              GLenum internalformat,
                                              GLsizei width,
                                              GLsizei height);
angle::CallCapture CaptureSampleCoverage(const Context *context,
                                         bool isCallValid,
                                         GLfloat value,
                                         GLboolean invert);
angle::CallCapture CaptureScissor(const Context *context,
                                  bool isCallValid,
                                  GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLsizei height);
angle::CallCapture CaptureShaderBinary(const Context *context,
                                       bool isCallValid,
                                       GLsizei count,
                                       const GLuint *shaders,
                                       GLenum binaryformat,
                                       const void *binary,
                                       GLsizei length);
angle::CallCapture CaptureShaderSource(const Context *context,
                                       bool isCallValid,
                                       GLuint shader,
                                       GLsizei count,
                                       const GLchar *const *string,
                                       const GLint *length);
angle::CallCapture CaptureStencilFunc(const Context *context,
                                      bool isCallValid,
                                      GLenum func,
                                      GLint ref,
                                      GLuint mask);
angle::CallCapture CaptureStencilFuncSeparate(const Context *context,
                                              bool isCallValid,
                                              GLenum face,
                                              GLenum func,
                                              GLint ref,
                                              GLuint mask);
angle::CallCapture CaptureStencilMask(const Context *context, bool isCallValid, GLuint mask);
angle::CallCapture CaptureStencilMaskSeparate(const Context *context,
                                              bool isCallValid,
                                              GLenum face,
                                              GLuint mask);
angle::CallCapture CaptureStencilOp(const Context *context,
                                    bool isCallValid,
                                    GLenum fail,
                                    GLenum zfail,
                                    GLenum zpass);
angle::CallCapture CaptureStencilOpSeparate(const Context *context,
                                            bool isCallValid,
                                            GLenum face,
                                            GLenum sfail,
                                            GLenum dpfail,
                                            GLenum dppass);
angle::CallCapture CaptureTexImage2D(const Context *context,
                                     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 Context *context,
                                        bool isCallValid,
                                        TextureType targetPacked,
                                        GLenum pname,
                                        GLfloat param);
angle::CallCapture CaptureTexParameterfv(const Context *context,
                                         bool isCallValid,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         const GLfloat *params);
angle::CallCapture CaptureTexParameteri(const Context *context,
                                        bool isCallValid,
                                        TextureType targetPacked,
                                        GLenum pname,
                                        GLint param);
angle::CallCapture CaptureTexParameteriv(const Context *context,
                                         bool isCallValid,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         const GLint *params);
angle::CallCapture CaptureTexSubImage2D(const Context *context,
                                        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 Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0);
angle::CallCapture CaptureUniform1fv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform1i(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0);
angle::CallCapture CaptureUniform1iv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniform2f(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0,
                                    GLfloat v1);
angle::CallCapture CaptureUniform2fv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform2i(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0,
                                    GLint v1);
angle::CallCapture CaptureUniform2iv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniform3f(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0,
                                    GLfloat v1,
                                    GLfloat v2);
angle::CallCapture CaptureUniform3fv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform3i(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0,
                                    GLint v1,
                                    GLint v2);
angle::CallCapture CaptureUniform3iv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniform4f(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0,
                                    GLfloat v1,
                                    GLfloat v2,
                                    GLfloat v3);
angle::CallCapture CaptureUniform4fv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform4i(const Context *context,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0,
                                    GLint v1,
                                    GLint v2,
                                    GLint v3);
angle::CallCapture CaptureUniform4iv(const Context *context,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniformMatrix2fv(const Context *context,
                                           bool isCallValid,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value);
angle::CallCapture CaptureUniformMatrix3fv(const Context *context,
                                           bool isCallValid,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value);
angle::CallCapture CaptureUniformMatrix4fv(const Context *context,
                                           bool isCallValid,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value);
angle::CallCapture CaptureUseProgram(const Context *context, bool isCallValid, GLuint program);
angle::CallCapture CaptureValidateProgram(const Context *context, bool isCallValid, GLuint program);
angle::CallCapture CaptureVertexAttrib1f(const Context *context,
                                         bool isCallValid,
                                         GLuint index,
                                         GLfloat x);
angle::CallCapture CaptureVertexAttrib1fv(const Context *context,
                                          bool isCallValid,
                                          GLuint index,
                                          const GLfloat *v);
angle::CallCapture CaptureVertexAttrib2f(const Context *context,
                                         bool isCallValid,
                                         GLuint index,
                                         GLfloat x,
                                         GLfloat y);
angle::CallCapture CaptureVertexAttrib2fv(const Context *context,
                                          bool isCallValid,
                                          GLuint index,
                                          const GLfloat *v);
angle::CallCapture CaptureVertexAttrib3f(const Context *context,
                                         bool isCallValid,
                                         GLuint index,
                                         GLfloat x,
                                         GLfloat y,
                                         GLfloat z);
angle::CallCapture CaptureVertexAttrib3fv(const Context *context,
                                          bool isCallValid,
                                          GLuint index,
                                          const GLfloat *v);
angle::CallCapture CaptureVertexAttrib4f(const Context *context,
                                         bool isCallValid,
                                         GLuint index,
                                         GLfloat x,
                                         GLfloat y,
                                         GLfloat z,
                                         GLfloat w);
angle::CallCapture CaptureVertexAttrib4fv(const Context *context,
                                          bool isCallValid,
                                          GLuint index,
                                          const GLfloat *v);
angle::CallCapture CaptureVertexAttribPointer(const Context *context,
                                              bool isCallValid,
                                              GLuint index,
                                              GLint size,
                                              VertexAttribType typePacked,
                                              GLboolean normalized,
                                              GLsizei stride,
                                              const void *pointer);
angle::CallCapture CaptureViewport(const Context *context,
                                   bool isCallValid,
                                   GLint x,
                                   GLint y,
                                   GLsizei width,
                                   GLsizei height);

// Parameter Captures

void CaptureBindAttribLocation_name(const Context *context,
                                    bool isCallValid,
                                    GLuint program,
                                    GLuint index,
                                    const GLchar *name,
                                    angle::ParamCapture *paramCapture);
void CaptureBufferData_data(const Context *context,
                            bool isCallValid,
                            BufferBinding targetPacked,
                            GLsizeiptr size,
                            const void *data,
                            BufferUsage usagePacked,
                            angle::ParamCapture *paramCapture);
void CaptureBufferSubData_data(const Context *context,
                               bool isCallValid,
                               BufferBinding targetPacked,
                               GLintptr offset,
                               GLsizeiptr size,
                               const void *data,
                               angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage2D_data(const Context *context,
                                      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 Context *context,
                                         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_buffers(const Context *context,
                                  bool isCallValid,
                                  GLsizei n,
                                  const GLuint *buffers,
                                  angle::ParamCapture *paramCapture);
void CaptureDeleteFramebuffers_framebuffers(const Context *context,
                                            bool isCallValid,
                                            GLsizei n,
                                            const GLuint *framebuffers,
                                            angle::ParamCapture *paramCapture);
void CaptureDeleteRenderbuffers_renderbuffers(const Context *context,
                                              bool isCallValid,
                                              GLsizei n,
                                              const GLuint *renderbuffers,
                                              angle::ParamCapture *paramCapture);
void CaptureDeleteTextures_textures(const Context *context,
                                    bool isCallValid,
                                    GLsizei n,
                                    const GLuint *textures,
                                    angle::ParamCapture *paramCapture);
void CaptureDrawElements_indices(const Context *context,
                                 bool isCallValid,
                                 PrimitiveMode modePacked,
                                 GLsizei count,
                                 DrawElementsType typePacked,
                                 const void *indices,
                                 angle::ParamCapture *paramCapture);
void CaptureGenBuffers_buffers(const Context *context,
                               bool isCallValid,
                               GLsizei n,
                               GLuint *buffers,
                               angle::ParamCapture *paramCapture);
void CaptureGenFramebuffers_framebuffers(const Context *context,
                                         bool isCallValid,
                                         GLsizei n,
                                         GLuint *framebuffers,
                                         angle::ParamCapture *paramCapture);
void CaptureGenRenderbuffers_renderbuffers(const Context *context,
                                           bool isCallValid,
                                           GLsizei n,
                                           GLuint *renderbuffers,
                                           angle::ParamCapture *paramCapture);
void CaptureGenTextures_textures(const Context *context,
                                 bool isCallValid,
                                 GLsizei n,
                                 GLuint *textures,
                                 angle::ParamCapture *paramCapture);
void CaptureGetActiveAttrib_length(const Context *context,
                                   bool isCallValid,
                                   GLuint program,
                                   GLuint index,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name,
                                   angle::ParamCapture *paramCapture);
void CaptureGetActiveAttrib_size(const Context *context,
                                 bool isCallValid,
                                 GLuint program,
                                 GLuint index,
                                 GLsizei bufSize,
                                 GLsizei *length,
                                 GLint *size,
                                 GLenum *type,
                                 GLchar *name,
                                 angle::ParamCapture *paramCapture);
void CaptureGetActiveAttrib_type(const Context *context,
                                 bool isCallValid,
                                 GLuint program,
                                 GLuint index,
                                 GLsizei bufSize,
                                 GLsizei *length,
                                 GLint *size,
                                 GLenum *type,
                                 GLchar *name,
                                 angle::ParamCapture *paramCapture);
void CaptureGetActiveAttrib_name(const Context *context,
                                 bool isCallValid,
                                 GLuint program,
                                 GLuint index,
                                 GLsizei bufSize,
                                 GLsizei *length,
                                 GLint *size,
                                 GLenum *type,
                                 GLchar *name,
                                 angle::ParamCapture *paramCapture);
void CaptureGetActiveUniform_length(const Context *context,
                                    bool isCallValid,
                                    GLuint program,
                                    GLuint index,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *size,
                                    GLenum *type,
                                    GLchar *name,
                                    angle::ParamCapture *paramCapture);
void CaptureGetActiveUniform_size(const Context *context,
                                  bool isCallValid,
                                  GLuint program,
                                  GLuint index,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLint *size,
                                  GLenum *type,
                                  GLchar *name,
                                  angle::ParamCapture *paramCapture);
void CaptureGetActiveUniform_type(const Context *context,
                                  bool isCallValid,
                                  GLuint program,
                                  GLuint index,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLint *size,
                                  GLenum *type,
                                  GLchar *name,
                                  angle::ParamCapture *paramCapture);
void CaptureGetActiveUniform_name(const Context *context,
                                  bool isCallValid,
                                  GLuint program,
                                  GLuint index,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLint *size,
                                  GLenum *type,
                                  GLchar *name,
                                  angle::ParamCapture *paramCapture);
void CaptureGetAttachedShaders_count(const Context *context,
                                     bool isCallValid,
                                     GLuint program,
                                     GLsizei maxCount,
                                     GLsizei *count,
                                     GLuint *shaders,
                                     angle::ParamCapture *paramCapture);
void CaptureGetAttachedShaders_shaders(const Context *context,
                                       bool isCallValid,
                                       GLuint program,
                                       GLsizei maxCount,
                                       GLsizei *count,
                                       GLuint *shaders,
                                       angle::ParamCapture *paramCapture);
void CaptureGetAttribLocation_name(const Context *context,
                                   bool isCallValid,
                                   GLuint program,
                                   const GLchar *name,
                                   angle::ParamCapture *paramCapture);
void CaptureGetBooleanv_data(const Context *context,
                             bool isCallValid,
                             GLenum pname,
                             GLboolean *data,
                             angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteriv_params(const Context *context,
                                        bool isCallValid,
                                        BufferBinding targetPacked,
                                        GLenum pname,
                                        GLint *params,
                                        angle::ParamCapture *paramCapture);
void CaptureGetFloatv_data(const Context *context,
                           bool isCallValid,
                           GLenum pname,
                           GLfloat *data,
                           angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameteriv_params(const Context *context,
                                                       bool isCallValid,
                                                       GLenum target,
                                                       GLenum attachment,
                                                       GLenum pname,
                                                       GLint *params,
                                                       angle::ParamCapture *paramCapture);
void CaptureGetIntegerv_data(const Context *context,
                             bool isCallValid,
                             GLenum pname,
                             GLint *data,
                             angle::ParamCapture *paramCapture);
void CaptureGetProgramInfoLog_length(const Context *context,
                                     bool isCallValid,
                                     GLuint program,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *infoLog,
                                     angle::ParamCapture *paramCapture);
void CaptureGetProgramInfoLog_infoLog(const Context *context,
                                      bool isCallValid,
                                      GLuint program,
                                      GLsizei bufSize,
                                      GLsizei *length,
                                      GLchar *infoLog,
                                      angle::ParamCapture *paramCapture);
void CaptureGetProgramiv_params(const Context *context,
                                bool isCallValid,
                                GLuint program,
                                GLenum pname,
                                GLint *params,
                                angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameteriv_params(const Context *context,
                                              bool isCallValid,
                                              GLenum target,
                                              GLenum pname,
                                              GLint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetShaderInfoLog_length(const Context *context,
                                    bool isCallValid,
                                    GLuint shader,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *infoLog,
                                    angle::ParamCapture *paramCapture);
void CaptureGetShaderInfoLog_infoLog(const Context *context,
                                     bool isCallValid,
                                     GLuint shader,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *infoLog,
                                     angle::ParamCapture *paramCapture);
void CaptureGetShaderPrecisionFormat_range(const Context *context,
                                           bool isCallValid,
                                           GLenum shadertype,
                                           GLenum precisiontype,
                                           GLint *range,
                                           GLint *precision,
                                           angle::ParamCapture *paramCapture);
void CaptureGetShaderPrecisionFormat_precision(const Context *context,
                                               bool isCallValid,
                                               GLenum shadertype,
                                               GLenum precisiontype,
                                               GLint *range,
                                               GLint *precision,
                                               angle::ParamCapture *paramCapture);
void CaptureGetShaderSource_length(const Context *context,
                                   bool isCallValid,
                                   GLuint shader,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLchar *source,
                                   angle::ParamCapture *paramCapture);
void CaptureGetShaderSource_source(const Context *context,
                                   bool isCallValid,
                                   GLuint shader,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLchar *source,
                                   angle::ParamCapture *paramCapture);
void CaptureGetShaderiv_params(const Context *context,
                               bool isCallValid,
                               GLuint shader,
                               GLenum pname,
                               GLint *params,
                               angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfv_params(const Context *context,
                                     bool isCallValid,
                                     TextureType targetPacked,
                                     GLenum pname,
                                     GLfloat *params,
                                     angle::ParamCapture *paramCapture);
void CaptureGetTexParameteriv_params(const Context *context,
                                     bool isCallValid,
                                     TextureType targetPacked,
                                     GLenum pname,
                                     GLint *params,
                                     angle::ParamCapture *paramCapture);
void CaptureGetUniformLocation_name(const Context *context,
                                    bool isCallValid,
                                    GLuint program,
                                    const GLchar *name,
                                    angle::ParamCapture *paramCapture);
void CaptureGetUniformfv_params(const Context *context,
                                bool isCallValid,
                                GLuint program,
                                GLint location,
                                GLfloat *params,
                                angle::ParamCapture *paramCapture);
void CaptureGetUniformiv_params(const Context *context,
                                bool isCallValid,
                                GLuint program,
                                GLint location,
                                GLint *params,
                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointerv_pointer(const Context *context,
                                            bool isCallValid,
                                            GLuint index,
                                            GLenum pname,
                                            void **pointer,
                                            angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfv_params(const Context *context,
                                     bool isCallValid,
                                     GLuint index,
                                     GLenum pname,
                                     GLfloat *params,
                                     angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribiv_params(const Context *context,
                                     bool isCallValid,
                                     GLuint index,
                                     GLenum pname,
                                     GLint *params,
                                     angle::ParamCapture *paramCapture);
void CaptureReadPixels_pixels(const Context *context,
                              bool isCallValid,
                              GLint x,
                              GLint y,
                              GLsizei width,
                              GLsizei height,
                              GLenum format,
                              GLenum type,
                              void *pixels,
                              angle::ParamCapture *paramCapture);
void CaptureShaderBinary_shaders(const Context *context,
                                 bool isCallValid,
                                 GLsizei count,
                                 const GLuint *shaders,
                                 GLenum binaryformat,
                                 const void *binary,
                                 GLsizei length,
                                 angle::ParamCapture *paramCapture);
void CaptureShaderBinary_binary(const Context *context,
                                bool isCallValid,
                                GLsizei count,
                                const GLuint *shaders,
                                GLenum binaryformat,
                                const void *binary,
                                GLsizei length,
                                angle::ParamCapture *paramCapture);
void CaptureShaderSource_string(const Context *context,
                                bool isCallValid,
                                GLuint shader,
                                GLsizei count,
                                const GLchar *const *string,
                                const GLint *length,
                                angle::ParamCapture *paramCapture);
void CaptureShaderSource_length(const Context *context,
                                bool isCallValid,
                                GLuint shader,
                                GLsizei count,
                                const GLchar *const *string,
                                const GLint *length,
                                angle::ParamCapture *paramCapture);
void CaptureTexImage2D_pixels(const Context *context,
                              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 Context *context,
                                  bool isCallValid,
                                  TextureType targetPacked,
                                  GLenum pname,
                                  const GLfloat *params,
                                  angle::ParamCapture *paramCapture);
void CaptureTexParameteriv_params(const Context *context,
                                  bool isCallValid,
                                  TextureType targetPacked,
                                  GLenum pname,
                                  const GLint *params,
                                  angle::ParamCapture *paramCapture);
void CaptureTexSubImage2D_pixels(const Context *context,
                                 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 Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform1iv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform2fv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform2iv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform3fv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform3iv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform4fv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform4iv_value(const Context *context,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2fv_value(const Context *context,
                                   bool isCallValid,
                                   GLint location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3fv_value(const Context *context,
                                   bool isCallValid,
                                   GLint location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4fv_value(const Context *context,
                                   bool isCallValid,
                                   GLint location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *value,
                                   angle::ParamCapture *paramCapture);
void CaptureVertexAttrib1fv_v(const Context *context,
                              bool isCallValid,
                              GLuint index,
                              const GLfloat *v,
                              angle::ParamCapture *paramCapture);
void CaptureVertexAttrib2fv_v(const Context *context,
                              bool isCallValid,
                              GLuint index,
                              const GLfloat *v,
                              angle::ParamCapture *paramCapture);
void CaptureVertexAttrib3fv_v(const Context *context,
                              bool isCallValid,
                              GLuint index,
                              const GLfloat *v,
                              angle::ParamCapture *paramCapture);
void CaptureVertexAttrib4fv_v(const Context *context,
                              bool isCallValid,
                              GLuint index,
                              const GLfloat *v,
                              angle::ParamCapture *paramCapture);
void CaptureVertexAttribPointer_pointer(const Context *context,
                                        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_
