// 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_gl_4_autogen.h:
//   Capture functions for the OpenGL ES Desktop GL 4.x entry points.

#ifndef LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
#define LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_

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

namespace gl
{

// Method Captures

// GL 4.0
angle::CallCapture CaptureBeginQueryIndexed(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLuint index,
                                            QueryID idPacked);
angle::CallCapture CaptureDrawTransformFeedback(const State &glState,
                                                bool isCallValid,
                                                GLenum mode,
                                                TransformFeedbackID idPacked);
angle::CallCapture CaptureDrawTransformFeedbackStream(const State &glState,
                                                      bool isCallValid,
                                                      GLenum mode,
                                                      TransformFeedbackID idPacked,
                                                      GLuint stream);
angle::CallCapture CaptureEndQueryIndexed(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint index);
angle::CallCapture CaptureGetActiveSubroutineName(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum shadertype,
                                                  GLuint index,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLchar *name);
angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState,
                                                         bool isCallValid,
                                                         ShaderProgramID programPacked,
                                                         GLenum shadertype,
                                                         GLuint index,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLchar *name);
angle::CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       GLenum shadertype,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLint *values);
angle::CallCapture CaptureGetProgramStageiv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            GLenum shadertype,
                                            GLenum pname,
                                            GLint *values);
angle::CallCapture CaptureGetQueryIndexediv(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLuint index,
                                            GLenum pname,
                                            GLint *params);
angle::CallCapture CaptureGetSubroutineIndex(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLenum shadertype,
                                             const GLchar *name,
                                             GLuint returnValue);
angle::CallCapture CaptureGetSubroutineUniformLocation(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       GLenum shadertype,
                                                       const GLchar *name,
                                                       GLint returnValue);
angle::CallCapture CaptureGetUniformSubroutineuiv(const State &glState,
                                                  bool isCallValid,
                                                  GLenum shadertype,
                                                  GLint location,
                                                  GLuint *params);
angle::CallCapture CaptureGetUniformdv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLdouble *params);
angle::CallCapture CapturePatchParameterfv(const State &glState,
                                           bool isCallValid,
                                           GLenum pname,
                                           const GLfloat *values);
angle::CallCapture CaptureUniform1d(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLdouble x);
angle::CallCapture CaptureUniform1dv(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value);
angle::CallCapture CaptureUniform2d(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLdouble x,
                                    GLdouble y);
angle::CallCapture CaptureUniform2dv(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value);
angle::CallCapture CaptureUniform3d(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLdouble x,
                                    GLdouble y,
                                    GLdouble z);
angle::CallCapture CaptureUniform3dv(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value);
angle::CallCapture CaptureUniform4d(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLdouble x,
                                    GLdouble y,
                                    GLdouble z,
                                    GLdouble w);
angle::CallCapture CaptureUniform4dv(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value);
angle::CallCapture CaptureUniformMatrix2dv(const State &glState,
                                           bool isCallValid,
                                           UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value);
angle::CallCapture CaptureUniformMatrix2x3dv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value);
angle::CallCapture CaptureUniformMatrix2x4dv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value);
angle::CallCapture CaptureUniformMatrix3dv(const State &glState,
                                           bool isCallValid,
                                           UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value);
angle::CallCapture CaptureUniformMatrix3x2dv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value);
angle::CallCapture CaptureUniformMatrix3x4dv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value);
angle::CallCapture CaptureUniformMatrix4dv(const State &glState,
                                           bool isCallValid,
                                           UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value);
angle::CallCapture CaptureUniformMatrix4x2dv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value);
angle::CallCapture CaptureUniformMatrix4x3dv(const State &glState,
                                             bool isCallValid,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value);
angle::CallCapture CaptureUniformSubroutinesuiv(const State &glState,
                                                bool isCallValid,
                                                GLenum shadertype,
                                                GLsizei count,
                                                const GLuint *indices);

// GL 4.1
angle::CallCapture CaptureDepthRangeArrayv(const State &glState,
                                           bool isCallValid,
                                           GLuint first,
                                           GLsizei count,
                                           const GLdouble *v);
angle::CallCapture CaptureDepthRangeIndexed(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            GLdouble n,
                                            GLdouble f);
angle::CallCapture CaptureGetDoublei_v(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLuint index,
                                       GLdouble *data);
angle::CallCapture CaptureGetFloati_v(const State &glState,
                                      bool isCallValid,
                                      GLenum target,
                                      GLuint index,
                                      GLfloat *data);
angle::CallCapture CaptureGetVertexAttribLdv(const State &glState,
                                             bool isCallValid,
                                             GLuint index,
                                             GLenum pname,
                                             GLdouble *params);
angle::CallCapture CaptureProgramUniform1d(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLdouble v0);
angle::CallCapture CaptureProgramUniform1dv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            const GLdouble *value);
angle::CallCapture CaptureProgramUniform2d(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLdouble v0,
                                           GLdouble v1);
angle::CallCapture CaptureProgramUniform2dv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            const GLdouble *value);
angle::CallCapture CaptureProgramUniform3d(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLdouble v0,
                                           GLdouble v1,
                                           GLdouble v2);
angle::CallCapture CaptureProgramUniform3dv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            const GLdouble *value);
angle::CallCapture CaptureProgramUniform4d(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLdouble v0,
                                           GLdouble v1,
                                           GLdouble v2,
                                           GLdouble v3);
angle::CallCapture CaptureProgramUniform4dv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix2dv(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  UniformLocation locationPacked,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei count,
                                                    GLboolean transpose,
                                                    const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei count,
                                                    GLboolean transpose,
                                                    const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix3dv(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  UniformLocation locationPacked,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei count,
                                                    GLboolean transpose,
                                                    const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei count,
                                                    GLboolean transpose,
                                                    const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix4dv(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  UniformLocation locationPacked,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei count,
                                                    GLboolean transpose,
                                                    const GLdouble *value);
angle::CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei count,
                                                    GLboolean transpose,
                                                    const GLdouble *value);
angle::CallCapture CaptureScissorArrayv(const State &glState,
                                        bool isCallValid,
                                        GLuint first,
                                        GLsizei count,
                                        const GLint *v);
angle::CallCapture CaptureScissorIndexed(const State &glState,
                                         bool isCallValid,
                                         GLuint index,
                                         GLint left,
                                         GLint bottom,
                                         GLsizei width,
                                         GLsizei height);
angle::CallCapture CaptureScissorIndexedv(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          const GLint *v);
angle::CallCapture CaptureVertexAttribL1d(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLdouble x);
angle::CallCapture CaptureVertexAttribL1dv(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           const GLdouble *v);
angle::CallCapture CaptureVertexAttribL2d(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLdouble x,
                                          GLdouble y);
angle::CallCapture CaptureVertexAttribL2dv(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           const GLdouble *v);
angle::CallCapture CaptureVertexAttribL3d(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLdouble x,
                                          GLdouble y,
                                          GLdouble z);
angle::CallCapture CaptureVertexAttribL3dv(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           const GLdouble *v);
angle::CallCapture CaptureVertexAttribL4d(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLdouble x,
                                          GLdouble y,
                                          GLdouble z,
                                          GLdouble w);
angle::CallCapture CaptureVertexAttribL4dv(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           const GLdouble *v);
angle::CallCapture CaptureVertexAttribLPointer(const State &glState,
                                               bool isCallValid,
                                               GLuint index,
                                               GLint size,
                                               GLenum type,
                                               GLsizei stride,
                                               const void *pointer);
angle::CallCapture CaptureViewportArrayv(const State &glState,
                                         bool isCallValid,
                                         GLuint first,
                                         GLsizei count,
                                         const GLfloat *v);
angle::CallCapture CaptureViewportIndexedf(const State &glState,
                                           bool isCallValid,
                                           GLuint index,
                                           GLfloat x,
                                           GLfloat y,
                                           GLfloat w,
                                           GLfloat h);
angle::CallCapture CaptureViewportIndexedfv(const State &glState,
                                            bool isCallValid,
                                            GLuint index,
                                            const GLfloat *v);

// GL 4.2
angle::CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
                                                          bool isCallValid,
                                                          PrimitiveMode modePacked,
                                                          GLint first,
                                                          GLsizei count,
                                                          GLsizei instancecount,
                                                          GLuint baseinstance);
angle::CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState,
                                                            bool isCallValid,
                                                            PrimitiveMode modePacked,
                                                            GLsizei count,
                                                            DrawElementsType typePacked,
                                                            const void *indices,
                                                            GLsizei instancecount,
                                                            GLuint baseinstance);
angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState,
                                                                      bool isCallValid,
                                                                      PrimitiveMode modePacked,
                                                                      GLsizei count,
                                                                      DrawElementsType typePacked,
                                                                      const void *indices,
                                                                      GLsizei instancecount,
                                                                      GLint basevertex,
                                                                      GLuint baseinstance);
angle::CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState,
                                                         bool isCallValid,
                                                         GLenum mode,
                                                         TransformFeedbackID idPacked,
                                                         GLsizei instancecount);
angle::CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState,
                                                               bool isCallValid,
                                                               GLenum mode,
                                                               TransformFeedbackID idPacked,
                                                               GLuint stream,
                                                               GLsizei instancecount);
angle::CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState,
                                                         bool isCallValid,
                                                         ShaderProgramID programPacked,
                                                         GLuint bufferIndex,
                                                         GLenum pname,
                                                         GLint *params);
angle::CallCapture CaptureTexStorage1D(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLsizei levels,
                                       GLenum internalformat,
                                       GLsizei width);

// GL 4.3
angle::CallCapture CaptureClearBufferData(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLenum internalformat,
                                          GLenum format,
                                          GLenum type,
                                          const void *data);
angle::CallCapture CaptureClearBufferSubData(const State &glState,
                                             bool isCallValid,
                                             GLenum target,
                                             GLenum internalformat,
                                             GLintptr offset,
                                             GLsizeiptr size,
                                             GLenum format,
                                             GLenum type,
                                             const void *data);
angle::CallCapture CaptureGetInternalformati64v(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum internalformat,
                                                GLenum pname,
                                                GLsizei count,
                                                GLint64 *params);
angle::CallCapture CaptureGetProgramResourceLocationIndex(const State &glState,
                                                          bool isCallValid,
                                                          ShaderProgramID programPacked,
                                                          GLenum programInterface,
                                                          const GLchar *name,
                                                          GLint returnValue);
angle::CallCapture CaptureInvalidateBufferData(const State &glState,
                                               bool isCallValid,
                                               BufferID bufferPacked);
angle::CallCapture CaptureInvalidateBufferSubData(const State &glState,
                                                  bool isCallValid,
                                                  BufferID bufferPacked,
                                                  GLintptr offset,
                                                  GLsizeiptr length);
angle::CallCapture CaptureInvalidateTexImage(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLint level);
angle::CallCapture CaptureInvalidateTexSubImage(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth);
angle::CallCapture CaptureMultiDrawArraysIndirect(const State &glState,
                                                  bool isCallValid,
                                                  PrimitiveMode modePacked,
                                                  const void *indirect,
                                                  GLsizei drawcount,
                                                  GLsizei stride);
angle::CallCapture CaptureMultiDrawElementsIndirect(const State &glState,
                                                    bool isCallValid,
                                                    PrimitiveMode modePacked,
                                                    DrawElementsType typePacked,
                                                    const void *indirect,
                                                    GLsizei drawcount,
                                                    GLsizei stride);
angle::CallCapture CaptureShaderStorageBlockBinding(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLuint storageBlockIndex,
                                                    GLuint storageBlockBinding);
angle::CallCapture CaptureTextureView(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLenum target,
                                      GLuint origtexture,
                                      GLenum internalformat,
                                      GLuint minlevel,
                                      GLuint numlevels,
                                      GLuint minlayer,
                                      GLuint numlayers);
angle::CallCapture CaptureVertexAttribLFormat(const State &glState,
                                              bool isCallValid,
                                              GLuint attribindex,
                                              GLint size,
                                              GLenum type,
                                              GLuint relativeoffset);

// GL 4.4
angle::CallCapture CaptureBindBuffersBase(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint first,
                                          GLsizei count,
                                          const BufferID *buffersPacked);
angle::CallCapture CaptureBindBuffersRange(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           GLuint first,
                                           GLsizei count,
                                           const BufferID *buffersPacked,
                                           const GLintptr *offsets,
                                           const GLsizeiptr *sizes);
angle::CallCapture CaptureBindImageTextures(const State &glState,
                                            bool isCallValid,
                                            GLuint first,
                                            GLsizei count,
                                            const GLuint *textures);
angle::CallCapture CaptureBindSamplers(const State &glState,
                                       bool isCallValid,
                                       GLuint first,
                                       GLsizei count,
                                       const GLuint *samplers);
angle::CallCapture CaptureBindTextures(const State &glState,
                                       bool isCallValid,
                                       GLuint first,
                                       GLsizei count,
                                       const GLuint *textures);
angle::CallCapture CaptureBindVertexBuffers(const State &glState,
                                            bool isCallValid,
                                            GLuint first,
                                            GLsizei count,
                                            const BufferID *buffersPacked,
                                            const GLintptr *offsets,
                                            const GLsizei *strides);
angle::CallCapture CaptureBufferStorage(const State &glState,
                                        bool isCallValid,
                                        BufferBinding targetPacked,
                                        GLsizeiptr size,
                                        const void *data,
                                        GLbitfield flags);
angle::CallCapture CaptureClearTexImage(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLint level,
                                        GLenum format,
                                        GLenum type,
                                        const void *data);
angle::CallCapture CaptureClearTexSubImage(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLint level,
                                           GLint xoffset,
                                           GLint yoffset,
                                           GLint zoffset,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth,
                                           GLenum format,
                                           GLenum type,
                                           const void *data);

// GL 4.5
angle::CallCapture CaptureBindTextureUnit(const State &glState,
                                          bool isCallValid,
                                          GLuint unit,
                                          TextureID texturePacked);
angle::CallCapture CaptureBlitNamedFramebuffer(const State &glState,
                                               bool isCallValid,
                                               GLuint readFramebuffer,
                                               GLuint drawFramebuffer,
                                               GLint srcX0,
                                               GLint srcY0,
                                               GLint srcX1,
                                               GLint srcY1,
                                               GLint dstX0,
                                               GLint dstY0,
                                               GLint dstX1,
                                               GLint dstY1,
                                               GLbitfield mask,
                                               GLenum filter);
angle::CallCapture CaptureCheckNamedFramebufferStatus(const State &glState,
                                                      bool isCallValid,
                                                      FramebufferID framebufferPacked,
                                                      GLenum target,
                                                      GLenum returnValue);
angle::CallCapture CaptureClearNamedBufferData(const State &glState,
                                               bool isCallValid,
                                               BufferID bufferPacked,
                                               GLenum internalformat,
                                               GLenum format,
                                               GLenum type,
                                               const void *data);
angle::CallCapture CaptureClearNamedBufferSubData(const State &glState,
                                                  bool isCallValid,
                                                  BufferID bufferPacked,
                                                  GLenum internalformat,
                                                  GLintptr offset,
                                                  GLsizeiptr size,
                                                  GLenum format,
                                                  GLenum type,
                                                  const void *data);
angle::CallCapture CaptureClearNamedFramebufferfi(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum buffer,
                                                  GLint drawbuffer,
                                                  GLfloat depth,
                                                  GLint stencil);
angle::CallCapture CaptureClearNamedFramebufferfv(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum buffer,
                                                  GLint drawbuffer,
                                                  const GLfloat *value);
angle::CallCapture CaptureClearNamedFramebufferiv(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum buffer,
                                                  GLint drawbuffer,
                                                  const GLint *value);
angle::CallCapture CaptureClearNamedFramebufferuiv(const State &glState,
                                                   bool isCallValid,
                                                   FramebufferID framebufferPacked,
                                                   GLenum buffer,
                                                   GLint drawbuffer,
                                                   const GLuint *value);
angle::CallCapture CaptureClipControl(const State &glState,
                                      bool isCallValid,
                                      GLenum origin,
                                      GLenum depth);
angle::CallCapture CaptureCompressedTextureSubImage1D(const State &glState,
                                                      bool isCallValid,
                                                      TextureID texturePacked,
                                                      GLint level,
                                                      GLint xoffset,
                                                      GLsizei width,
                                                      GLenum format,
                                                      GLsizei imageSize,
                                                      const void *data);
angle::CallCapture CaptureCompressedTextureSubImage2D(const State &glState,
                                                      bool isCallValid,
                                                      TextureID texturePacked,
                                                      GLint level,
                                                      GLint xoffset,
                                                      GLint yoffset,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLenum format,
                                                      GLsizei imageSize,
                                                      const void *data);
angle::CallCapture CaptureCompressedTextureSubImage3D(const State &glState,
                                                      bool isCallValid,
                                                      TextureID texturePacked,
                                                      GLint level,
                                                      GLint xoffset,
                                                      GLint yoffset,
                                                      GLint zoffset,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLsizei depth,
                                                      GLenum format,
                                                      GLsizei imageSize,
                                                      const void *data);
angle::CallCapture CaptureCopyNamedBufferSubData(const State &glState,
                                                 bool isCallValid,
                                                 GLuint readBuffer,
                                                 GLuint writeBuffer,
                                                 GLintptr readOffset,
                                                 GLintptr writeOffset,
                                                 GLsizeiptr size);
angle::CallCapture CaptureCopyTextureSubImage1D(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint xoffset,
                                                GLint x,
                                                GLint y,
                                                GLsizei width);
angle::CallCapture CaptureCopyTextureSubImage2D(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint x,
                                                GLint y,
                                                GLsizei width,
                                                GLsizei height);
angle::CallCapture CaptureCopyTextureSubImage3D(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLint x,
                                                GLint y,
                                                GLsizei width,
                                                GLsizei height);
angle::CallCapture CaptureCreateBuffers(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        BufferID *buffersPacked);
angle::CallCapture CaptureCreateFramebuffers(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             GLuint *framebuffers);
angle::CallCapture CaptureCreateProgramPipelines(const State &glState,
                                                 bool isCallValid,
                                                 GLsizei n,
                                                 GLuint *pipelines);
angle::CallCapture CaptureCreateQueries(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLsizei n,
                                        GLuint *ids);
angle::CallCapture CaptureCreateRenderbuffers(const State &glState,
                                              bool isCallValid,
                                              GLsizei n,
                                              RenderbufferID *renderbuffersPacked);
angle::CallCapture CaptureCreateSamplers(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         GLuint *samplers);
angle::CallCapture CaptureCreateTextures(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLsizei n,
                                         GLuint *textures);
angle::CallCapture CaptureCreateTransformFeedbacks(const State &glState,
                                                   bool isCallValid,
                                                   GLsizei n,
                                                   GLuint *ids);
angle::CallCapture CaptureCreateVertexArrays(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             VertexArrayID *arraysPacked);
angle::CallCapture CaptureDisableVertexArrayAttrib(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   GLuint index);
angle::CallCapture CaptureEnableVertexArrayAttrib(const State &glState,
                                                  bool isCallValid,
                                                  VertexArrayID vaobjPacked,
                                                  GLuint index);
angle::CallCapture CaptureFlushMappedNamedBufferRange(const State &glState,
                                                      bool isCallValid,
                                                      BufferID bufferPacked,
                                                      GLintptr offset,
                                                      GLsizeiptr length);
angle::CallCapture CaptureGenerateTextureMipmap(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked);
angle::CallCapture CaptureGetCompressedTextureImage(const State &glState,
                                                    bool isCallValid,
                                                    TextureID texturePacked,
                                                    GLint level,
                                                    GLsizei bufSize,
                                                    void *pixels);
angle::CallCapture CaptureGetCompressedTextureSubImage(const State &glState,
                                                       bool isCallValid,
                                                       TextureID texturePacked,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLint zoffset,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLsizei bufSize,
                                                       void *pixels);
angle::CallCapture CaptureGetNamedBufferParameteri64v(const State &glState,
                                                      bool isCallValid,
                                                      BufferID bufferPacked,
                                                      GLenum pname,
                                                      GLint64 *params);
angle::CallCapture CaptureGetNamedBufferParameteriv(const State &glState,
                                                    bool isCallValid,
                                                    BufferID bufferPacked,
                                                    GLenum pname,
                                                    GLint *params);
angle::CallCapture CaptureGetNamedBufferPointerv(const State &glState,
                                                 bool isCallValid,
                                                 BufferID bufferPacked,
                                                 GLenum pname,
                                                 void **params);
angle::CallCapture CaptureGetNamedBufferSubData(const State &glState,
                                                bool isCallValid,
                                                BufferID bufferPacked,
                                                GLintptr offset,
                                                GLsizeiptr size,
                                                void *data);
angle::CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState,
                                                                   bool isCallValid,
                                                                   FramebufferID framebufferPacked,
                                                                   GLenum attachment,
                                                                   GLenum pname,
                                                                   GLint *params);
angle::CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState,
                                                         bool isCallValid,
                                                         FramebufferID framebufferPacked,
                                                         GLenum pname,
                                                         GLint *param);
angle::CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState,
                                                          bool isCallValid,
                                                          RenderbufferID renderbufferPacked,
                                                          GLenum pname,
                                                          GLint *params);
angle::CallCapture CaptureGetQueryBufferObjecti64v(const State &glState,
                                                   bool isCallValid,
                                                   GLuint id,
                                                   BufferID bufferPacked,
                                                   GLenum pname,
                                                   GLintptr offset);
angle::CallCapture CaptureGetQueryBufferObjectiv(const State &glState,
                                                 bool isCallValid,
                                                 GLuint id,
                                                 BufferID bufferPacked,
                                                 GLenum pname,
                                                 GLintptr offset);
angle::CallCapture CaptureGetQueryBufferObjectui64v(const State &glState,
                                                    bool isCallValid,
                                                    GLuint id,
                                                    BufferID bufferPacked,
                                                    GLenum pname,
                                                    GLintptr offset);
angle::CallCapture CaptureGetQueryBufferObjectuiv(const State &glState,
                                                  bool isCallValid,
                                                  GLuint id,
                                                  BufferID bufferPacked,
                                                  GLenum pname,
                                                  GLintptr offset);
angle::CallCapture CaptureGetTextureImage(const State &glState,
                                          bool isCallValid,
                                          TextureID texturePacked,
                                          GLint level,
                                          GLenum format,
                                          GLenum type,
                                          GLsizei bufSize,
                                          void *pixels);
angle::CallCapture CaptureGetTextureLevelParameterfv(const State &glState,
                                                     bool isCallValid,
                                                     TextureID texturePacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLfloat *params);
angle::CallCapture CaptureGetTextureLevelParameteriv(const State &glState,
                                                     bool isCallValid,
                                                     TextureID texturePacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLint *params);
angle::CallCapture CaptureGetTextureParameterIiv(const State &glState,
                                                 bool isCallValid,
                                                 TextureID texturePacked,
                                                 GLenum pname,
                                                 GLint *params);
angle::CallCapture CaptureGetTextureParameterIuiv(const State &glState,
                                                  bool isCallValid,
                                                  TextureID texturePacked,
                                                  GLenum pname,
                                                  GLuint *params);
angle::CallCapture CaptureGetTextureParameterfv(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLenum pname,
                                                GLfloat *params);
angle::CallCapture CaptureGetTextureParameteriv(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLenum pname,
                                                GLint *params);
angle::CallCapture CaptureGetTextureSubImage(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLint level,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLint zoffset,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLenum format,
                                             GLenum type,
                                             GLsizei bufSize,
                                             void *pixels);
angle::CallCapture CaptureGetTransformFeedbacki64_v(const State &glState,
                                                    bool isCallValid,
                                                    GLuint xfb,
                                                    GLenum pname,
                                                    GLuint index,
                                                    GLint64 *param);
angle::CallCapture CaptureGetTransformFeedbacki_v(const State &glState,
                                                  bool isCallValid,
                                                  GLuint xfb,
                                                  GLenum pname,
                                                  GLuint index,
                                                  GLint *param);
angle::CallCapture CaptureGetTransformFeedbackiv(const State &glState,
                                                 bool isCallValid,
                                                 GLuint xfb,
                                                 GLenum pname,
                                                 GLint *param);
angle::CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState,
                                                    bool isCallValid,
                                                    VertexArrayID vaobjPacked,
                                                    GLuint index,
                                                    GLenum pname,
                                                    GLint64 *param);
angle::CallCapture CaptureGetVertexArrayIndexediv(const State &glState,
                                                  bool isCallValid,
                                                  VertexArrayID vaobjPacked,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLint *param);
angle::CallCapture CaptureGetVertexArrayiv(const State &glState,
                                           bool isCallValid,
                                           VertexArrayID vaobjPacked,
                                           GLenum pname,
                                           GLint *param);
angle::CallCapture CaptureGetnColorTable(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         void *table);
angle::CallCapture CaptureGetnCompressedTexImage(const State &glState,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLint lod,
                                                 GLsizei bufSize,
                                                 void *pixels);
angle::CallCapture CaptureGetnConvolutionFilter(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum format,
                                                GLenum type,
                                                GLsizei bufSize,
                                                void *image);
angle::CallCapture CaptureGetnHistogram(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLboolean reset,
                                        GLenum format,
                                        GLenum type,
                                        GLsizei bufSize,
                                        void *values);
angle::CallCapture CaptureGetnMapdv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLenum query,
                                    GLsizei bufSize,
                                    GLdouble *v);
angle::CallCapture CaptureGetnMapfv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLenum query,
                                    GLsizei bufSize,
                                    GLfloat *v);
angle::CallCapture CaptureGetnMapiv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLenum query,
                                    GLsizei bufSize,
                                    GLint *v);
angle::CallCapture CaptureGetnMinmax(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLboolean reset,
                                     GLenum format,
                                     GLenum type,
                                     GLsizei bufSize,
                                     void *values);
angle::CallCapture CaptureGetnPixelMapfv(const State &glState,
                                         bool isCallValid,
                                         GLenum map,
                                         GLsizei bufSize,
                                         GLfloat *values);
angle::CallCapture CaptureGetnPixelMapuiv(const State &glState,
                                          bool isCallValid,
                                          GLenum map,
                                          GLsizei bufSize,
                                          GLuint *values);
angle::CallCapture CaptureGetnPixelMapusv(const State &glState,
                                          bool isCallValid,
                                          GLenum map,
                                          GLsizei bufSize,
                                          GLushort *values);
angle::CallCapture CaptureGetnPolygonStipple(const State &glState,
                                             bool isCallValid,
                                             GLsizei bufSize,
                                             GLubyte *pattern);
angle::CallCapture CaptureGetnSeparableFilter(const State &glState,
                                              bool isCallValid,
                                              GLenum target,
                                              GLenum format,
                                              GLenum type,
                                              GLsizei rowBufSize,
                                              void *row,
                                              GLsizei columnBufSize,
                                              void *column,
                                              void *span);
angle::CallCapture CaptureGetnTexImage(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLint level,
                                       GLenum format,
                                       GLenum type,
                                       GLsizei bufSize,
                                       void *pixels);
angle::CallCapture CaptureGetnUniformdv(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
                                        UniformLocation locationPacked,
                                        GLsizei bufSize,
                                        GLdouble *params);
angle::CallCapture CaptureInvalidateNamedFramebufferData(const State &glState,
                                                         bool isCallValid,
                                                         FramebufferID framebufferPacked,
                                                         GLsizei numAttachments,
                                                         const GLenum *attachments);
angle::CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState,
                                                            bool isCallValid,
                                                            FramebufferID framebufferPacked,
                                                            GLsizei numAttachments,
                                                            const GLenum *attachments,
                                                            GLint x,
                                                            GLint y,
                                                            GLsizei width,
                                                            GLsizei height);
angle::CallCapture CaptureMapNamedBuffer(const State &glState,
                                         bool isCallValid,
                                         BufferID bufferPacked,
                                         GLenum access,
                                         void *returnValue);
angle::CallCapture CaptureMapNamedBufferRange(const State &glState,
                                              bool isCallValid,
                                              BufferID bufferPacked,
                                              GLintptr offset,
                                              GLsizeiptr length,
                                              GLbitfield access,
                                              void *returnValue);
angle::CallCapture CaptureNamedBufferData(const State &glState,
                                          bool isCallValid,
                                          BufferID bufferPacked,
                                          GLsizeiptr size,
                                          const void *data,
                                          GLenum usage);
angle::CallCapture CaptureNamedBufferStorage(const State &glState,
                                             bool isCallValid,
                                             BufferID bufferPacked,
                                             GLsizeiptr size,
                                             const void *data,
                                             GLbitfield flags);
angle::CallCapture CaptureNamedBufferSubData(const State &glState,
                                             bool isCallValid,
                                             BufferID bufferPacked,
                                             GLintptr offset,
                                             GLsizeiptr size,
                                             const void *data);
angle::CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState,
                                                     bool isCallValid,
                                                     FramebufferID framebufferPacked,
                                                     GLenum buf);
angle::CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState,
                                                      bool isCallValid,
                                                      FramebufferID framebufferPacked,
                                                      GLsizei n,
                                                      const GLenum *bufs);
angle::CallCapture CaptureNamedFramebufferParameteri(const State &glState,
                                                     bool isCallValid,
                                                     FramebufferID framebufferPacked,
                                                     GLenum pname,
                                                     GLint param);
angle::CallCapture CaptureNamedFramebufferReadBuffer(const State &glState,
                                                     bool isCallValid,
                                                     FramebufferID framebufferPacked,
                                                     GLenum src);
angle::CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState,
                                                       bool isCallValid,
                                                       FramebufferID framebufferPacked,
                                                       GLenum attachment,
                                                       GLenum renderbuffertarget,
                                                       RenderbufferID renderbufferPacked);
angle::CallCapture CaptureNamedFramebufferTexture(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum attachment,
                                                  TextureID texturePacked,
                                                  GLint level);
angle::CallCapture CaptureNamedFramebufferTextureLayer(const State &glState,
                                                       bool isCallValid,
                                                       FramebufferID framebufferPacked,
                                                       GLenum attachment,
                                                       TextureID texturePacked,
                                                       GLint level,
                                                       GLint layer);
angle::CallCapture CaptureNamedRenderbufferStorage(const State &glState,
                                                   bool isCallValid,
                                                   RenderbufferID renderbufferPacked,
                                                   GLenum internalformat,
                                                   GLsizei width,
                                                   GLsizei height);
angle::CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState,
                                                              bool isCallValid,
                                                              RenderbufferID renderbufferPacked,
                                                              GLsizei samples,
                                                              GLenum internalformat,
                                                              GLsizei width,
                                                              GLsizei height);
angle::CallCapture CaptureTextureBarrier(const State &glState, bool isCallValid);
angle::CallCapture CaptureTextureBuffer(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLenum internalformat,
                                        BufferID bufferPacked);
angle::CallCapture CaptureTextureBufferRange(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLenum internalformat,
                                             BufferID bufferPacked,
                                             GLintptr offset,
                                             GLsizeiptr size);
angle::CallCapture CaptureTextureParameterIiv(const State &glState,
                                              bool isCallValid,
                                              TextureID texturePacked,
                                              GLenum pname,
                                              const GLint *params);
angle::CallCapture CaptureTextureParameterIuiv(const State &glState,
                                               bool isCallValid,
                                               TextureID texturePacked,
                                               GLenum pname,
                                               const GLuint *params);
angle::CallCapture CaptureTextureParameterf(const State &glState,
                                            bool isCallValid,
                                            TextureID texturePacked,
                                            GLenum pname,
                                            GLfloat param);
angle::CallCapture CaptureTextureParameterfv(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLenum pname,
                                             const GLfloat *param);
angle::CallCapture CaptureTextureParameteri(const State &glState,
                                            bool isCallValid,
                                            TextureID texturePacked,
                                            GLenum pname,
                                            GLint param);
angle::CallCapture CaptureTextureParameteriv(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLenum pname,
                                             const GLint *param);
angle::CallCapture CaptureTextureStorage1D(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLsizei levels,
                                           GLenum internalformat,
                                           GLsizei width);
angle::CallCapture CaptureTextureStorage2D(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLsizei levels,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height);
angle::CallCapture CaptureTextureStorage2DMultisample(const State &glState,
                                                      bool isCallValid,
                                                      TextureID texturePacked,
                                                      GLsizei samples,
                                                      GLenum internalformat,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLboolean fixedsamplelocations);
angle::CallCapture CaptureTextureStorage3D(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLsizei levels,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth);
angle::CallCapture CaptureTextureStorage3DMultisample(const State &glState,
                                                      bool isCallValid,
                                                      TextureID texturePacked,
                                                      GLsizei samples,
                                                      GLenum internalformat,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLsizei depth,
                                                      GLboolean fixedsamplelocations);
angle::CallCapture CaptureTextureSubImage1D(const State &glState,
                                            bool isCallValid,
                                            TextureID texturePacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLsizei width,
                                            GLenum format,
                                            GLenum type,
                                            const void *pixels);
angle::CallCapture CaptureTextureSubImage2D(const State &glState,
                                            bool isCallValid,
                                            TextureID texturePacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLenum format,
                                            GLenum type,
                                            const void *pixels);
angle::CallCapture CaptureTextureSubImage3D(const State &glState,
                                            bool isCallValid,
                                            TextureID texturePacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint zoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth,
                                            GLenum format,
                                            GLenum type,
                                            const void *pixels);
angle::CallCapture CaptureTransformFeedbackBufferBase(const State &glState,
                                                      bool isCallValid,
                                                      GLuint xfb,
                                                      GLuint index,
                                                      BufferID bufferPacked);
angle::CallCapture CaptureTransformFeedbackBufferRange(const State &glState,
                                                       bool isCallValid,
                                                       GLuint xfb,
                                                       GLuint index,
                                                       BufferID bufferPacked,
                                                       GLintptr offset,
                                                       GLsizeiptr size);
angle::CallCapture CaptureUnmapNamedBuffer(const State &glState,
                                           bool isCallValid,
                                           BufferID bufferPacked,
                                           GLboolean returnValue);
angle::CallCapture CaptureVertexArrayAttribBinding(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   GLuint attribindex,
                                                   GLuint bindingindex);
angle::CallCapture CaptureVertexArrayAttribFormat(const State &glState,
                                                  bool isCallValid,
                                                  VertexArrayID vaobjPacked,
                                                  GLuint attribindex,
                                                  GLint size,
                                                  GLenum type,
                                                  GLboolean normalized,
                                                  GLuint relativeoffset);
angle::CallCapture CaptureVertexArrayAttribIFormat(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   GLuint attribindex,
                                                   GLint size,
                                                   GLenum type,
                                                   GLuint relativeoffset);
angle::CallCapture CaptureVertexArrayAttribLFormat(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   GLuint attribindex,
                                                   GLint size,
                                                   GLenum type,
                                                   GLuint relativeoffset);
angle::CallCapture CaptureVertexArrayBindingDivisor(const State &glState,
                                                    bool isCallValid,
                                                    VertexArrayID vaobjPacked,
                                                    GLuint bindingindex,
                                                    GLuint divisor);
angle::CallCapture CaptureVertexArrayElementBuffer(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   BufferID bufferPacked);
angle::CallCapture CaptureVertexArrayVertexBuffer(const State &glState,
                                                  bool isCallValid,
                                                  VertexArrayID vaobjPacked,
                                                  GLuint bindingindex,
                                                  BufferID bufferPacked,
                                                  GLintptr offset,
                                                  GLsizei stride);
angle::CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   GLuint first,
                                                   GLsizei count,
                                                   const BufferID *buffersPacked,
                                                   const GLintptr *offsets,
                                                   const GLsizei *strides);

// GL 4.6
angle::CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
                                                       bool isCallValid,
                                                       GLenum mode,
                                                       const void *indirect,
                                                       GLintptr drawcount,
                                                       GLsizei maxdrawcount,
                                                       GLsizei stride);
angle::CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState,
                                                         bool isCallValid,
                                                         GLenum mode,
                                                         GLenum type,
                                                         const void *indirect,
                                                         GLintptr drawcount,
                                                         GLsizei maxdrawcount,
                                                         GLsizei stride);
angle::CallCapture CapturePolygonOffsetClamp(const State &glState,
                                             bool isCallValid,
                                             GLfloat factor,
                                             GLfloat units,
                                             GLfloat clamp);
angle::CallCapture CaptureSpecializeShader(const State &glState,
                                           bool isCallValid,
                                           GLuint shader,
                                           const GLchar *pEntryPoint,
                                           GLuint numSpecializationConstants,
                                           const GLuint *pConstantIndex,
                                           const GLuint *pConstantValue);

// Parameter Captures

// GL 4.0
void CaptureGetActiveSubroutineName_length(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLenum shadertype,
                                           GLuint index,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLchar *name,
                                           angle::ParamCapture *paramCapture);
void CaptureGetActiveSubroutineName_name(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         GLenum shadertype,
                                         GLuint index,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLchar *name,
                                         angle::ParamCapture *paramCapture);
void CaptureGetActiveSubroutineUniformName_length(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum shadertype,
                                                  GLuint index,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLchar *name,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetActiveSubroutineUniformName_name(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                GLenum shadertype,
                                                GLuint index,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *name,
                                                angle::ParamCapture *paramCapture);
void CaptureGetActiveSubroutineUniformiv_values(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                GLenum shadertype,
                                                GLuint index,
                                                GLenum pname,
                                                GLint *values,
                                                angle::ParamCapture *paramCapture);
void CaptureGetProgramStageiv_values(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     GLenum shadertype,
                                     GLenum pname,
                                     GLint *values,
                                     angle::ParamCapture *paramCapture);
void CaptureGetQueryIndexediv_params(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint index,
                                     GLenum pname,
                                     GLint *params,
                                     angle::ParamCapture *paramCapture);
void CaptureGetSubroutineIndex_name(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLenum shadertype,
                                    const GLchar *name,
                                    angle::ParamCapture *paramCapture);
void CaptureGetSubroutineUniformLocation_name(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              GLenum shadertype,
                                              const GLchar *name,
                                              angle::ParamCapture *paramCapture);
void CaptureGetUniformSubroutineuiv_params(const State &glState,
                                           bool isCallValid,
                                           GLenum shadertype,
                                           GLint location,
                                           GLuint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformdv_params(const State &glState,
                                bool isCallValid,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLdouble *params,
                                angle::ParamCapture *paramCapture);
void CapturePatchParameterfv_values(const State &glState,
                                    bool isCallValid,
                                    GLenum pname,
                                    const GLfloat *values,
                                    angle::ParamCapture *paramCapture);
void CaptureUniform1dv_value(const State &glState,
                             bool isCallValid,
                             UniformLocation locationPacked,
                             GLsizei count,
                             const GLdouble *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform2dv_value(const State &glState,
                             bool isCallValid,
                             UniformLocation locationPacked,
                             GLsizei count,
                             const GLdouble *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform3dv_value(const State &glState,
                             bool isCallValid,
                             UniformLocation locationPacked,
                             GLsizei count,
                             const GLdouble *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniform4dv_value(const State &glState,
                             bool isCallValid,
                             UniformLocation locationPacked,
                             GLsizei count,
                             const GLdouble *value,
                             angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2dv_value(const State &glState,
                                   bool isCallValid,
                                   UniformLocation locationPacked,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLdouble *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2x3dv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLdouble *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix2x4dv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLdouble *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3dv_value(const State &glState,
                                   bool isCallValid,
                                   UniformLocation locationPacked,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLdouble *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3x2dv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLdouble *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix3x4dv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLdouble *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4dv_value(const State &glState,
                                   bool isCallValid,
                                   UniformLocation locationPacked,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLdouble *value,
                                   angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4x2dv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLdouble *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformMatrix4x3dv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLdouble *value,
                                     angle::ParamCapture *paramCapture);
void CaptureUniformSubroutinesuiv_indices(const State &glState,
                                          bool isCallValid,
                                          GLenum shadertype,
                                          GLsizei count,
                                          const GLuint *indices,
                                          angle::ParamCapture *paramCapture);

// GL 4.1
void CaptureDepthRangeArrayv_v(const State &glState,
                               bool isCallValid,
                               GLuint first,
                               GLsizei count,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureGetDoublei_v_data(const State &glState,
                              bool isCallValid,
                              GLenum target,
                              GLuint index,
                              GLdouble *data,
                              angle::ParamCapture *paramCapture);
void CaptureGetFloati_v_data(const State &glState,
                             bool isCallValid,
                             GLenum target,
                             GLuint index,
                             GLfloat *data,
                             angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribLdv_params(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      GLenum pname,
                                      GLdouble *params,
                                      angle::ParamCapture *paramCapture);
void CaptureProgramUniform1dv_value(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    const GLdouble *value,
                                    angle::ParamCapture *paramCapture);
void CaptureProgramUniform2dv_value(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    const GLdouble *value,
                                    angle::ParamCapture *paramCapture);
void CaptureProgramUniform3dv_value(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    const GLdouble *value,
                                    angle::ParamCapture *paramCapture);
void CaptureProgramUniform4dv_value(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    const GLdouble *value,
                                    angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix2dv_value(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID programPacked,
                                          UniformLocation locationPacked,
                                          GLsizei count,
                                          GLboolean transpose,
                                          const GLdouble *value,
                                          angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix2x3dv_value(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLdouble *value,
                                            angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix2x4dv_value(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLdouble *value,
                                            angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix3dv_value(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID programPacked,
                                          UniformLocation locationPacked,
                                          GLsizei count,
                                          GLboolean transpose,
                                          const GLdouble *value,
                                          angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix3x2dv_value(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLdouble *value,
                                            angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix3x4dv_value(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLdouble *value,
                                            angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix4dv_value(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID programPacked,
                                          UniformLocation locationPacked,
                                          GLsizei count,
                                          GLboolean transpose,
                                          const GLdouble *value,
                                          angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix4x2dv_value(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLdouble *value,
                                            angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix4x3dv_value(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLdouble *value,
                                            angle::ParamCapture *paramCapture);
void CaptureScissorArrayv_v(const State &glState,
                            bool isCallValid,
                            GLuint first,
                            GLsizei count,
                            const GLint *v,
                            angle::ParamCapture *paramCapture);
void CaptureScissorIndexedv_v(const State &glState,
                              bool isCallValid,
                              GLuint index,
                              const GLint *v,
                              angle::ParamCapture *paramCapture);
void CaptureVertexAttribL1dv_v(const State &glState,
                               bool isCallValid,
                               GLuint index,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureVertexAttribL2dv_v(const State &glState,
                               bool isCallValid,
                               GLuint index,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureVertexAttribL3dv_v(const State &glState,
                               bool isCallValid,
                               GLuint index,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureVertexAttribL4dv_v(const State &glState,
                               bool isCallValid,
                               GLuint index,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureVertexAttribLPointer_pointer(const State &glState,
                                         bool isCallValid,
                                         GLuint index,
                                         GLint size,
                                         GLenum type,
                                         GLsizei stride,
                                         const void *pointer,
                                         angle::ParamCapture *paramCapture);
void CaptureViewportArrayv_v(const State &glState,
                             bool isCallValid,
                             GLuint first,
                             GLsizei count,
                             const GLfloat *v,
                             angle::ParamCapture *paramCapture);
void CaptureViewportIndexedfv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLfloat *v,
                                angle::ParamCapture *paramCapture);

// GL 4.2
void CaptureDrawElementsInstancedBaseInstance_indices(const State &glState,
                                                      bool isCallValid,
                                                      PrimitiveMode modePacked,
                                                      GLsizei count,
                                                      DrawElementsType typePacked,
                                                      const void *indices,
                                                      GLsizei instancecount,
                                                      GLuint baseinstance,
                                                      angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexBaseInstance_indices(const State &glState,
                                                                bool isCallValid,
                                                                PrimitiveMode modePacked,
                                                                GLsizei count,
                                                                DrawElementsType typePacked,
                                                                const void *indices,
                                                                GLsizei instancecount,
                                                                GLint basevertex,
                                                                GLuint baseinstance,
                                                                angle::ParamCapture *paramCapture);
void CaptureGetActiveAtomicCounterBufferiv_params(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLuint bufferIndex,
                                                  GLenum pname,
                                                  GLint *params,
                                                  angle::ParamCapture *paramCapture);

// GL 4.3
void CaptureClearBufferData_data(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLenum internalformat,
                                 GLenum format,
                                 GLenum type,
                                 const void *data,
                                 angle::ParamCapture *paramCapture);
void CaptureClearBufferSubData_data(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLenum internalformat,
                                    GLintptr offset,
                                    GLsizeiptr size,
                                    GLenum format,
                                    GLenum type,
                                    const void *data,
                                    angle::ParamCapture *paramCapture);
void CaptureGetInternalformati64v_params(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLenum internalformat,
                                         GLenum pname,
                                         GLsizei count,
                                         GLint64 *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetProgramResourceLocationIndex_name(const State &glState,
                                                 bool isCallValid,
                                                 ShaderProgramID programPacked,
                                                 GLenum programInterface,
                                                 const GLchar *name,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysIndirect_indirect(const State &glState,
                                             bool isCallValid,
                                             PrimitiveMode modePacked,
                                             const void *indirect,
                                             GLsizei drawcount,
                                             GLsizei stride,
                                             angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsIndirect_indirect(const State &glState,
                                               bool isCallValid,
                                               PrimitiveMode modePacked,
                                               DrawElementsType typePacked,
                                               const void *indirect,
                                               GLsizei drawcount,
                                               GLsizei stride,
                                               angle::ParamCapture *paramCapture);

// GL 4.4
void CaptureBindBuffersBase_buffersPacked(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint first,
                                          GLsizei count,
                                          const BufferID *buffersPacked,
                                          angle::ParamCapture *paramCapture);
void CaptureBindBuffersRange_buffersPacked(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           GLuint first,
                                           GLsizei count,
                                           const BufferID *buffersPacked,
                                           const GLintptr *offsets,
                                           const GLsizeiptr *sizes,
                                           angle::ParamCapture *paramCapture);
void CaptureBindBuffersRange_offsets(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint first,
                                     GLsizei count,
                                     const BufferID *buffersPacked,
                                     const GLintptr *offsets,
                                     const GLsizeiptr *sizes,
                                     angle::ParamCapture *paramCapture);
void CaptureBindBuffersRange_sizes(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLuint first,
                                   GLsizei count,
                                   const BufferID *buffersPacked,
                                   const GLintptr *offsets,
                                   const GLsizeiptr *sizes,
                                   angle::ParamCapture *paramCapture);
void CaptureBindImageTextures_textures(const State &glState,
                                       bool isCallValid,
                                       GLuint first,
                                       GLsizei count,
                                       const GLuint *textures,
                                       angle::ParamCapture *paramCapture);
void CaptureBindSamplers_samplers(const State &glState,
                                  bool isCallValid,
                                  GLuint first,
                                  GLsizei count,
                                  const GLuint *samplers,
                                  angle::ParamCapture *paramCapture);
void CaptureBindTextures_textures(const State &glState,
                                  bool isCallValid,
                                  GLuint first,
                                  GLsizei count,
                                  const GLuint *textures,
                                  angle::ParamCapture *paramCapture);
void CaptureBindVertexBuffers_buffersPacked(const State &glState,
                                            bool isCallValid,
                                            GLuint first,
                                            GLsizei count,
                                            const BufferID *buffersPacked,
                                            const GLintptr *offsets,
                                            const GLsizei *strides,
                                            angle::ParamCapture *paramCapture);
void CaptureBindVertexBuffers_offsets(const State &glState,
                                      bool isCallValid,
                                      GLuint first,
                                      GLsizei count,
                                      const BufferID *buffersPacked,
                                      const GLintptr *offsets,
                                      const GLsizei *strides,
                                      angle::ParamCapture *paramCapture);
void CaptureBindVertexBuffers_strides(const State &glState,
                                      bool isCallValid,
                                      GLuint first,
                                      GLsizei count,
                                      const BufferID *buffersPacked,
                                      const GLintptr *offsets,
                                      const GLsizei *strides,
                                      angle::ParamCapture *paramCapture);
void CaptureBufferStorage_data(const State &glState,
                               bool isCallValid,
                               BufferBinding targetPacked,
                               GLsizeiptr size,
                               const void *data,
                               GLbitfield flags,
                               angle::ParamCapture *paramCapture);
void CaptureClearTexImage_data(const State &glState,
                               bool isCallValid,
                               TextureID texturePacked,
                               GLint level,
                               GLenum format,
                               GLenum type,
                               const void *data,
                               angle::ParamCapture *paramCapture);
void CaptureClearTexSubImage_data(const State &glState,
                                  bool isCallValid,
                                  TextureID texturePacked,
                                  GLint level,
                                  GLint xoffset,
                                  GLint yoffset,
                                  GLint zoffset,
                                  GLsizei width,
                                  GLsizei height,
                                  GLsizei depth,
                                  GLenum format,
                                  GLenum type,
                                  const void *data,
                                  angle::ParamCapture *paramCapture);

// GL 4.5
void CaptureClearNamedBufferData_data(const State &glState,
                                      bool isCallValid,
                                      BufferID bufferPacked,
                                      GLenum internalformat,
                                      GLenum format,
                                      GLenum type,
                                      const void *data,
                                      angle::ParamCapture *paramCapture);
void CaptureClearNamedBufferSubData_data(const State &glState,
                                         bool isCallValid,
                                         BufferID bufferPacked,
                                         GLenum internalformat,
                                         GLintptr offset,
                                         GLsizeiptr size,
                                         GLenum format,
                                         GLenum type,
                                         const void *data,
                                         angle::ParamCapture *paramCapture);
void CaptureClearNamedFramebufferfv_value(const State &glState,
                                          bool isCallValid,
                                          FramebufferID framebufferPacked,
                                          GLenum buffer,
                                          GLint drawbuffer,
                                          const GLfloat *value,
                                          angle::ParamCapture *paramCapture);
void CaptureClearNamedFramebufferiv_value(const State &glState,
                                          bool isCallValid,
                                          FramebufferID framebufferPacked,
                                          GLenum buffer,
                                          GLint drawbuffer,
                                          const GLint *value,
                                          angle::ParamCapture *paramCapture);
void CaptureClearNamedFramebufferuiv_value(const State &glState,
                                           bool isCallValid,
                                           FramebufferID framebufferPacked,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           const GLuint *value,
                                           angle::ParamCapture *paramCapture);
void CaptureCompressedTextureSubImage1D_data(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLint level,
                                             GLint xoffset,
                                             GLsizei width,
                                             GLenum format,
                                             GLsizei imageSize,
                                             const void *data,
                                             angle::ParamCapture *paramCapture);
void CaptureCompressedTextureSubImage2D_data(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLint level,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLsizei width,
                                             GLsizei height,
                                             GLenum format,
                                             GLsizei imageSize,
                                             const void *data,
                                             angle::ParamCapture *paramCapture);
void CaptureCompressedTextureSubImage3D_data(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             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 CaptureCreateBuffers_buffersPacked(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        BufferID *buffersPacked,
                                        angle::ParamCapture *paramCapture);
void CaptureCreateFramebuffers_framebuffers(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            GLuint *framebuffers,
                                            angle::ParamCapture *paramCapture);
void CaptureCreateProgramPipelines_pipelines(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             GLuint *pipelines,
                                             angle::ParamCapture *paramCapture);
void CaptureCreateQueries_ids(const State &glState,
                              bool isCallValid,
                              GLenum target,
                              GLsizei n,
                              GLuint *ids,
                              angle::ParamCapture *paramCapture);
void CaptureCreateRenderbuffers_renderbuffersPacked(const State &glState,
                                                    bool isCallValid,
                                                    GLsizei n,
                                                    RenderbufferID *renderbuffersPacked,
                                                    angle::ParamCapture *paramCapture);
void CaptureCreateSamplers_samplers(const State &glState,
                                    bool isCallValid,
                                    GLsizei n,
                                    GLuint *samplers,
                                    angle::ParamCapture *paramCapture);
void CaptureCreateTextures_textures(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLsizei n,
                                    GLuint *textures,
                                    angle::ParamCapture *paramCapture);
void CaptureCreateTransformFeedbacks_ids(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         GLuint *ids,
                                         angle::ParamCapture *paramCapture);
void CaptureCreateVertexArrays_arraysPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            VertexArrayID *arraysPacked,
                                            angle::ParamCapture *paramCapture);
void CaptureGetCompressedTextureImage_pixels(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLint level,
                                             GLsizei bufSize,
                                             void *pixels,
                                             angle::ParamCapture *paramCapture);
void CaptureGetCompressedTextureSubImage_pixels(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
                                                GLsizei bufSize,
                                                void *pixels,
                                                angle::ParamCapture *paramCapture);
void CaptureGetNamedBufferParameteri64v_params(const State &glState,
                                               bool isCallValid,
                                               BufferID bufferPacked,
                                               GLenum pname,
                                               GLint64 *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetNamedBufferParameteriv_params(const State &glState,
                                             bool isCallValid,
                                             BufferID bufferPacked,
                                             GLenum pname,
                                             GLint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureGetNamedBufferPointerv_params(const State &glState,
                                          bool isCallValid,
                                          BufferID bufferPacked,
                                          GLenum pname,
                                          void **params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetNamedBufferSubData_data(const State &glState,
                                       bool isCallValid,
                                       BufferID bufferPacked,
                                       GLintptr offset,
                                       GLsizeiptr size,
                                       void *data,
                                       angle::ParamCapture *paramCapture);
void CaptureGetNamedFramebufferAttachmentParameteriv_params(const State &glState,
                                                            bool isCallValid,
                                                            FramebufferID framebufferPacked,
                                                            GLenum attachment,
                                                            GLenum pname,
                                                            GLint *params,
                                                            angle::ParamCapture *paramCapture);
void CaptureGetNamedFramebufferParameteriv_param(const State &glState,
                                                 bool isCallValid,
                                                 FramebufferID framebufferPacked,
                                                 GLenum pname,
                                                 GLint *param,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetNamedRenderbufferParameteriv_params(const State &glState,
                                                   bool isCallValid,
                                                   RenderbufferID renderbufferPacked,
                                                   GLenum pname,
                                                   GLint *params,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetTextureImage_pixels(const State &glState,
                                   bool isCallValid,
                                   TextureID texturePacked,
                                   GLint level,
                                   GLenum format,
                                   GLenum type,
                                   GLsizei bufSize,
                                   void *pixels,
                                   angle::ParamCapture *paramCapture);
void CaptureGetTextureLevelParameterfv_params(const State &glState,
                                              bool isCallValid,
                                              TextureID texturePacked,
                                              GLint level,
                                              GLenum pname,
                                              GLfloat *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetTextureLevelParameteriv_params(const State &glState,
                                              bool isCallValid,
                                              TextureID texturePacked,
                                              GLint level,
                                              GLenum pname,
                                              GLint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetTextureParameterIiv_params(const State &glState,
                                          bool isCallValid,
                                          TextureID texturePacked,
                                          GLenum pname,
                                          GLint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetTextureParameterIuiv_params(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLenum pname,
                                           GLuint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetTextureParameterfv_params(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLenum pname,
                                         GLfloat *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetTextureParameteriv_params(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLenum pname,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetTextureSubImage_pixels(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLint level,
                                      GLint xoffset,
                                      GLint yoffset,
                                      GLint zoffset,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLenum format,
                                      GLenum type,
                                      GLsizei bufSize,
                                      void *pixels,
                                      angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbacki64_v_param(const State &glState,
                                            bool isCallValid,
                                            GLuint xfb,
                                            GLenum pname,
                                            GLuint index,
                                            GLint64 *param,
                                            angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbacki_v_param(const State &glState,
                                          bool isCallValid,
                                          GLuint xfb,
                                          GLenum pname,
                                          GLuint index,
                                          GLint *param,
                                          angle::ParamCapture *paramCapture);
void CaptureGetTransformFeedbackiv_param(const State &glState,
                                         bool isCallValid,
                                         GLuint xfb,
                                         GLenum pname,
                                         GLint *param,
                                         angle::ParamCapture *paramCapture);
void CaptureGetVertexArrayIndexed64iv_param(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            GLuint index,
                                            GLenum pname,
                                            GLint64 *param,
                                            angle::ParamCapture *paramCapture);
void CaptureGetVertexArrayIndexediv_param(const State &glState,
                                          bool isCallValid,
                                          VertexArrayID vaobjPacked,
                                          GLuint index,
                                          GLenum pname,
                                          GLint *param,
                                          angle::ParamCapture *paramCapture);
void CaptureGetVertexArrayiv_param(const State &glState,
                                   bool isCallValid,
                                   VertexArrayID vaobjPacked,
                                   GLenum pname,
                                   GLint *param,
                                   angle::ParamCapture *paramCapture);
void CaptureGetnColorTable_table(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLenum format,
                                 GLenum type,
                                 GLsizei bufSize,
                                 void *table,
                                 angle::ParamCapture *paramCapture);
void CaptureGetnCompressedTexImage_pixels(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLint lod,
                                          GLsizei bufSize,
                                          void *pixels,
                                          angle::ParamCapture *paramCapture);
void CaptureGetnConvolutionFilter_image(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLenum format,
                                        GLenum type,
                                        GLsizei bufSize,
                                        void *image,
                                        angle::ParamCapture *paramCapture);
void CaptureGetnHistogram_values(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLboolean reset,
                                 GLenum format,
                                 GLenum type,
                                 GLsizei bufSize,
                                 void *values,
                                 angle::ParamCapture *paramCapture);
void CaptureGetnMapdv_v(const State &glState,
                        bool isCallValid,
                        GLenum target,
                        GLenum query,
                        GLsizei bufSize,
                        GLdouble *v,
                        angle::ParamCapture *paramCapture);
void CaptureGetnMapfv_v(const State &glState,
                        bool isCallValid,
                        GLenum target,
                        GLenum query,
                        GLsizei bufSize,
                        GLfloat *v,
                        angle::ParamCapture *paramCapture);
void CaptureGetnMapiv_v(const State &glState,
                        bool isCallValid,
                        GLenum target,
                        GLenum query,
                        GLsizei bufSize,
                        GLint *v,
                        angle::ParamCapture *paramCapture);
void CaptureGetnMinmax_values(const State &glState,
                              bool isCallValid,
                              GLenum target,
                              GLboolean reset,
                              GLenum format,
                              GLenum type,
                              GLsizei bufSize,
                              void *values,
                              angle::ParamCapture *paramCapture);
void CaptureGetnPixelMapfv_values(const State &glState,
                                  bool isCallValid,
                                  GLenum map,
                                  GLsizei bufSize,
                                  GLfloat *values,
                                  angle::ParamCapture *paramCapture);
void CaptureGetnPixelMapuiv_values(const State &glState,
                                   bool isCallValid,
                                   GLenum map,
                                   GLsizei bufSize,
                                   GLuint *values,
                                   angle::ParamCapture *paramCapture);
void CaptureGetnPixelMapusv_values(const State &glState,
                                   bool isCallValid,
                                   GLenum map,
                                   GLsizei bufSize,
                                   GLushort *values,
                                   angle::ParamCapture *paramCapture);
void CaptureGetnPolygonStipple_pattern(const State &glState,
                                       bool isCallValid,
                                       GLsizei bufSize,
                                       GLubyte *pattern,
                                       angle::ParamCapture *paramCapture);
void CaptureGetnSeparableFilter_row(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLenum format,
                                    GLenum type,
                                    GLsizei rowBufSize,
                                    void *row,
                                    GLsizei columnBufSize,
                                    void *column,
                                    void *span,
                                    angle::ParamCapture *paramCapture);
void CaptureGetnSeparableFilter_column(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLenum format,
                                       GLenum type,
                                       GLsizei rowBufSize,
                                       void *row,
                                       GLsizei columnBufSize,
                                       void *column,
                                       void *span,
                                       angle::ParamCapture *paramCapture);
void CaptureGetnSeparableFilter_span(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLenum format,
                                     GLenum type,
                                     GLsizei rowBufSize,
                                     void *row,
                                     GLsizei columnBufSize,
                                     void *column,
                                     void *span,
                                     angle::ParamCapture *paramCapture);
void CaptureGetnTexImage_pixels(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLint level,
                                GLenum format,
                                GLenum type,
                                GLsizei bufSize,
                                void *pixels,
                                angle::ParamCapture *paramCapture);
void CaptureGetnUniformdv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
                                 UniformLocation locationPacked,
                                 GLsizei bufSize,
                                 GLdouble *params,
                                 angle::ParamCapture *paramCapture);
void CaptureInvalidateNamedFramebufferData_attachments(const State &glState,
                                                       bool isCallValid,
                                                       FramebufferID framebufferPacked,
                                                       GLsizei numAttachments,
                                                       const GLenum *attachments,
                                                       angle::ParamCapture *paramCapture);
void CaptureInvalidateNamedFramebufferSubData_attachments(const State &glState,
                                                          bool isCallValid,
                                                          FramebufferID framebufferPacked,
                                                          GLsizei numAttachments,
                                                          const GLenum *attachments,
                                                          GLint x,
                                                          GLint y,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          angle::ParamCapture *paramCapture);
void CaptureNamedBufferData_data(const State &glState,
                                 bool isCallValid,
                                 BufferID bufferPacked,
                                 GLsizeiptr size,
                                 const void *data,
                                 GLenum usage,
                                 angle::ParamCapture *paramCapture);
void CaptureNamedBufferStorage_data(const State &glState,
                                    bool isCallValid,
                                    BufferID bufferPacked,
                                    GLsizeiptr size,
                                    const void *data,
                                    GLbitfield flags,
                                    angle::ParamCapture *paramCapture);
void CaptureNamedBufferSubData_data(const State &glState,
                                    bool isCallValid,
                                    BufferID bufferPacked,
                                    GLintptr offset,
                                    GLsizeiptr size,
                                    const void *data,
                                    angle::ParamCapture *paramCapture);
void CaptureNamedFramebufferDrawBuffers_bufs(const State &glState,
                                             bool isCallValid,
                                             FramebufferID framebufferPacked,
                                             GLsizei n,
                                             const GLenum *bufs,
                                             angle::ParamCapture *paramCapture);
void CaptureTextureParameterIiv_params(const State &glState,
                                       bool isCallValid,
                                       TextureID texturePacked,
                                       GLenum pname,
                                       const GLint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureTextureParameterIuiv_params(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLenum pname,
                                        const GLuint *params,
                                        angle::ParamCapture *paramCapture);
void CaptureTextureParameterfv_param(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLenum pname,
                                     const GLfloat *param,
                                     angle::ParamCapture *paramCapture);
void CaptureTextureParameteriv_param(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLenum pname,
                                     const GLint *param,
                                     angle::ParamCapture *paramCapture);
void CaptureTextureSubImage1D_pixels(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLsizei width,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels,
                                     angle::ParamCapture *paramCapture);
void CaptureTextureSubImage2D_pixels(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels,
                                     angle::ParamCapture *paramCapture);
void CaptureTextureSubImage3D_pixels(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     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 CaptureVertexArrayVertexBuffers_buffersPacked(const State &glState,
                                                   bool isCallValid,
                                                   VertexArrayID vaobjPacked,
                                                   GLuint first,
                                                   GLsizei count,
                                                   const BufferID *buffersPacked,
                                                   const GLintptr *offsets,
                                                   const GLsizei *strides,
                                                   angle::ParamCapture *paramCapture);
void CaptureVertexArrayVertexBuffers_offsets(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint first,
                                             GLsizei count,
                                             const BufferID *buffersPacked,
                                             const GLintptr *offsets,
                                             const GLsizei *strides,
                                             angle::ParamCapture *paramCapture);
void CaptureVertexArrayVertexBuffers_strides(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint first,
                                             GLsizei count,
                                             const BufferID *buffersPacked,
                                             const GLintptr *offsets,
                                             const GLsizei *strides,
                                             angle::ParamCapture *paramCapture);

// GL 4.6
void CaptureMultiDrawArraysIndirectCount_indirect(const State &glState,
                                                  bool isCallValid,
                                                  GLenum mode,
                                                  const void *indirect,
                                                  GLintptr drawcount,
                                                  GLsizei maxdrawcount,
                                                  GLsizei stride,
                                                  angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsIndirectCount_indirect(const State &glState,
                                                    bool isCallValid,
                                                    GLenum mode,
                                                    GLenum type,
                                                    const void *indirect,
                                                    GLintptr drawcount,
                                                    GLsizei maxdrawcount,
                                                    GLsizei stride,
                                                    angle::ParamCapture *paramCapture);
void CaptureSpecializeShader_pEntryPoint(const State &glState,
                                         bool isCallValid,
                                         GLuint shader,
                                         const GLchar *pEntryPoint,
                                         GLuint numSpecializationConstants,
                                         const GLuint *pConstantIndex,
                                         const GLuint *pConstantValue,
                                         angle::ParamCapture *paramCapture);
void CaptureSpecializeShader_pConstantIndex(const State &glState,
                                            bool isCallValid,
                                            GLuint shader,
                                            const GLchar *pEntryPoint,
                                            GLuint numSpecializationConstants,
                                            const GLuint *pConstantIndex,
                                            const GLuint *pConstantValue,
                                            angle::ParamCapture *paramCapture);
void CaptureSpecializeShader_pConstantValue(const State &glState,
                                            bool isCallValid,
                                            GLuint shader,
                                            const GLchar *pEntryPoint,
                                            GLuint numSpecializationConstants,
                                            const GLuint *pConstantIndex,
                                            const GLuint *pConstantValue,
                                            angle::ParamCapture *paramCapture);
}  // namespace gl

#endif  // LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
