// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// capture_gles_3_0_autogen.h:
//   Capture functions for the OpenGL ES 3.0 entry points.

#ifndef LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
#define LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_

#include "common/PackedEnums.h"
#include "libANGLE/FrameCapture.h"

namespace gl
{

// Method Captures

angle::CallCapture CaptureBeginQuery(const State &glState,
                                     bool isCallValid,
                                     QueryType targetPacked,
                                     QueryID idPacked);
angle::CallCapture CaptureBeginTransformFeedback(const State &glState,
                                                 bool isCallValid,
                                                 PrimitiveMode primitiveModePacked);
angle::CallCapture CaptureBindBufferBase(const State &glState,
                                         bool isCallValid,
                                         BufferBinding targetPacked,
                                         GLuint index,
                                         BufferID bufferPacked);
angle::CallCapture CaptureBindBufferRange(const State &glState,
                                          bool isCallValid,
                                          BufferBinding targetPacked,
                                          GLuint index,
                                          BufferID bufferPacked,
                                          GLintptr offset,
                                          GLsizeiptr size);
angle::CallCapture CaptureBindSampler(const State &glState,
                                      bool isCallValid,
                                      GLuint unit,
                                      SamplerID samplerPacked);
angle::CallCapture CaptureBindTransformFeedback(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                TransformFeedbackID idPacked);
angle::CallCapture CaptureBindVertexArray(const State &glState,
                                          bool isCallValid,
                                          VertexArrayID arrayPacked);
angle::CallCapture CaptureBlitFramebuffer(const State &glState,
                                          bool isCallValid,
                                          GLint srcX0,
                                          GLint srcY0,
                                          GLint srcX1,
                                          GLint srcY1,
                                          GLint dstX0,
                                          GLint dstY0,
                                          GLint dstX1,
                                          GLint dstY1,
                                          GLbitfield mask,
                                          GLenum filter);
angle::CallCapture CaptureClearBufferfi(const State &glState,
                                        bool isCallValid,
                                        GLenum buffer,
                                        GLint drawbuffer,
                                        GLfloat depth,
                                        GLint stencil);
angle::CallCapture CaptureClearBufferfv(const State &glState,
                                        bool isCallValid,
                                        GLenum buffer,
                                        GLint drawbuffer,
                                        const GLfloat *value);
angle::CallCapture CaptureClearBufferiv(const State &glState,
                                        bool isCallValid,
                                        GLenum buffer,
                                        GLint drawbuffer,
                                        const GLint *value);
angle::CallCapture CaptureClearBufferuiv(const State &glState,
                                         bool isCallValid,
                                         GLenum buffer,
                                         GLint drawbuffer,
                                         const GLuint *value);
angle::CallCapture CaptureClientWaitSync(const State &glState,
                                         bool isCallValid,
                                         GLsync sync,
                                         GLbitfield flags,
                                         GLuint64 timeout,
                                         GLenum returnValue);
angle::CallCapture CaptureCompressedTexImage3D(const State &glState,
                                               bool isCallValid,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               GLint border,
                                               GLsizei imageSize,
                                               const void *data);
angle::CallCapture CaptureCompressedTexSubImage3D(const State &glState,
                                                  bool isCallValid,
                                                  TextureTarget targetPacked,
                                                  GLint level,
                                                  GLint xoffset,
                                                  GLint yoffset,
                                                  GLint zoffset,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLsizei depth,
                                                  GLenum format,
                                                  GLsizei imageSize,
                                                  const void *data);
angle::CallCapture CaptureCopyBufferSubData(const State &glState,
                                            bool isCallValid,
                                            BufferBinding readTargetPacked,
                                            BufferBinding writeTargetPacked,
                                            GLintptr readOffset,
                                            GLintptr writeOffset,
                                            GLsizeiptr size);
angle::CallCapture CaptureCopyTexSubImage3D(const State &glState,
                                            bool isCallValid,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint zoffset,
                                            GLint x,
                                            GLint y,
                                            GLsizei width,
                                            GLsizei height);
angle::CallCapture CaptureDeleteQueries(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        const QueryID *idsPacked);
angle::CallCapture CaptureDeleteSamplers(const State &glState,
                                         bool isCallValid,
                                         GLsizei count,
                                         const SamplerID *samplersPacked);
angle::CallCapture CaptureDeleteSync(const State &glState, bool isCallValid, GLsync sync);
angle::CallCapture CaptureDeleteTransformFeedbacks(const State &glState,
                                                   bool isCallValid,
                                                   GLsizei n,
                                                   const TransformFeedbackID *idsPacked);
angle::CallCapture CaptureDeleteVertexArrays(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             const VertexArrayID *arraysPacked);
angle::CallCapture CaptureDrawArraysInstanced(const State &glState,
                                              bool isCallValid,
                                              PrimitiveMode modePacked,
                                              GLint first,
                                              GLsizei count,
                                              GLsizei instancecount);
angle::CallCapture CaptureDrawBuffers(const State &glState,
                                      bool isCallValid,
                                      GLsizei n,
                                      const GLenum *bufs);
angle::CallCapture CaptureDrawElementsInstanced(const State &glState,
                                                bool isCallValid,
                                                PrimitiveMode modePacked,
                                                GLsizei count,
                                                DrawElementsType typePacked,
                                                const void *indices,
                                                GLsizei instancecount);
angle::CallCapture CaptureDrawRangeElements(const State &glState,
                                            bool isCallValid,
                                            PrimitiveMode modePacked,
                                            GLuint start,
                                            GLuint end,
                                            GLsizei count,
                                            DrawElementsType typePacked,
                                            const void *indices);
angle::CallCapture CaptureEndQuery(const State &glState, bool isCallValid, QueryType targetPacked);
angle::CallCapture CaptureEndTransformFeedback(const State &glState, bool isCallValid);
angle::CallCapture CaptureFenceSync(const State &glState,
                                    bool isCallValid,
                                    GLenum condition,
                                    GLbitfield flags,
                                    GLsync returnValue);
angle::CallCapture CaptureFlushMappedBufferRange(const State &glState,
                                                 bool isCallValid,
                                                 BufferBinding targetPacked,
                                                 GLintptr offset,
                                                 GLsizeiptr length);
angle::CallCapture CaptureFramebufferTextureLayer(const State &glState,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum attachment,
                                                  TextureID texturePacked,
                                                  GLint level,
                                                  GLint layer);
angle::CallCapture CaptureGenQueries(const State &glState,
                                     bool isCallValid,
                                     GLsizei n,
                                     QueryID *idsPacked);
angle::CallCapture CaptureGenSamplers(const State &glState,
                                      bool isCallValid,
                                      GLsizei count,
                                      SamplerID *samplersPacked);
angle::CallCapture CaptureGenTransformFeedbacks(const State &glState,
                                                bool isCallValid,
                                                GLsizei n,
                                                TransformFeedbackID *idsPacked);
angle::CallCapture CaptureGenVertexArrays(const State &glState,
                                          bool isCallValid,
                                          GLsizei n,
                                          VertexArrayID *arraysPacked);
angle::CallCapture CaptureGetActiveUniformBlockName(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLuint uniformBlockIndex,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLchar *uniformBlockName);
angle::CallCapture CaptureGetActiveUniformBlockiv(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLuint uniformBlockIndex,
                                                  GLenum pname,
                                                  GLint *params);
angle::CallCapture CaptureGetActiveUniformsiv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              GLsizei uniformCount,
                                              const GLuint *uniformIndices,
                                              GLenum pname,
                                              GLint *params);
angle::CallCapture CaptureGetBufferParameteri64v(const State &glState,
                                                 bool isCallValid,
                                                 BufferBinding targetPacked,
                                                 GLenum pname,
                                                 GLint64 *params);
angle::CallCapture CaptureGetBufferPointerv(const State &glState,
                                            bool isCallValid,
                                            BufferBinding targetPacked,
                                            GLenum pname,
                                            void **params);
angle::CallCapture CaptureGetFragDataLocation(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              const GLchar *name,
                                              GLint returnValue);
angle::CallCapture CaptureGetInteger64i_v(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint index,
                                          GLint64 *data);
angle::CallCapture CaptureGetInteger64v(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLint64 *data);
angle::CallCapture CaptureGetIntegeri_v(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLuint index,
                                        GLint *data);
angle::CallCapture CaptureGetInternalformativ(const State &glState,
                                              bool isCallValid,
                                              GLenum target,
                                              GLenum internalformat,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLint *params);
angle::CallCapture CaptureGetProgramBinary(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLenum *binaryFormat,
                                           void *binary);
angle::CallCapture CaptureGetQueryObjectuiv(const State &glState,
                                            bool isCallValid,
                                            QueryID idPacked,
                                            GLenum pname,
                                            GLuint *params);
angle::CallCapture CaptureGetQueryiv(const State &glState,
                                     bool isCallValid,
                                     QueryType targetPacked,
                                     GLenum pname,
                                     GLint *params);
angle::CallCapture CaptureGetSamplerParameterfv(const State &glState,
                                                bool isCallValid,
                                                SamplerID samplerPacked,
                                                GLenum pname,
                                                GLfloat *params);
angle::CallCapture CaptureGetSamplerParameteriv(const State &glState,
                                                bool isCallValid,
                                                SamplerID samplerPacked,
                                                GLenum pname,
                                                GLint *params);
angle::CallCapture CaptureGetStringi(const State &glState,
                                     bool isCallValid,
                                     GLenum name,
                                     GLuint index,
                                     const GLubyte *returnValue);
angle::CallCapture CaptureGetSynciv(const State &glState,
                                    bool isCallValid,
                                    GLsync sync,
                                    GLenum pname,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *values);
angle::CallCapture CaptureGetTransformFeedbackVarying(const State &glState,
                                                      bool isCallValid,
                                                      ShaderProgramID programPacked,
                                                      GLuint index,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLsizei *size,
                                                      GLenum *type,
                                                      GLchar *name);
angle::CallCapture CaptureGetUniformBlockIndex(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               const GLchar *uniformBlockName,
                                               GLuint returnValue);
angle::CallCapture CaptureGetUniformIndices(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            GLsizei uniformCount,
                                            const GLchar *const *uniformNames,
                                            GLuint *uniformIndices);
angle::CallCapture CaptureGetUniformuiv(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
                                        GLint location,
                                        GLuint *params);
angle::CallCapture CaptureGetVertexAttribIiv(const State &glState,
                                             bool isCallValid,
                                             GLuint index,
                                             GLenum pname,
                                             GLint *params);
angle::CallCapture CaptureGetVertexAttribIuiv(const State &glState,
                                              bool isCallValid,
                                              GLuint index,
                                              GLenum pname,
                                              GLuint *params);
angle::CallCapture CaptureInvalidateFramebuffer(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLsizei numAttachments,
                                                const GLenum *attachments);
angle::CallCapture CaptureInvalidateSubFramebuffer(const State &glState,
                                                   bool isCallValid,
                                                   GLenum target,
                                                   GLsizei numAttachments,
                                                   const GLenum *attachments,
                                                   GLint x,
                                                   GLint y,
                                                   GLsizei width,
                                                   GLsizei height);
angle::CallCapture CaptureIsQuery(const State &glState,
                                  bool isCallValid,
                                  QueryID idPacked,
                                  GLboolean returnValue);
angle::CallCapture CaptureIsSampler(const State &glState,
                                    bool isCallValid,
                                    SamplerID samplerPacked,
                                    GLboolean returnValue);
angle::CallCapture CaptureIsSync(const State &glState,
                                 bool isCallValid,
                                 GLsync sync,
                                 GLboolean returnValue);
angle::CallCapture CaptureIsTransformFeedback(const State &glState,
                                              bool isCallValid,
                                              TransformFeedbackID idPacked,
                                              GLboolean returnValue);
angle::CallCapture CaptureIsVertexArray(const State &glState,
                                        bool isCallValid,
                                        VertexArrayID arrayPacked,
                                        GLboolean returnValue);
angle::CallCapture CaptureMapBufferRange(const State &glState,
                                         bool isCallValid,
                                         BufferBinding targetPacked,
                                         GLintptr offset,
                                         GLsizeiptr length,
                                         GLbitfield access,
                                         void *returnValue);
angle::CallCapture CapturePauseTransformFeedback(const State &glState, bool isCallValid);
angle::CallCapture CaptureProgramBinary(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
                                        GLenum binaryFormat,
                                        const void *binary,
                                        GLsizei length);
angle::CallCapture CaptureProgramParameteri(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            GLenum pname,
                                            GLint value);
angle::CallCapture CaptureReadBuffer(const State &glState, bool isCallValid, GLenum src);
angle::CallCapture CaptureRenderbufferStorageMultisample(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLsizei samples,
                                                         GLenum internalformat,
                                                         GLsizei width,
                                                         GLsizei height);
angle::CallCapture CaptureResumeTransformFeedback(const State &glState, bool isCallValid);
angle::CallCapture CaptureSamplerParameterf(const State &glState,
                                            bool isCallValid,
                                            SamplerID samplerPacked,
                                            GLenum pname,
                                            GLfloat param);
angle::CallCapture CaptureSamplerParameterfv(const State &glState,
                                             bool isCallValid,
                                             SamplerID samplerPacked,
                                             GLenum pname,
                                             const GLfloat *param);
angle::CallCapture CaptureSamplerParameteri(const State &glState,
                                            bool isCallValid,
                                            SamplerID samplerPacked,
                                            GLenum pname,
                                            GLint param);
angle::CallCapture CaptureSamplerParameteriv(const State &glState,
                                             bool isCallValid,
                                             SamplerID samplerPacked,
                                             GLenum pname,
                                             const GLint *param);
angle::CallCapture CaptureTexImage3D(const State &glState,
                                     bool isCallValid,
                                     TextureTarget targetPacked,
                                     GLint level,
                                     GLint internalformat,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLint border,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels);
angle::CallCapture CaptureTexStorage2D(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLsizei levels,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height);
angle::CallCapture CaptureTexStorage3D(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLsizei levels,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth);
angle::CallCapture CaptureTexSubImage3D(const State &glState,
                                        bool isCallValid,
                                        TextureTarget targetPacked,
                                        GLint level,
                                        GLint xoffset,
                                        GLint yoffset,
                                        GLint zoffset,
                                        GLsizei width,
                                        GLsizei height,
                                        GLsizei depth,
                                        GLenum format,
                                        GLenum type,
                                        const void *pixels);
angle::CallCapture CaptureTransformFeedbackVaryings(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLsizei count,
                                                    const GLchar *const *varyings,
                                                    GLenum bufferMode);
angle::CallCapture CaptureUniform1ui(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLuint v0);
angle::CallCapture CaptureUniform1uiv(const State &glState,
                                      bool isCallValid,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value);
angle::CallCapture CaptureUniform2ui(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLuint v0,
                                     GLuint v1);
angle::CallCapture CaptureUniform2uiv(const State &glState,
                                      bool isCallValid,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value);
angle::CallCapture CaptureUniform3ui(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLuint v0,
                                     GLuint v1,
                                     GLuint v2);
angle::CallCapture CaptureUniform3uiv(const State &glState,
                                      bool isCallValid,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value);
angle::CallCapture CaptureUniform4ui(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLuint v0,
                                     GLuint v1,
                                     GLuint v2,
                                     GLuint v3);
angle::CallCapture CaptureUniform4uiv(const State &glState,
                                      bool isCallValid,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value);
angle::CallCapture CaptureUniformBlockBinding(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              GLuint uniformBlockIndex,
                                              GLuint uniformBlockBinding);
angle::CallCapture CaptureUniformMatrix2x3fv(const State &glState,
                                             bool isCallValid,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
angle::CallCapture CaptureUniformMatrix2x4fv(const State &glState,
                                             bool isCallValid,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
angle::CallCapture CaptureUniformMatrix3x2fv(const State &glState,
                                             bool isCallValid,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
angle::CallCapture CaptureUniformMatrix3x4fv(const State &glState,
                                             bool isCallValid,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
angle::CallCapture CaptureUniformMatrix4x2fv(const State &glState,
                                             bool isCallValid,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
angle::CallCapture CaptureUniformMatrix4x3fv(const State &glState,
                                             bool isCallValid,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value);
angle::CallCapture CaptureUnmapBuffer(const State &glState,
                                      bool isCallValid,
                                      BufferBinding targetPacked,
                                      GLboolean returnValue);
angle::CallCapture CaptureVertexAttribDivisor(const State &glState,
                                              bool isCallValid,
                                              GLuint index,
                                              GLuint divisor);
angle::CallCapture CaptureVertexAttribI4i(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLint x,
                                          GLint y,
                                          GLint z,
                                          GLint w);
angle::CallCapture CaptureVertexAttribI4iv(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           const GLint *v);
angle::CallCapture CaptureVertexAttribI4ui(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           GLuint x,
                                           GLuint y,
                                           GLuint z,
                                           GLuint w);
angle::CallCapture CaptureVertexAttribI4uiv(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            const GLuint *v);
angle::CallCapture CaptureVertexAttribIPointer(const State &glState,
                                               bool isCallValid,
                                               GLuint index,
                                               GLint size,
                                               VertexAttribType typePacked,
                                               GLsizei stride,
                                               const void *pointer);
angle::CallCapture CaptureWaitSync(const State &glState,
                                   bool isCallValid,
                                   GLsync sync,
                                   GLbitfield flags,
                                   GLuint64 timeout);

// Parameter Captures

void CaptureClearBufferfv_value(const State &glState,
                                bool isCallValid,
                                GLenum buffer,
                                GLint drawbuffer,
                                const GLfloat *value,
                                angle::ParamCapture *paramCapture);
void CaptureClearBufferiv_value(const State &glState,
                                bool isCallValid,
                                GLenum buffer,
                                GLint drawbuffer,
                                const GLint *value,
                                angle::ParamCapture *paramCapture);
void CaptureClearBufferuiv_value(const State &glState,
                                 bool isCallValid,
                                 GLenum buffer,
                                 GLint drawbuffer,
                                 const GLuint *value,
                                 angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage3D_data(const State &glState,
                                      bool isCallValid,
                                      TextureTarget targetPacked,
                                      GLint level,
                                      GLenum internalformat,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLint border,
                                      GLsizei imageSize,
                                      const void *data,
                                      angle::ParamCapture *paramCapture);
void CaptureCompressedTexSubImage3D_data(const State &glState,
                                         bool isCallValid,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLenum format,
                                         GLsizei imageSize,
                                         const void *data,
                                         angle::ParamCapture *paramCapture);
void CaptureDeleteQueries_idsPacked(const State &glState,
                                    bool isCallValid,
                                    GLsizei n,
                                    const QueryID *idsPacked,
                                    angle::ParamCapture *paramCapture);
void CaptureDeleteSamplers_samplersPacked(const State &glState,
                                          bool isCallValid,
                                          GLsizei count,
                                          const SamplerID *samplersPacked,
                                          angle::ParamCapture *paramCapture);
void CaptureDeleteTransformFeedbacks_idsPacked(const State &glState,
                                               bool isCallValid,
                                               GLsizei n,
                                               const TransformFeedbackID *idsPacked,
                                               angle::ParamCapture *paramCapture);
void CaptureDeleteVertexArrays_arraysPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            const VertexArrayID *arraysPacked,
                                            angle::ParamCapture *paramCapture);
void CaptureDrawBuffers_bufs(const State &glState,
                             bool isCallValid,
                             GLsizei n,
                             const GLenum *bufs,
                             angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstanced_indices(const State &glState,
                                          bool isCallValid,
                                          PrimitiveMode modePacked,
                                          GLsizei count,
                                          DrawElementsType typePacked,
                                          const void *indices,
                                          GLsizei instancecount,
                                          angle::ParamCapture *paramCapture);
void CaptureDrawRangeElements_indices(const State &glState,
                                      bool isCallValid,
                                      PrimitiveMode modePacked,
                                      GLuint start,
                                      GLuint end,
                                      GLsizei count,
                                      DrawElementsType typePacked,
                                      const void *indices,
                                      angle::ParamCapture *paramCapture);
void CaptureGenQueries_idsPacked(const State &glState,
                                 bool isCallValid,
                                 GLsizei n,
                                 QueryID *idsPacked,
                                 angle::ParamCapture *paramCapture);
void CaptureGenSamplers_samplersPacked(const State &glState,
                                       bool isCallValid,
                                       GLsizei count,
                                       SamplerID *samplersPacked,
                                       angle::ParamCapture *paramCapture);
void CaptureGenTransformFeedbacks_idsPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            TransformFeedbackID *idsPacked,
                                            angle::ParamCapture *paramCapture);
void CaptureGenVertexArrays_arraysPacked(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         VertexArrayID *arraysPacked,
                                         angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockName_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLuint uniformBlockIndex,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *uniformBlockName,
                                             angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       GLuint uniformBlockIndex,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLchar *uniformBlockName,
                                                       angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockiv_params(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLuint uniformBlockIndex,
                                           GLenum pname,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLsizei uniformCount,
                                               const GLuint *uniformIndices,
                                               GLenum pname,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformsiv_params(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLsizei uniformCount,
                                       const GLuint *uniformIndices,
                                       GLenum pname,
                                       GLint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64v_params(const State &glState,
                                          bool isCallValid,
                                          BufferBinding targetPacked,
                                          GLenum pname,
                                          GLint64 *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetBufferPointerv_params(const State &glState,
                                     bool isCallValid,
                                     BufferBinding targetPacked,
                                     GLenum pname,
                                     void **params,
                                     angle::ParamCapture *paramCapture);
void CaptureGetFragDataLocation_name(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     const GLchar *name,
                                     angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_v_data(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLuint index,
                                 GLint64 *data,
                                 angle::ParamCapture *paramCapture);
void CaptureGetInteger64v_data(const State &glState,
                               bool isCallValid,
                               GLenum pname,
                               GLint64 *data,
                               angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_v_data(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               GLuint index,
                               GLint *data,
                               angle::ParamCapture *paramCapture);
void CaptureGetInternalformativ_params(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLenum internalformat,
                                       GLenum pname,
                                       GLsizei bufSize,
                                       GLint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureGetProgramBinary_length(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLenum *binaryFormat,
                                    void *binary,
                                    angle::ParamCapture *paramCapture);
void CaptureGetProgramBinary_binaryFormat(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID programPacked,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLenum *binaryFormat,
                                          void *binary,
                                          angle::ParamCapture *paramCapture);
void CaptureGetProgramBinary_binary(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLenum *binaryFormat,
                                    void *binary,
                                    angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuiv_params(const State &glState,
                                     bool isCallValid,
                                     QueryID idPacked,
                                     GLenum pname,
                                     GLuint *params,
                                     angle::ParamCapture *paramCapture);
void CaptureGetQueryiv_params(const State &glState,
                              bool isCallValid,
                              QueryType targetPacked,
                              GLenum pname,
                              GLint *params,
                              angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfv_params(const State &glState,
                                         bool isCallValid,
                                         SamplerID samplerPacked,
                                         GLenum pname,
                                         GLfloat *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameteriv_params(const State &glState,
                                         bool isCallValid,
                                         SamplerID samplerPacked,
                                         GLenum pname,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetSynciv_length(const State &glState,
                             bool isCallValid,
                             GLsync sync,
                             GLenum pname,
                             GLsizei bufSize,
                             GLsizei *length,
                             GLint *values,
                             angle::ParamCapture *paramCapture);
void CaptureGetSynciv_values(const State &glState,
                             bool isCallValid,
                             GLsync sync,
                             GLenum pname,
                             GLsizei bufSize,
                             GLsizei *length,
                             GLint *values,
                             angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbackVarying_length(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLsizei *size,
                                               GLenum *type,
                                               GLchar *name,
                                               angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbackVarying_size(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLsizei *size,
                                             GLenum *type,
                                             GLchar *name,
                                             angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbackVarying_type(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLsizei *size,
                                             GLenum *type,
                                             GLchar *name,
                                             angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbackVarying_name(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLsizei *size,
                                             GLenum *type,
                                             GLchar *name,
                                             angle::ParamCapture *paramCapture);
void CaptureGetUniformBlockIndex_uniformBlockName(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  const GLchar *uniformBlockName,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetUniformIndices_uniformNames(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLsizei uniformCount,
                                           const GLchar *const *uniformNames,
                                           GLuint *uniformIndices,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformIndices_uniformIndices(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLsizei uniformCount,
                                             const GLchar *const *uniformNames,
                                             GLuint *uniformIndices,
                                             angle::ParamCapture *paramCapture);
void CaptureGetUniformuiv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
                                 GLint location,
                                 GLuint *params,
                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIiv_params(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      GLenum pname,
                                      GLint *params,
                                      angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuiv_params(const State &glState,
                                       bool isCallValid,
                                       GLuint index,
                                       GLenum pname,
                                       GLuint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureInvalidateFramebuffer_attachments(const State &glState,
                                              bool isCallValid,
                                              GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum *attachments,
                                              angle::ParamCapture *paramCapture);
void CaptureInvalidateSubFramebuffer_attachments(const State &glState,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLsizei numAttachments,
                                                 const GLenum *attachments,
                                                 GLint x,
                                                 GLint y,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 angle::ParamCapture *paramCapture);
void CaptureProgramBinary_binary(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
                                 GLenum binaryFormat,
                                 const void *binary,
                                 GLsizei length,
                                 angle::ParamCapture *paramCapture);
void CaptureSamplerParameterfv_param(const State &glState,
                                     bool isCallValid,
                                     SamplerID samplerPacked,
                                     GLenum pname,
                                     const GLfloat *param,
                                     angle::ParamCapture *paramCapture);
void CaptureSamplerParameteriv_param(const State &glState,
                                     bool isCallValid,
                                     SamplerID samplerPacked,
                                     GLenum pname,
                                     const GLint *param,
                                     angle::ParamCapture *paramCapture);
void CaptureTexImage3D_pixels(const State &glState,
                              bool isCallValid,
                              TextureTarget targetPacked,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLsizei height,
                              GLsizei depth,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels,
                              angle::ParamCapture *paramCapture);
void CaptureTexSubImage3D_pixels(const State &glState,
                                 bool isCallValid,
                                 TextureTarget targetPacked,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint zoffset,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels,
                                 angle::ParamCapture *paramCapture);
void CaptureTransformFeedbackVaryings_varyings(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLsizei count,
                                               const GLchar *const *varyings,
                                               GLenum bufferMode,
                                               angle::ParamCapture *paramCapture);
void CaptureUniform1uiv_value(const State &glState,
                              bool isCallValid,
                              GLint location,
                              GLsizei count,
                              const GLuint *value,
                              angle::ParamCapture *paramCapture);
void CaptureUniform2uiv_value(const State &glState,
                              bool isCallValid,
                              GLint location,
                              GLsizei count,
                              const GLuint *value,
                              angle::ParamCapture *paramCapture);
void CaptureUniform3uiv_value(const State &glState,
                              bool isCallValid,
                              GLint location,
                              GLsizei count,
                              const GLuint *value,
                              angle::ParamCapture *paramCapture);
void CaptureUniform4uiv_value(const State &glState,
                              bool isCallValid,
                              GLint location,
                              GLsizei count,
                              const GLuint *value,
                              angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2x3fv_value(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2x4fv_value(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3x2fv_value(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3x4fv_value(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4x2fv_value(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4x3fv_value(const State &glState,
                                     bool isCallValid,
                                     GLint location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
void CaptureVertexAttribI4iv_v(const State &glState,
                               bool isCallValid,
                               GLuint index,
                               const GLint *v,
                               angle::ParamCapture *paramCapture);
void CaptureVertexAttribI4uiv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLuint *v,
                                angle::ParamCapture *paramCapture);
void CaptureVertexAttribIPointer_pointer(const State &glState,
                                         bool isCallValid,
                                         GLuint index,
                                         GLint size,
                                         VertexAttribType typePacked,
                                         GLsizei stride,
                                         const void *pointer,
                                         angle::ParamCapture *paramCapture);
}  // namespace gl

#endif  // LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
