// 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
{

// 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,
                                       GLint location,
                                       GLfloat *params);
angle::CallCapture CaptureGetUniformiv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLint location,
                                       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,
                                    GLint location,
                                    GLfloat v0);
angle::CallCapture CaptureUniform1fv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform1i(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0);
angle::CallCapture CaptureUniform1iv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniform2f(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0,
                                    GLfloat v1);
angle::CallCapture CaptureUniform2fv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform2i(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0,
                                    GLint v1);
angle::CallCapture CaptureUniform2iv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniform3f(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0,
                                    GLfloat v1,
                                    GLfloat v2);
angle::CallCapture CaptureUniform3fv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform3i(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0,
                                    GLint v1,
                                    GLint v2);
angle::CallCapture CaptureUniform3iv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniform4f(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLfloat v0,
                                    GLfloat v1,
                                    GLfloat v2,
                                    GLfloat v3);
angle::CallCapture CaptureUniform4fv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value);
angle::CallCapture CaptureUniform4i(const State &glState,
                                    bool isCallValid,
                                    GLint location,
                                    GLint v0,
                                    GLint v1,
                                    GLint v2,
                                    GLint v3);
angle::CallCapture CaptureUniform4iv(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value);
angle::CallCapture CaptureUniformMatrix2fv(const State &glState,
                                           bool isCallValid,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value);
angle::CallCapture CaptureUniformMatrix3fv(const State &glState,
                                           bool isCallValid,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value);
angle::CallCapture CaptureUniformMatrix4fv(const State &glState,
                                           bool isCallValid,
                                           GLint location,
                                           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,
                                GLint location,
                                GLfloat *params,
                                angle::ParamCapture *paramCapture);
void CaptureGetUniformiv_params(const State &glState,
                                bool isCallValid,
                                ShaderProgramID programPacked,
                                GLint location,
                                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,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform1iv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform2fv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform2iv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform3fv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform3iv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform4fv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLfloat *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform4iv_value(const State &glState,
                             bool isCallValid,
                             GLint location,
                             GLsizei count,
                             const GLint *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2fv_value(const State &glState,
                                   bool isCallValid,
                                   GLint location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3fv_value(const State &glState,
                                   bool isCallValid,
                                   GLint location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4fv_value(const State &glState,
                                   bool isCallValid,
                                   GLint location,
                                   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_