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

#ifndef LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
#define LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_

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

namespace gl
{

// Method Captures

// GL 1.0
angle::CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value);
angle::CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode);
angle::CallCapture CaptureBitmap(const State &glState,
                                 bool isCallValid,
                                 GLsizei width,
                                 GLsizei height,
                                 GLfloat xorig,
                                 GLfloat yorig,
                                 GLfloat xmove,
                                 GLfloat ymove,
                                 const GLubyte *bitmap);
angle::CallCapture CaptureCallList(const State &glState, bool isCallValid, GLuint list);
angle::CallCapture CaptureCallLists(const State &glState,
                                    bool isCallValid,
                                    GLsizei n,
                                    GLenum type,
                                    const void *lists);
angle::CallCapture CaptureClearAccum(const State &glState,
                                     bool isCallValid,
                                     GLfloat red,
                                     GLfloat green,
                                     GLfloat blue,
                                     GLfloat alpha);
angle::CallCapture CaptureClearDepth(const State &glState, bool isCallValid, GLdouble depth);
angle::CallCapture CaptureClearIndex(const State &glState, bool isCallValid, GLfloat c);
angle::CallCapture CaptureClipPlane(const State &glState,
                                    bool isCallValid,
                                    GLenum plane,
                                    const GLdouble *equation);
angle::CallCapture CaptureColor3b(const State &glState,
                                  bool isCallValid,
                                  GLbyte red,
                                  GLbyte green,
                                  GLbyte blue);
angle::CallCapture CaptureColor3bv(const State &glState, bool isCallValid, const GLbyte *v);
angle::CallCapture CaptureColor3d(const State &glState,
                                  bool isCallValid,
                                  GLdouble red,
                                  GLdouble green,
                                  GLdouble blue);
angle::CallCapture CaptureColor3dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureColor3f(const State &glState,
                                  bool isCallValid,
                                  GLfloat red,
                                  GLfloat green,
                                  GLfloat blue);
angle::CallCapture CaptureColor3fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureColor3i(const State &glState,
                                  bool isCallValid,
                                  GLint red,
                                  GLint green,
                                  GLint blue);
angle::CallCapture CaptureColor3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureColor3s(const State &glState,
                                  bool isCallValid,
                                  GLshort red,
                                  GLshort green,
                                  GLshort blue);
angle::CallCapture CaptureColor3sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureColor3ub(const State &glState,
                                   bool isCallValid,
                                   GLubyte red,
                                   GLubyte green,
                                   GLubyte blue);
angle::CallCapture CaptureColor3ubv(const State &glState, bool isCallValid, const GLubyte *v);
angle::CallCapture CaptureColor3ui(const State &glState,
                                   bool isCallValid,
                                   GLuint red,
                                   GLuint green,
                                   GLuint blue);
angle::CallCapture CaptureColor3uiv(const State &glState, bool isCallValid, const GLuint *v);
angle::CallCapture CaptureColor3us(const State &glState,
                                   bool isCallValid,
                                   GLushort red,
                                   GLushort green,
                                   GLushort blue);
angle::CallCapture CaptureColor3usv(const State &glState, bool isCallValid, const GLushort *v);
angle::CallCapture CaptureColor4b(const State &glState,
                                  bool isCallValid,
                                  GLbyte red,
                                  GLbyte green,
                                  GLbyte blue,
                                  GLbyte alpha);
angle::CallCapture CaptureColor4bv(const State &glState, bool isCallValid, const GLbyte *v);
angle::CallCapture CaptureColor4d(const State &glState,
                                  bool isCallValid,
                                  GLdouble red,
                                  GLdouble green,
                                  GLdouble blue,
                                  GLdouble alpha);
angle::CallCapture CaptureColor4dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureColor4fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureColor4i(const State &glState,
                                  bool isCallValid,
                                  GLint red,
                                  GLint green,
                                  GLint blue,
                                  GLint alpha);
angle::CallCapture CaptureColor4iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureColor4s(const State &glState,
                                  bool isCallValid,
                                  GLshort red,
                                  GLshort green,
                                  GLshort blue,
                                  GLshort alpha);
angle::CallCapture CaptureColor4sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureColor4ubv(const State &glState, bool isCallValid, const GLubyte *v);
angle::CallCapture CaptureColor4ui(const State &glState,
                                   bool isCallValid,
                                   GLuint red,
                                   GLuint green,
                                   GLuint blue,
                                   GLuint alpha);
angle::CallCapture CaptureColor4uiv(const State &glState, bool isCallValid, const GLuint *v);
angle::CallCapture CaptureColor4us(const State &glState,
                                   bool isCallValid,
                                   GLushort red,
                                   GLushort green,
                                   GLushort blue,
                                   GLushort alpha);
angle::CallCapture CaptureColor4usv(const State &glState, bool isCallValid, const GLushort *v);
angle::CallCapture CaptureColorMaterial(const State &glState,
                                        bool isCallValid,
                                        GLenum face,
                                        GLenum mode);
angle::CallCapture CaptureCopyPixels(const State &glState,
                                     bool isCallValid,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum type);
angle::CallCapture CaptureDeleteLists(const State &glState,
                                      bool isCallValid,
                                      GLuint list,
                                      GLsizei range);
angle::CallCapture CaptureDepthRange(const State &glState,
                                     bool isCallValid,
                                     GLdouble n,
                                     GLdouble f);
angle::CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf);
angle::CallCapture CaptureDrawPixels(const State &glState,
                                     bool isCallValid,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels);
angle::CallCapture CaptureEdgeFlag(const State &glState, bool isCallValid, GLboolean flag);
angle::CallCapture CaptureEdgeFlagv(const State &glState, bool isCallValid, const GLboolean *flag);
angle::CallCapture CaptureEnd(const State &glState, bool isCallValid);
angle::CallCapture CaptureEndList(const State &glState, bool isCallValid);
angle::CallCapture CaptureEvalCoord1d(const State &glState, bool isCallValid, GLdouble u);
angle::CallCapture CaptureEvalCoord1dv(const State &glState, bool isCallValid, const GLdouble *u);
angle::CallCapture CaptureEvalCoord1f(const State &glState, bool isCallValid, GLfloat u);
angle::CallCapture CaptureEvalCoord1fv(const State &glState, bool isCallValid, const GLfloat *u);
angle::CallCapture CaptureEvalCoord2d(const State &glState,
                                      bool isCallValid,
                                      GLdouble u,
                                      GLdouble v);
angle::CallCapture CaptureEvalCoord2dv(const State &glState, bool isCallValid, const GLdouble *u);
angle::CallCapture CaptureEvalCoord2f(const State &glState, bool isCallValid, GLfloat u, GLfloat v);
angle::CallCapture CaptureEvalCoord2fv(const State &glState, bool isCallValid, const GLfloat *u);
angle::CallCapture CaptureEvalMesh1(const State &glState,
                                    bool isCallValid,
                                    GLenum mode,
                                    GLint i1,
                                    GLint i2);
angle::CallCapture CaptureEvalMesh2(const State &glState,
                                    bool isCallValid,
                                    GLenum mode,
                                    GLint i1,
                                    GLint i2,
                                    GLint j1,
                                    GLint j2);
angle::CallCapture CaptureEvalPoint1(const State &glState, bool isCallValid, GLint i);
angle::CallCapture CaptureEvalPoint2(const State &glState, bool isCallValid, GLint i, GLint j);
angle::CallCapture CaptureFeedbackBuffer(const State &glState,
                                         bool isCallValid,
                                         GLsizei size,
                                         GLenum type,
                                         GLfloat *buffer);
angle::CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GLint param);
angle::CallCapture CaptureFogiv(const State &glState,
                                bool isCallValid,
                                GLenum pname,
                                const GLint *params);
angle::CallCapture CaptureFrustum(const State &glState,
                                  bool isCallValid,
                                  GLdouble left,
                                  GLdouble right,
                                  GLdouble bottom,
                                  GLdouble top,
                                  GLdouble zNear,
                                  GLdouble zFar);
angle::CallCapture CaptureGenLists(const State &glState,
                                   bool isCallValid,
                                   GLsizei range,
                                   GLuint returnValue);
angle::CallCapture CaptureGetClipPlane(const State &glState,
                                       bool isCallValid,
                                       GLenum plane,
                                       GLdouble *equation);
angle::CallCapture CaptureGetDoublev(const State &glState,
                                     bool isCallValid,
                                     GLenum pname,
                                     GLdouble *data);
angle::CallCapture CaptureGetLightiv(const State &glState,
                                     bool isCallValid,
                                     GLenum light,
                                     GLenum pname,
                                     GLint *params);
angle::CallCapture CaptureGetMapdv(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLenum query,
                                   GLdouble *v);
angle::CallCapture CaptureGetMapfv(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLenum query,
                                   GLfloat *v);
angle::CallCapture CaptureGetMapiv(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLenum query,
                                   GLint *v);
angle::CallCapture CaptureGetMaterialiv(const State &glState,
                                        bool isCallValid,
                                        GLenum face,
                                        GLenum pname,
                                        GLint *params);
angle::CallCapture CaptureGetPixelMapfv(const State &glState,
                                        bool isCallValid,
                                        GLenum map,
                                        GLfloat *values);
angle::CallCapture CaptureGetPixelMapuiv(const State &glState,
                                         bool isCallValid,
                                         GLenum map,
                                         GLuint *values);
angle::CallCapture CaptureGetPixelMapusv(const State &glState,
                                         bool isCallValid,
                                         GLenum map,
                                         GLushort *values);
angle::CallCapture CaptureGetPolygonStipple(const State &glState, bool isCallValid, GLubyte *mask);
angle::CallCapture CaptureGetTexGendv(const State &glState,
                                      bool isCallValid,
                                      GLenum coord,
                                      GLenum pname,
                                      GLdouble *params);
angle::CallCapture CaptureGetTexGenfv(const State &glState,
                                      bool isCallValid,
                                      GLenum coord,
                                      GLenum pname,
                                      GLfloat *params);
angle::CallCapture CaptureGetTexGeniv(const State &glState,
                                      bool isCallValid,
                                      GLenum coord,
                                      GLenum pname,
                                      GLint *params);
angle::CallCapture CaptureGetTexImage(const State &glState,
                                      bool isCallValid,
                                      TextureTarget targetPacked,
                                      GLint level,
                                      GLenum format,
                                      GLenum type,
                                      void *pixels);
angle::CallCapture CaptureIndexMask(const State &glState, bool isCallValid, GLuint mask);
angle::CallCapture CaptureIndexd(const State &glState, bool isCallValid, GLdouble c);
angle::CallCapture CaptureIndexdv(const State &glState, bool isCallValid, const GLdouble *c);
angle::CallCapture CaptureIndexf(const State &glState, bool isCallValid, GLfloat c);
angle::CallCapture CaptureIndexfv(const State &glState, bool isCallValid, const GLfloat *c);
angle::CallCapture CaptureIndexi(const State &glState, bool isCallValid, GLint c);
angle::CallCapture CaptureIndexiv(const State &glState, bool isCallValid, const GLint *c);
angle::CallCapture CaptureIndexs(const State &glState, bool isCallValid, GLshort c);
angle::CallCapture CaptureIndexsv(const State &glState, bool isCallValid, const GLshort *c);
angle::CallCapture CaptureInitNames(const State &glState, bool isCallValid);
angle::CallCapture CaptureIsList(const State &glState,
                                 bool isCallValid,
                                 GLuint list,
                                 GLboolean returnValue);
angle::CallCapture CaptureLightModeli(const State &glState,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLint param);
angle::CallCapture CaptureLightModeliv(const State &glState,
                                       bool isCallValid,
                                       GLenum pname,
                                       const GLint *params);
angle::CallCapture CaptureLighti(const State &glState,
                                 bool isCallValid,
                                 GLenum light,
                                 GLenum pname,
                                 GLint param);
angle::CallCapture CaptureLightiv(const State &glState,
                                  bool isCallValid,
                                  GLenum light,
                                  GLenum pname,
                                  const GLint *params);
angle::CallCapture CaptureLineStipple(const State &glState,
                                      bool isCallValid,
                                      GLint factor,
                                      GLushort pattern);
angle::CallCapture CaptureListBase(const State &glState, bool isCallValid, GLuint base);
angle::CallCapture CaptureLoadMatrixd(const State &glState, bool isCallValid, const GLdouble *m);
angle::CallCapture CaptureLoadName(const State &glState, bool isCallValid, GLuint name);
angle::CallCapture CaptureMap1d(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLdouble u1,
                                GLdouble u2,
                                GLint stride,
                                GLint order,
                                const GLdouble *points);
angle::CallCapture CaptureMap1f(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLfloat u1,
                                GLfloat u2,
                                GLint stride,
                                GLint order,
                                const GLfloat *points);
angle::CallCapture CaptureMap2d(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLdouble u1,
                                GLdouble u2,
                                GLint ustride,
                                GLint uorder,
                                GLdouble v1,
                                GLdouble v2,
                                GLint vstride,
                                GLint vorder,
                                const GLdouble *points);
angle::CallCapture CaptureMap2f(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLfloat u1,
                                GLfloat u2,
                                GLint ustride,
                                GLint uorder,
                                GLfloat v1,
                                GLfloat v2,
                                GLint vstride,
                                GLint vorder,
                                const GLfloat *points);
angle::CallCapture CaptureMapGrid1d(const State &glState,
                                    bool isCallValid,
                                    GLint un,
                                    GLdouble u1,
                                    GLdouble u2);
angle::CallCapture CaptureMapGrid1f(const State &glState,
                                    bool isCallValid,
                                    GLint un,
                                    GLfloat u1,
                                    GLfloat u2);
angle::CallCapture CaptureMapGrid2d(const State &glState,
                                    bool isCallValid,
                                    GLint un,
                                    GLdouble u1,
                                    GLdouble u2,
                                    GLint vn,
                                    GLdouble v1,
                                    GLdouble v2);
angle::CallCapture CaptureMapGrid2f(const State &glState,
                                    bool isCallValid,
                                    GLint un,
                                    GLfloat u1,
                                    GLfloat u2,
                                    GLint vn,
                                    GLfloat v1,
                                    GLfloat v2);
angle::CallCapture CaptureMateriali(const State &glState,
                                    bool isCallValid,
                                    GLenum face,
                                    GLenum pname,
                                    GLint param);
angle::CallCapture CaptureMaterialiv(const State &glState,
                                     bool isCallValid,
                                     GLenum face,
                                     GLenum pname,
                                     const GLint *params);
angle::CallCapture CaptureMultMatrixd(const State &glState, bool isCallValid, const GLdouble *m);
angle::CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, GLenum mode);
angle::CallCapture CaptureNormal3b(const State &glState,
                                   bool isCallValid,
                                   GLbyte nx,
                                   GLbyte ny,
                                   GLbyte nz);
angle::CallCapture CaptureNormal3bv(const State &glState, bool isCallValid, const GLbyte *v);
angle::CallCapture CaptureNormal3d(const State &glState,
                                   bool isCallValid,
                                   GLdouble nx,
                                   GLdouble ny,
                                   GLdouble nz);
angle::CallCapture CaptureNormal3dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureNormal3fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureNormal3i(const State &glState,
                                   bool isCallValid,
                                   GLint nx,
                                   GLint ny,
                                   GLint nz);
angle::CallCapture CaptureNormal3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureNormal3s(const State &glState,
                                   bool isCallValid,
                                   GLshort nx,
                                   GLshort ny,
                                   GLshort nz);
angle::CallCapture CaptureNormal3sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureOrtho(const State &glState,
                                bool isCallValid,
                                GLdouble left,
                                GLdouble right,
                                GLdouble bottom,
                                GLdouble top,
                                GLdouble zNear,
                                GLdouble zFar);
angle::CallCapture CapturePassThrough(const State &glState, bool isCallValid, GLfloat token);
angle::CallCapture CapturePixelMapfv(const State &glState,
                                     bool isCallValid,
                                     GLenum map,
                                     GLsizei mapsize,
                                     const GLfloat *values);
angle::CallCapture CapturePixelMapuiv(const State &glState,
                                      bool isCallValid,
                                      GLenum map,
                                      GLsizei mapsize,
                                      const GLuint *values);
angle::CallCapture CapturePixelMapusv(const State &glState,
                                      bool isCallValid,
                                      GLenum map,
                                      GLsizei mapsize,
                                      const GLushort *values);
angle::CallCapture CapturePixelStoref(const State &glState,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLfloat param);
angle::CallCapture CapturePixelTransferf(const State &glState,
                                         bool isCallValid,
                                         GLenum pname,
                                         GLfloat param);
angle::CallCapture CapturePixelTransferi(const State &glState,
                                         bool isCallValid,
                                         GLenum pname,
                                         GLint param);
angle::CallCapture CapturePixelZoom(const State &glState,
                                    bool isCallValid,
                                    GLfloat xfactor,
                                    GLfloat yfactor);
angle::CallCapture CapturePolygonMode(const State &glState,
                                      bool isCallValid,
                                      GLenum face,
                                      GLenum mode);
angle::CallCapture CapturePolygonStipple(const State &glState,
                                         bool isCallValid,
                                         const GLubyte *mask);
angle::CallCapture CapturePopAttrib(const State &glState, bool isCallValid);
angle::CallCapture CapturePopName(const State &glState, bool isCallValid);
angle::CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield mask);
angle::CallCapture CapturePushName(const State &glState, bool isCallValid, GLuint name);
angle::CallCapture CaptureRasterPos2d(const State &glState,
                                      bool isCallValid,
                                      GLdouble x,
                                      GLdouble y);
angle::CallCapture CaptureRasterPos2dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureRasterPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
angle::CallCapture CaptureRasterPos2fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureRasterPos2i(const State &glState, bool isCallValid, GLint x, GLint y);
angle::CallCapture CaptureRasterPos2iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureRasterPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
angle::CallCapture CaptureRasterPos2sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureRasterPos3d(const State &glState,
                                      bool isCallValid,
                                      GLdouble x,
                                      GLdouble y,
                                      GLdouble z);
angle::CallCapture CaptureRasterPos3dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureRasterPos3f(const State &glState,
                                      bool isCallValid,
                                      GLfloat x,
                                      GLfloat y,
                                      GLfloat z);
angle::CallCapture CaptureRasterPos3fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureRasterPos3i(const State &glState,
                                      bool isCallValid,
                                      GLint x,
                                      GLint y,
                                      GLint z);
angle::CallCapture CaptureRasterPos3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureRasterPos3s(const State &glState,
                                      bool isCallValid,
                                      GLshort x,
                                      GLshort y,
                                      GLshort z);
angle::CallCapture CaptureRasterPos3sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureRasterPos4d(const State &glState,
                                      bool isCallValid,
                                      GLdouble x,
                                      GLdouble y,
                                      GLdouble z,
                                      GLdouble w);
angle::CallCapture CaptureRasterPos4dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureRasterPos4f(const State &glState,
                                      bool isCallValid,
                                      GLfloat x,
                                      GLfloat y,
                                      GLfloat z,
                                      GLfloat w);
angle::CallCapture CaptureRasterPos4fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureRasterPos4i(const State &glState,
                                      bool isCallValid,
                                      GLint x,
                                      GLint y,
                                      GLint z,
                                      GLint w);
angle::CallCapture CaptureRasterPos4iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureRasterPos4s(const State &glState,
                                      bool isCallValid,
                                      GLshort x,
                                      GLshort y,
                                      GLshort z,
                                      GLshort w);
angle::CallCapture CaptureRasterPos4sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureRectd(const State &glState,
                                bool isCallValid,
                                GLdouble x1,
                                GLdouble y1,
                                GLdouble x2,
                                GLdouble y2);
angle::CallCapture CaptureRectdv(const State &glState,
                                 bool isCallValid,
                                 const GLdouble *v1,
                                 const GLdouble *v2);
angle::CallCapture CaptureRectf(const State &glState,
                                bool isCallValid,
                                GLfloat x1,
                                GLfloat y1,
                                GLfloat x2,
                                GLfloat y2);
angle::CallCapture CaptureRectfv(const State &glState,
                                 bool isCallValid,
                                 const GLfloat *v1,
                                 const GLfloat *v2);
angle::CallCapture CaptureRecti(const State &glState,
                                bool isCallValid,
                                GLint x1,
                                GLint y1,
                                GLint x2,
                                GLint y2);
angle::CallCapture CaptureRectiv(const State &glState,
                                 bool isCallValid,
                                 const GLint *v1,
                                 const GLint *v2);
angle::CallCapture CaptureRects(const State &glState,
                                bool isCallValid,
                                GLshort x1,
                                GLshort y1,
                                GLshort x2,
                                GLshort y2);
angle::CallCapture CaptureRectsv(const State &glState,
                                 bool isCallValid,
                                 const GLshort *v1,
                                 const GLshort *v2);
angle::CallCapture CaptureRenderMode(const State &glState,
                                     bool isCallValid,
                                     GLenum mode,
                                     GLint returnValue);
angle::CallCapture CaptureRotated(const State &glState,
                                  bool isCallValid,
                                  GLdouble angle,
                                  GLdouble x,
                                  GLdouble y,
                                  GLdouble z);
angle::CallCapture CaptureScaled(const State &glState,
                                 bool isCallValid,
                                 GLdouble x,
                                 GLdouble y,
                                 GLdouble z);
angle::CallCapture CaptureSelectBuffer(const State &glState,
                                       bool isCallValid,
                                       GLsizei size,
                                       GLuint *buffer);
angle::CallCapture CaptureTexCoord1d(const State &glState, bool isCallValid, GLdouble s);
angle::CallCapture CaptureTexCoord1dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureTexCoord1f(const State &glState, bool isCallValid, GLfloat s);
angle::CallCapture CaptureTexCoord1fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureTexCoord1i(const State &glState, bool isCallValid, GLint s);
angle::CallCapture CaptureTexCoord1iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureTexCoord1s(const State &glState, bool isCallValid, GLshort s);
angle::CallCapture CaptureTexCoord1sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureTexCoord2d(const State &glState,
                                     bool isCallValid,
                                     GLdouble s,
                                     GLdouble t);
angle::CallCapture CaptureTexCoord2dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureTexCoord2f(const State &glState, bool isCallValid, GLfloat s, GLfloat t);
angle::CallCapture CaptureTexCoord2fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureTexCoord2i(const State &glState, bool isCallValid, GLint s, GLint t);
angle::CallCapture CaptureTexCoord2iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureTexCoord2s(const State &glState, bool isCallValid, GLshort s, GLshort t);
angle::CallCapture CaptureTexCoord2sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureTexCoord3d(const State &glState,
                                     bool isCallValid,
                                     GLdouble s,
                                     GLdouble t,
                                     GLdouble r);
angle::CallCapture CaptureTexCoord3dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureTexCoord3f(const State &glState,
                                     bool isCallValid,
                                     GLfloat s,
                                     GLfloat t,
                                     GLfloat r);
angle::CallCapture CaptureTexCoord3fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureTexCoord3i(const State &glState,
                                     bool isCallValid,
                                     GLint s,
                                     GLint t,
                                     GLint r);
angle::CallCapture CaptureTexCoord3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureTexCoord3s(const State &glState,
                                     bool isCallValid,
                                     GLshort s,
                                     GLshort t,
                                     GLshort r);
angle::CallCapture CaptureTexCoord3sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureTexCoord4d(const State &glState,
                                     bool isCallValid,
                                     GLdouble s,
                                     GLdouble t,
                                     GLdouble r,
                                     GLdouble q);
angle::CallCapture CaptureTexCoord4dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureTexCoord4f(const State &glState,
                                     bool isCallValid,
                                     GLfloat s,
                                     GLfloat t,
                                     GLfloat r,
                                     GLfloat q);
angle::CallCapture CaptureTexCoord4fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureTexCoord4i(const State &glState,
                                     bool isCallValid,
                                     GLint s,
                                     GLint t,
                                     GLint r,
                                     GLint q);
angle::CallCapture CaptureTexCoord4iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureTexCoord4s(const State &glState,
                                     bool isCallValid,
                                     GLshort s,
                                     GLshort t,
                                     GLshort r,
                                     GLshort q);
angle::CallCapture CaptureTexCoord4sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureTexGend(const State &glState,
                                  bool isCallValid,
                                  GLenum coord,
                                  GLenum pname,
                                  GLdouble param);
angle::CallCapture CaptureTexGendv(const State &glState,
                                   bool isCallValid,
                                   GLenum coord,
                                   GLenum pname,
                                   const GLdouble *params);
angle::CallCapture CaptureTexGenf(const State &glState,
                                  bool isCallValid,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfloat param);
angle::CallCapture CaptureTexGenfv(const State &glState,
                                   bool isCallValid,
                                   GLenum coord,
                                   GLenum pname,
                                   const GLfloat *params);
angle::CallCapture CaptureTexGeni(const State &glState,
                                  bool isCallValid,
                                  GLenum coord,
                                  GLenum pname,
                                  GLint param);
angle::CallCapture CaptureTexGeniv(const State &glState,
                                   bool isCallValid,
                                   GLenum coord,
                                   GLenum pname,
                                   const GLint *params);
angle::CallCapture CaptureTexImage1D(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLint level,
                                     GLint internalformat,
                                     GLsizei width,
                                     GLint border,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels);
angle::CallCapture CaptureTranslated(const State &glState,
                                     bool isCallValid,
                                     GLdouble x,
                                     GLdouble y,
                                     GLdouble z);
angle::CallCapture CaptureVertex2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y);
angle::CallCapture CaptureVertex2dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureVertex2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
angle::CallCapture CaptureVertex2fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureVertex2i(const State &glState, bool isCallValid, GLint x, GLint y);
angle::CallCapture CaptureVertex2iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureVertex2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
angle::CallCapture CaptureVertex2sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureVertex3d(const State &glState,
                                   bool isCallValid,
                                   GLdouble x,
                                   GLdouble y,
                                   GLdouble z);
angle::CallCapture CaptureVertex3dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureVertex3f(const State &glState,
                                   bool isCallValid,
                                   GLfloat x,
                                   GLfloat y,
                                   GLfloat z);
angle::CallCapture CaptureVertex3fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureVertex3i(const State &glState,
                                   bool isCallValid,
                                   GLint x,
                                   GLint y,
                                   GLint z);
angle::CallCapture CaptureVertex3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureVertex3s(const State &glState,
                                   bool isCallValid,
                                   GLshort x,
                                   GLshort y,
                                   GLshort z);
angle::CallCapture CaptureVertex3sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureVertex4d(const State &glState,
                                   bool isCallValid,
                                   GLdouble x,
                                   GLdouble y,
                                   GLdouble z,
                                   GLdouble w);
angle::CallCapture CaptureVertex4dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureVertex4f(const State &glState,
                                   bool isCallValid,
                                   GLfloat x,
                                   GLfloat y,
                                   GLfloat z,
                                   GLfloat w);
angle::CallCapture CaptureVertex4fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureVertex4i(const State &glState,
                                   bool isCallValid,
                                   GLint x,
                                   GLint y,
                                   GLint z,
                                   GLint w);
angle::CallCapture CaptureVertex4iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureVertex4s(const State &glState,
                                   bool isCallValid,
                                   GLshort x,
                                   GLshort y,
                                   GLshort z,
                                   GLshort w);
angle::CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLshort *v);

// GL 1.1
angle::CallCapture CaptureAreTexturesResident(const State &glState,
                                              bool isCallValid,
                                              GLsizei n,
                                              const GLuint *textures,
                                              GLboolean *residences,
                                              GLboolean returnValue);
angle::CallCapture CaptureArrayElement(const State &glState, bool isCallValid, GLint i);
angle::CallCapture CaptureCopyTexImage1D(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLint level,
                                         GLenum internalformat,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLint border);
angle::CallCapture CaptureCopyTexSubImage1D(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLint level,
                                            GLint xoffset,
                                            GLint x,
                                            GLint y,
                                            GLsizei width);
angle::CallCapture CaptureEdgeFlagPointer(const State &glState,
                                          bool isCallValid,
                                          GLsizei stride,
                                          const void *pointer);
angle::CallCapture CaptureIndexPointer(const State &glState,
                                       bool isCallValid,
                                       GLenum type,
                                       GLsizei stride,
                                       const void *pointer);
angle::CallCapture CaptureIndexub(const State &glState, bool isCallValid, GLubyte c);
angle::CallCapture CaptureIndexubv(const State &glState, bool isCallValid, const GLubyte *c);
angle::CallCapture CaptureInterleavedArrays(const State &glState,
                                            bool isCallValid,
                                            GLenum format,
                                            GLsizei stride,
                                            const void *pointer);
angle::CallCapture CapturePopClientAttrib(const State &glState, bool isCallValid);
angle::CallCapture CapturePrioritizeTextures(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             const GLuint *textures,
                                             const GLfloat *priorities);
angle::CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbitfield mask);
angle::CallCapture CaptureTexSubImage1D(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLint level,
                                        GLint xoffset,
                                        GLsizei width,
                                        GLenum format,
                                        GLenum type,
                                        const void *pixels);

// GL 1.2

// GL 1.3
angle::CallCapture CaptureCompressedTexImage1D(const State &glState,
                                               bool isCallValid,
                                               GLenum target,
                                               GLint level,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLint border,
                                               GLsizei imageSize,
                                               const void *data);
angle::CallCapture CaptureCompressedTexSubImage1D(const State &glState,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLint level,
                                                  GLint xoffset,
                                                  GLsizei width,
                                                  GLenum format,
                                                  GLsizei imageSize,
                                                  const void *data);
angle::CallCapture CaptureGetCompressedTexImage(const State &glState,
                                                bool isCallValid,
                                                TextureTarget targetPacked,
                                                GLint level,
                                                void *img);
angle::CallCapture CaptureLoadTransposeMatrixd(const State &glState,
                                               bool isCallValid,
                                               const GLdouble *m);
angle::CallCapture CaptureLoadTransposeMatrixf(const State &glState,
                                               bool isCallValid,
                                               const GLfloat *m);
angle::CallCapture CaptureMultTransposeMatrixd(const State &glState,
                                               bool isCallValid,
                                               const GLdouble *m);
angle::CallCapture CaptureMultTransposeMatrixf(const State &glState,
                                               bool isCallValid,
                                               const GLfloat *m);
angle::CallCapture CaptureMultiTexCoord1d(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLdouble s);
angle::CallCapture CaptureMultiTexCoord1dv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLdouble *v);
angle::CallCapture CaptureMultiTexCoord1f(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLfloat s);
angle::CallCapture CaptureMultiTexCoord1fv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLfloat *v);
angle::CallCapture CaptureMultiTexCoord1i(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLint s);
angle::CallCapture CaptureMultiTexCoord1iv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLint *v);
angle::CallCapture CaptureMultiTexCoord1s(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLshort s);
angle::CallCapture CaptureMultiTexCoord1sv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLshort *v);
angle::CallCapture CaptureMultiTexCoord2d(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLdouble s,
                                          GLdouble t);
angle::CallCapture CaptureMultiTexCoord2dv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLdouble *v);
angle::CallCapture CaptureMultiTexCoord2f(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLfloat s,
                                          GLfloat t);
angle::CallCapture CaptureMultiTexCoord2fv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLfloat *v);
angle::CallCapture CaptureMultiTexCoord2i(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLint s,
                                          GLint t);
angle::CallCapture CaptureMultiTexCoord2iv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLint *v);
angle::CallCapture CaptureMultiTexCoord2s(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLshort s,
                                          GLshort t);
angle::CallCapture CaptureMultiTexCoord2sv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLshort *v);
angle::CallCapture CaptureMultiTexCoord3d(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLdouble s,
                                          GLdouble t,
                                          GLdouble r);
angle::CallCapture CaptureMultiTexCoord3dv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLdouble *v);
angle::CallCapture CaptureMultiTexCoord3f(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLfloat s,
                                          GLfloat t,
                                          GLfloat r);
angle::CallCapture CaptureMultiTexCoord3fv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLfloat *v);
angle::CallCapture CaptureMultiTexCoord3i(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLint s,
                                          GLint t,
                                          GLint r);
angle::CallCapture CaptureMultiTexCoord3iv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLint *v);
angle::CallCapture CaptureMultiTexCoord3s(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLshort s,
                                          GLshort t,
                                          GLshort r);
angle::CallCapture CaptureMultiTexCoord3sv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLshort *v);
angle::CallCapture CaptureMultiTexCoord4d(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLdouble s,
                                          GLdouble t,
                                          GLdouble r,
                                          GLdouble q);
angle::CallCapture CaptureMultiTexCoord4dv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLdouble *v);
angle::CallCapture CaptureMultiTexCoord4fv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLfloat *v);
angle::CallCapture CaptureMultiTexCoord4i(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLint s,
                                          GLint t,
                                          GLint r,
                                          GLint q);
angle::CallCapture CaptureMultiTexCoord4iv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLint *v);
angle::CallCapture CaptureMultiTexCoord4s(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLshort s,
                                          GLshort t,
                                          GLshort r,
                                          GLshort q);
angle::CallCapture CaptureMultiTexCoord4sv(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           const GLshort *v);

// GL 1.4
angle::CallCapture CaptureFogCoordPointer(const State &glState,
                                          bool isCallValid,
                                          GLenum type,
                                          GLsizei stride,
                                          const void *pointer);
angle::CallCapture CaptureFogCoordd(const State &glState, bool isCallValid, GLdouble coord);
angle::CallCapture CaptureFogCoorddv(const State &glState, bool isCallValid, const GLdouble *coord);
angle::CallCapture CaptureFogCoordf(const State &glState, bool isCallValid, GLfloat coord);
angle::CallCapture CaptureFogCoordfv(const State &glState, bool isCallValid, const GLfloat *coord);
angle::CallCapture CaptureMultiDrawArrays(const State &glState,
                                          bool isCallValid,
                                          PrimitiveMode modePacked,
                                          const GLint *first,
                                          const GLsizei *count,
                                          GLsizei drawcount);
angle::CallCapture CaptureMultiDrawElements(const State &glState,
                                            bool isCallValid,
                                            PrimitiveMode modePacked,
                                            const GLsizei *count,
                                            DrawElementsType typePacked,
                                            const void *const *indices,
                                            GLsizei drawcount);
angle::CallCapture CapturePointParameteri(const State &glState,
                                          bool isCallValid,
                                          GLenum pname,
                                          GLint param);
angle::CallCapture CapturePointParameteriv(const State &glState,
                                           bool isCallValid,
                                           GLenum pname,
                                           const GLint *params);
angle::CallCapture CaptureSecondaryColor3b(const State &glState,
                                           bool isCallValid,
                                           GLbyte red,
                                           GLbyte green,
                                           GLbyte blue);
angle::CallCapture CaptureSecondaryColor3bv(const State &glState,
                                            bool isCallValid,
                                            const GLbyte *v);
angle::CallCapture CaptureSecondaryColor3d(const State &glState,
                                           bool isCallValid,
                                           GLdouble red,
                                           GLdouble green,
                                           GLdouble blue);
angle::CallCapture CaptureSecondaryColor3dv(const State &glState,
                                            bool isCallValid,
                                            const GLdouble *v);
angle::CallCapture CaptureSecondaryColor3f(const State &glState,
                                           bool isCallValid,
                                           GLfloat red,
                                           GLfloat green,
                                           GLfloat blue);
angle::CallCapture CaptureSecondaryColor3fv(const State &glState,
                                            bool isCallValid,
                                            const GLfloat *v);
angle::CallCapture CaptureSecondaryColor3i(const State &glState,
                                           bool isCallValid,
                                           GLint red,
                                           GLint green,
                                           GLint blue);
angle::CallCapture CaptureSecondaryColor3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureSecondaryColor3s(const State &glState,
                                           bool isCallValid,
                                           GLshort red,
                                           GLshort green,
                                           GLshort blue);
angle::CallCapture CaptureSecondaryColor3sv(const State &glState,
                                            bool isCallValid,
                                            const GLshort *v);
angle::CallCapture CaptureSecondaryColor3ub(const State &glState,
                                            bool isCallValid,
                                            GLubyte red,
                                            GLubyte green,
                                            GLubyte blue);
angle::CallCapture CaptureSecondaryColor3ubv(const State &glState,
                                             bool isCallValid,
                                             const GLubyte *v);
angle::CallCapture CaptureSecondaryColor3ui(const State &glState,
                                            bool isCallValid,
                                            GLuint red,
                                            GLuint green,
                                            GLuint blue);
angle::CallCapture CaptureSecondaryColor3uiv(const State &glState,
                                             bool isCallValid,
                                             const GLuint *v);
angle::CallCapture CaptureSecondaryColor3us(const State &glState,
                                            bool isCallValid,
                                            GLushort red,
                                            GLushort green,
                                            GLushort blue);
angle::CallCapture CaptureSecondaryColor3usv(const State &glState,
                                             bool isCallValid,
                                             const GLushort *v);
angle::CallCapture CaptureSecondaryColorPointer(const State &glState,
                                                bool isCallValid,
                                                GLint size,
                                                GLenum type,
                                                GLsizei stride,
                                                const void *pointer);
angle::CallCapture CaptureWindowPos2d(const State &glState,
                                      bool isCallValid,
                                      GLdouble x,
                                      GLdouble y);
angle::CallCapture CaptureWindowPos2dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureWindowPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
angle::CallCapture CaptureWindowPos2fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureWindowPos2i(const State &glState, bool isCallValid, GLint x, GLint y);
angle::CallCapture CaptureWindowPos2iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureWindowPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
angle::CallCapture CaptureWindowPos2sv(const State &glState, bool isCallValid, const GLshort *v);
angle::CallCapture CaptureWindowPos3d(const State &glState,
                                      bool isCallValid,
                                      GLdouble x,
                                      GLdouble y,
                                      GLdouble z);
angle::CallCapture CaptureWindowPos3dv(const State &glState, bool isCallValid, const GLdouble *v);
angle::CallCapture CaptureWindowPos3f(const State &glState,
                                      bool isCallValid,
                                      GLfloat x,
                                      GLfloat y,
                                      GLfloat z);
angle::CallCapture CaptureWindowPos3fv(const State &glState, bool isCallValid, const GLfloat *v);
angle::CallCapture CaptureWindowPos3i(const State &glState,
                                      bool isCallValid,
                                      GLint x,
                                      GLint y,
                                      GLint z);
angle::CallCapture CaptureWindowPos3iv(const State &glState, bool isCallValid, const GLint *v);
angle::CallCapture CaptureWindowPos3s(const State &glState,
                                      bool isCallValid,
                                      GLshort x,
                                      GLshort y,
                                      GLshort z);
angle::CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GLshort *v);

// GL 1.5
angle::CallCapture CaptureGetBufferSubData(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           GLintptr offset,
                                           GLsizeiptr size,
                                           void *data);
angle::CallCapture CaptureGetQueryObjectiv(const State &glState,
                                           bool isCallValid,
                                           QueryID idPacked,
                                           GLenum pname,
                                           GLint *params);
angle::CallCapture CaptureMapBuffer(const State &glState,
                                    bool isCallValid,
                                    BufferBinding targetPacked,
                                    GLenum access,
                                    void *returnValue);

// Parameter Captures

// GL 1.0
void CaptureBitmap_bitmap(const State &glState,
                          bool isCallValid,
                          GLsizei width,
                          GLsizei height,
                          GLfloat xorig,
                          GLfloat yorig,
                          GLfloat xmove,
                          GLfloat ymove,
                          const GLubyte *bitmap,
                          angle::ParamCapture *paramCapture);
void CaptureCallLists_lists(const State &glState,
                            bool isCallValid,
                            GLsizei n,
                            GLenum type,
                            const void *lists,
                            angle::ParamCapture *paramCapture);
void CaptureClipPlane_equation(const State &glState,
                               bool isCallValid,
                               GLenum plane,
                               const GLdouble *equation,
                               angle::ParamCapture *paramCapture);
void CaptureColor3bv_v(const State &glState,
                       bool isCallValid,
                       const GLbyte *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor3dv_v(const State &glState,
                       bool isCallValid,
                       const GLdouble *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor3fv_v(const State &glState,
                       bool isCallValid,
                       const GLfloat *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor3iv_v(const State &glState,
                       bool isCallValid,
                       const GLint *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor3sv_v(const State &glState,
                       bool isCallValid,
                       const GLshort *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor3ubv_v(const State &glState,
                        bool isCallValid,
                        const GLubyte *v,
                        angle::ParamCapture *paramCapture);
void CaptureColor3uiv_v(const State &glState,
                        bool isCallValid,
                        const GLuint *v,
                        angle::ParamCapture *paramCapture);
void CaptureColor3usv_v(const State &glState,
                        bool isCallValid,
                        const GLushort *v,
                        angle::ParamCapture *paramCapture);
void CaptureColor4bv_v(const State &glState,
                       bool isCallValid,
                       const GLbyte *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor4dv_v(const State &glState,
                       bool isCallValid,
                       const GLdouble *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor4fv_v(const State &glState,
                       bool isCallValid,
                       const GLfloat *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor4iv_v(const State &glState,
                       bool isCallValid,
                       const GLint *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor4sv_v(const State &glState,
                       bool isCallValid,
                       const GLshort *v,
                       angle::ParamCapture *paramCapture);
void CaptureColor4ubv_v(const State &glState,
                        bool isCallValid,
                        const GLubyte *v,
                        angle::ParamCapture *paramCapture);
void CaptureColor4uiv_v(const State &glState,
                        bool isCallValid,
                        const GLuint *v,
                        angle::ParamCapture *paramCapture);
void CaptureColor4usv_v(const State &glState,
                        bool isCallValid,
                        const GLushort *v,
                        angle::ParamCapture *paramCapture);
void CaptureDrawPixels_pixels(const State &glState,
                              bool isCallValid,
                              GLsizei width,
                              GLsizei height,
                              GLenum format,
                              GLenum type,
                              const void *pixels,
                              angle::ParamCapture *paramCapture);
void CaptureEdgeFlagv_flag(const State &glState,
                           bool isCallValid,
                           const GLboolean *flag,
                           angle::ParamCapture *paramCapture);
void CaptureEvalCoord1dv_u(const State &glState,
                           bool isCallValid,
                           const GLdouble *u,
                           angle::ParamCapture *paramCapture);
void CaptureEvalCoord1fv_u(const State &glState,
                           bool isCallValid,
                           const GLfloat *u,
                           angle::ParamCapture *paramCapture);
void CaptureEvalCoord2dv_u(const State &glState,
                           bool isCallValid,
                           const GLdouble *u,
                           angle::ParamCapture *paramCapture);
void CaptureEvalCoord2fv_u(const State &glState,
                           bool isCallValid,
                           const GLfloat *u,
                           angle::ParamCapture *paramCapture);
void CaptureFeedbackBuffer_buffer(const State &glState,
                                  bool isCallValid,
                                  GLsizei size,
                                  GLenum type,
                                  GLfloat *buffer,
                                  angle::ParamCapture *paramCapture);
void CaptureFogiv_params(const State &glState,
                         bool isCallValid,
                         GLenum pname,
                         const GLint *params,
                         angle::ParamCapture *paramCapture);
void CaptureGetClipPlane_equation(const State &glState,
                                  bool isCallValid,
                                  GLenum plane,
                                  GLdouble *equation,
                                  angle::ParamCapture *paramCapture);
void CaptureGetDoublev_data(const State &glState,
                            bool isCallValid,
                            GLenum pname,
                            GLdouble *data,
                            angle::ParamCapture *paramCapture);
void CaptureGetLightiv_params(const State &glState,
                              bool isCallValid,
                              GLenum light,
                              GLenum pname,
                              GLint *params,
                              angle::ParamCapture *paramCapture);
void CaptureGetMapdv_v(const State &glState,
                       bool isCallValid,
                       GLenum target,
                       GLenum query,
                       GLdouble *v,
                       angle::ParamCapture *paramCapture);
void CaptureGetMapfv_v(const State &glState,
                       bool isCallValid,
                       GLenum target,
                       GLenum query,
                       GLfloat *v,
                       angle::ParamCapture *paramCapture);
void CaptureGetMapiv_v(const State &glState,
                       bool isCallValid,
                       GLenum target,
                       GLenum query,
                       GLint *v,
                       angle::ParamCapture *paramCapture);
void CaptureGetMaterialiv_params(const State &glState,
                                 bool isCallValid,
                                 GLenum face,
                                 GLenum pname,
                                 GLint *params,
                                 angle::ParamCapture *paramCapture);
void CaptureGetPixelMapfv_values(const State &glState,
                                 bool isCallValid,
                                 GLenum map,
                                 GLfloat *values,
                                 angle::ParamCapture *paramCapture);
void CaptureGetPixelMapuiv_values(const State &glState,
                                  bool isCallValid,
                                  GLenum map,
                                  GLuint *values,
                                  angle::ParamCapture *paramCapture);
void CaptureGetPixelMapusv_values(const State &glState,
                                  bool isCallValid,
                                  GLenum map,
                                  GLushort *values,
                                  angle::ParamCapture *paramCapture);
void CaptureGetPolygonStipple_mask(const State &glState,
                                   bool isCallValid,
                                   GLubyte *mask,
                                   angle::ParamCapture *paramCapture);
void CaptureGetTexGendv_params(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               GLdouble *params,
                               angle::ParamCapture *paramCapture);
void CaptureGetTexGenfv_params(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               GLfloat *params,
                               angle::ParamCapture *paramCapture);
void CaptureGetTexGeniv_params(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               GLint *params,
                               angle::ParamCapture *paramCapture);
void CaptureGetTexImage_pixels(const State &glState,
                               bool isCallValid,
                               TextureTarget targetPacked,
                               GLint level,
                               GLenum format,
                               GLenum type,
                               void *pixels,
                               angle::ParamCapture *paramCapture);
void CaptureIndexdv_c(const State &glState,
                      bool isCallValid,
                      const GLdouble *c,
                      angle::ParamCapture *paramCapture);
void CaptureIndexfv_c(const State &glState,
                      bool isCallValid,
                      const GLfloat *c,
                      angle::ParamCapture *paramCapture);
void CaptureIndexiv_c(const State &glState,
                      bool isCallValid,
                      const GLint *c,
                      angle::ParamCapture *paramCapture);
void CaptureIndexsv_c(const State &glState,
                      bool isCallValid,
                      const GLshort *c,
                      angle::ParamCapture *paramCapture);
void CaptureLightModeliv_params(const State &glState,
                                bool isCallValid,
                                GLenum pname,
                                const GLint *params,
                                angle::ParamCapture *paramCapture);
void CaptureLightiv_params(const State &glState,
                           bool isCallValid,
                           GLenum light,
                           GLenum pname,
                           const GLint *params,
                           angle::ParamCapture *paramCapture);
void CaptureLoadMatrixd_m(const State &glState,
                          bool isCallValid,
                          const GLdouble *m,
                          angle::ParamCapture *paramCapture);
void CaptureMap1d_points(const State &glState,
                         bool isCallValid,
                         GLenum target,
                         GLdouble u1,
                         GLdouble u2,
                         GLint stride,
                         GLint order,
                         const GLdouble *points,
                         angle::ParamCapture *paramCapture);
void CaptureMap1f_points(const State &glState,
                         bool isCallValid,
                         GLenum target,
                         GLfloat u1,
                         GLfloat u2,
                         GLint stride,
                         GLint order,
                         const GLfloat *points,
                         angle::ParamCapture *paramCapture);
void CaptureMap2d_points(const State &glState,
                         bool isCallValid,
                         GLenum target,
                         GLdouble u1,
                         GLdouble u2,
                         GLint ustride,
                         GLint uorder,
                         GLdouble v1,
                         GLdouble v2,
                         GLint vstride,
                         GLint vorder,
                         const GLdouble *points,
                         angle::ParamCapture *paramCapture);
void CaptureMap2f_points(const State &glState,
                         bool isCallValid,
                         GLenum target,
                         GLfloat u1,
                         GLfloat u2,
                         GLint ustride,
                         GLint uorder,
                         GLfloat v1,
                         GLfloat v2,
                         GLint vstride,
                         GLint vorder,
                         const GLfloat *points,
                         angle::ParamCapture *paramCapture);
void CaptureMaterialiv_params(const State &glState,
                              bool isCallValid,
                              GLenum face,
                              GLenum pname,
                              const GLint *params,
                              angle::ParamCapture *paramCapture);
void CaptureMultMatrixd_m(const State &glState,
                          bool isCallValid,
                          const GLdouble *m,
                          angle::ParamCapture *paramCapture);
void CaptureNormal3bv_v(const State &glState,
                        bool isCallValid,
                        const GLbyte *v,
                        angle::ParamCapture *paramCapture);
void CaptureNormal3dv_v(const State &glState,
                        bool isCallValid,
                        const GLdouble *v,
                        angle::ParamCapture *paramCapture);
void CaptureNormal3fv_v(const State &glState,
                        bool isCallValid,
                        const GLfloat *v,
                        angle::ParamCapture *paramCapture);
void CaptureNormal3iv_v(const State &glState,
                        bool isCallValid,
                        const GLint *v,
                        angle::ParamCapture *paramCapture);
void CaptureNormal3sv_v(const State &glState,
                        bool isCallValid,
                        const GLshort *v,
                        angle::ParamCapture *paramCapture);
void CapturePixelMapfv_values(const State &glState,
                              bool isCallValid,
                              GLenum map,
                              GLsizei mapsize,
                              const GLfloat *values,
                              angle::ParamCapture *paramCapture);
void CapturePixelMapuiv_values(const State &glState,
                               bool isCallValid,
                               GLenum map,
                               GLsizei mapsize,
                               const GLuint *values,
                               angle::ParamCapture *paramCapture);
void CapturePixelMapusv_values(const State &glState,
                               bool isCallValid,
                               GLenum map,
                               GLsizei mapsize,
                               const GLushort *values,
                               angle::ParamCapture *paramCapture);
void CapturePolygonStipple_mask(const State &glState,
                                bool isCallValid,
                                const GLubyte *mask,
                                angle::ParamCapture *paramCapture);
void CaptureRasterPos2dv_v(const State &glState,
                           bool isCallValid,
                           const GLdouble *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos2fv_v(const State &glState,
                           bool isCallValid,
                           const GLfloat *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos2iv_v(const State &glState,
                           bool isCallValid,
                           const GLint *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos2sv_v(const State &glState,
                           bool isCallValid,
                           const GLshort *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos3dv_v(const State &glState,
                           bool isCallValid,
                           const GLdouble *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos3fv_v(const State &glState,
                           bool isCallValid,
                           const GLfloat *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos3iv_v(const State &glState,
                           bool isCallValid,
                           const GLint *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos3sv_v(const State &glState,
                           bool isCallValid,
                           const GLshort *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos4dv_v(const State &glState,
                           bool isCallValid,
                           const GLdouble *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos4fv_v(const State &glState,
                           bool isCallValid,
                           const GLfloat *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos4iv_v(const State &glState,
                           bool isCallValid,
                           const GLint *v,
                           angle::ParamCapture *paramCapture);
void CaptureRasterPos4sv_v(const State &glState,
                           bool isCallValid,
                           const GLshort *v,
                           angle::ParamCapture *paramCapture);
void CaptureRectdv_v1(const State &glState,
                      bool isCallValid,
                      const GLdouble *v1,
                      const GLdouble *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectdv_v2(const State &glState,
                      bool isCallValid,
                      const GLdouble *v1,
                      const GLdouble *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectfv_v1(const State &glState,
                      bool isCallValid,
                      const GLfloat *v1,
                      const GLfloat *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectfv_v2(const State &glState,
                      bool isCallValid,
                      const GLfloat *v1,
                      const GLfloat *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectiv_v1(const State &glState,
                      bool isCallValid,
                      const GLint *v1,
                      const GLint *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectiv_v2(const State &glState,
                      bool isCallValid,
                      const GLint *v1,
                      const GLint *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectsv_v1(const State &glState,
                      bool isCallValid,
                      const GLshort *v1,
                      const GLshort *v2,
                      angle::ParamCapture *paramCapture);
void CaptureRectsv_v2(const State &glState,
                      bool isCallValid,
                      const GLshort *v1,
                      const GLshort *v2,
                      angle::ParamCapture *paramCapture);
void CaptureSelectBuffer_buffer(const State &glState,
                                bool isCallValid,
                                GLsizei size,
                                GLuint *buffer,
                                angle::ParamCapture *paramCapture);
void CaptureTexCoord1dv_v(const State &glState,
                          bool isCallValid,
                          const GLdouble *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord1fv_v(const State &glState,
                          bool isCallValid,
                          const GLfloat *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord1iv_v(const State &glState,
                          bool isCallValid,
                          const GLint *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord1sv_v(const State &glState,
                          bool isCallValid,
                          const GLshort *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord2dv_v(const State &glState,
                          bool isCallValid,
                          const GLdouble *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord2fv_v(const State &glState,
                          bool isCallValid,
                          const GLfloat *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord2iv_v(const State &glState,
                          bool isCallValid,
                          const GLint *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord2sv_v(const State &glState,
                          bool isCallValid,
                          const GLshort *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord3dv_v(const State &glState,
                          bool isCallValid,
                          const GLdouble *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord3fv_v(const State &glState,
                          bool isCallValid,
                          const GLfloat *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord3iv_v(const State &glState,
                          bool isCallValid,
                          const GLint *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord3sv_v(const State &glState,
                          bool isCallValid,
                          const GLshort *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord4dv_v(const State &glState,
                          bool isCallValid,
                          const GLdouble *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord4fv_v(const State &glState,
                          bool isCallValid,
                          const GLfloat *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord4iv_v(const State &glState,
                          bool isCallValid,
                          const GLint *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexCoord4sv_v(const State &glState,
                          bool isCallValid,
                          const GLshort *v,
                          angle::ParamCapture *paramCapture);
void CaptureTexGendv_params(const State &glState,
                            bool isCallValid,
                            GLenum coord,
                            GLenum pname,
                            const GLdouble *params,
                            angle::ParamCapture *paramCapture);
void CaptureTexGenfv_params(const State &glState,
                            bool isCallValid,
                            GLenum coord,
                            GLenum pname,
                            const GLfloat *params,
                            angle::ParamCapture *paramCapture);
void CaptureTexGeniv_params(const State &glState,
                            bool isCallValid,
                            GLenum coord,
                            GLenum pname,
                            const GLint *params,
                            angle::ParamCapture *paramCapture);
void CaptureTexImage1D_pixels(const State &glState,
                              bool isCallValid,
                              GLenum target,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels,
                              angle::ParamCapture *paramCapture);
void CaptureVertex2dv_v(const State &glState,
                        bool isCallValid,
                        const GLdouble *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex2fv_v(const State &glState,
                        bool isCallValid,
                        const GLfloat *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex2iv_v(const State &glState,
                        bool isCallValid,
                        const GLint *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex2sv_v(const State &glState,
                        bool isCallValid,
                        const GLshort *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex3dv_v(const State &glState,
                        bool isCallValid,
                        const GLdouble *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex3fv_v(const State &glState,
                        bool isCallValid,
                        const GLfloat *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex3iv_v(const State &glState,
                        bool isCallValid,
                        const GLint *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex3sv_v(const State &glState,
                        bool isCallValid,
                        const GLshort *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex4dv_v(const State &glState,
                        bool isCallValid,
                        const GLdouble *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex4fv_v(const State &glState,
                        bool isCallValid,
                        const GLfloat *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex4iv_v(const State &glState,
                        bool isCallValid,
                        const GLint *v,
                        angle::ParamCapture *paramCapture);
void CaptureVertex4sv_v(const State &glState,
                        bool isCallValid,
                        const GLshort *v,
                        angle::ParamCapture *paramCapture);

// GL 1.1
void CaptureAreTexturesResident_textures(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         const GLuint *textures,
                                         GLboolean *residences,
                                         angle::ParamCapture *paramCapture);
void CaptureAreTexturesResident_residences(const State &glState,
                                           bool isCallValid,
                                           GLsizei n,
                                           const GLuint *textures,
                                           GLboolean *residences,
                                           angle::ParamCapture *paramCapture);
void CaptureEdgeFlagPointer_pointer(const State &glState,
                                    bool isCallValid,
                                    GLsizei stride,
                                    const void *pointer,
                                    angle::ParamCapture *paramCapture);
void CaptureIndexPointer_pointer(const State &glState,
                                 bool isCallValid,
                                 GLenum type,
                                 GLsizei stride,
                                 const void *pointer,
                                 angle::ParamCapture *paramCapture);
void CaptureIndexubv_c(const State &glState,
                       bool isCallValid,
                       const GLubyte *c,
                       angle::ParamCapture *paramCapture);
void CaptureInterleavedArrays_pointer(const State &glState,
                                      bool isCallValid,
                                      GLenum format,
                                      GLsizei stride,
                                      const void *pointer,
                                      angle::ParamCapture *paramCapture);
void CapturePrioritizeTextures_textures(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        const GLuint *textures,
                                        const GLfloat *priorities,
                                        angle::ParamCapture *paramCapture);
void CapturePrioritizeTextures_priorities(const State &glState,
                                          bool isCallValid,
                                          GLsizei n,
                                          const GLuint *textures,
                                          const GLfloat *priorities,
                                          angle::ParamCapture *paramCapture);
void CaptureTexSubImage1D_pixels(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLsizei width,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels,
                                 angle::ParamCapture *paramCapture);

// GL 1.2

// GL 1.3
void CaptureCompressedTexImage1D_data(const State &glState,
                                      bool isCallValid,
                                      GLenum target,
                                      GLint level,
                                      GLenum internalformat,
                                      GLsizei width,
                                      GLint border,
                                      GLsizei imageSize,
                                      const void *data,
                                      angle::ParamCapture *paramCapture);
void CaptureCompressedTexSubImage1D_data(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLint level,
                                         GLint xoffset,
                                         GLsizei width,
                                         GLenum format,
                                         GLsizei imageSize,
                                         const void *data,
                                         angle::ParamCapture *paramCapture);
void CaptureGetCompressedTexImage_img(const State &glState,
                                      bool isCallValid,
                                      TextureTarget targetPacked,
                                      GLint level,
                                      void *img,
                                      angle::ParamCapture *paramCapture);
void CaptureLoadTransposeMatrixd_m(const State &glState,
                                   bool isCallValid,
                                   const GLdouble *m,
                                   angle::ParamCapture *paramCapture);
void CaptureLoadTransposeMatrixf_m(const State &glState,
                                   bool isCallValid,
                                   const GLfloat *m,
                                   angle::ParamCapture *paramCapture);
void CaptureMultTransposeMatrixd_m(const State &glState,
                                   bool isCallValid,
                                   const GLdouble *m,
                                   angle::ParamCapture *paramCapture);
void CaptureMultTransposeMatrixf_m(const State &glState,
                                   bool isCallValid,
                                   const GLfloat *m,
                                   angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord1dv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord1fv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLfloat *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord1iv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLint *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord1sv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLshort *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord2dv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord2fv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLfloat *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord2iv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLint *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord2sv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLshort *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord3dv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord3fv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLfloat *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord3iv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLint *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord3sv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLshort *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord4dv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLdouble *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord4fv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLfloat *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord4iv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLint *v,
                               angle::ParamCapture *paramCapture);
void CaptureMultiTexCoord4sv_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               const GLshort *v,
                               angle::ParamCapture *paramCapture);

// GL 1.4
void CaptureFogCoordPointer_pointer(const State &glState,
                                    bool isCallValid,
                                    GLenum type,
                                    GLsizei stride,
                                    const void *pointer,
                                    angle::ParamCapture *paramCapture);
void CaptureFogCoorddv_coord(const State &glState,
                             bool isCallValid,
                             const GLdouble *coord,
                             angle::ParamCapture *paramCapture);
void CaptureFogCoordfv_coord(const State &glState,
                             bool isCallValid,
                             const GLfloat *coord,
                             angle::ParamCapture *paramCapture);
void CaptureMultiDrawArrays_first(const State &glState,
                                  bool isCallValid,
                                  PrimitiveMode modePacked,
                                  const GLint *first,
                                  const GLsizei *count,
                                  GLsizei drawcount,
                                  angle::ParamCapture *paramCapture);
void CaptureMultiDrawArrays_count(const State &glState,
                                  bool isCallValid,
                                  PrimitiveMode modePacked,
                                  const GLint *first,
                                  const GLsizei *count,
                                  GLsizei drawcount,
                                  angle::ParamCapture *paramCapture);
void CaptureMultiDrawElements_count(const State &glState,
                                    bool isCallValid,
                                    PrimitiveMode modePacked,
                                    const GLsizei *count,
                                    DrawElementsType typePacked,
                                    const void *const *indices,
                                    GLsizei drawcount,
                                    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElements_indices(const State &glState,
                                      bool isCallValid,
                                      PrimitiveMode modePacked,
                                      const GLsizei *count,
                                      DrawElementsType typePacked,
                                      const void *const *indices,
                                      GLsizei drawcount,
                                      angle::ParamCapture *paramCapture);
void CapturePointParameteriv_params(const State &glState,
                                    bool isCallValid,
                                    GLenum pname,
                                    const GLint *params,
                                    angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3bv_v(const State &glState,
                                bool isCallValid,
                                const GLbyte *v,
                                angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3dv_v(const State &glState,
                                bool isCallValid,
                                const GLdouble *v,
                                angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3fv_v(const State &glState,
                                bool isCallValid,
                                const GLfloat *v,
                                angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3iv_v(const State &glState,
                                bool isCallValid,
                                const GLint *v,
                                angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3sv_v(const State &glState,
                                bool isCallValid,
                                const GLshort *v,
                                angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3ubv_v(const State &glState,
                                 bool isCallValid,
                                 const GLubyte *v,
                                 angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3uiv_v(const State &glState,
                                 bool isCallValid,
                                 const GLuint *v,
                                 angle::ParamCapture *paramCapture);
void CaptureSecondaryColor3usv_v(const State &glState,
                                 bool isCallValid,
                                 const GLushort *v,
                                 angle::ParamCapture *paramCapture);
void CaptureSecondaryColorPointer_pointer(const State &glState,
                                          bool isCallValid,
                                          GLint size,
                                          GLenum type,
                                          GLsizei stride,
                                          const void *pointer,
                                          angle::ParamCapture *paramCapture);
void CaptureWindowPos2dv_v(const State &glState,
                           bool isCallValid,
                           const GLdouble *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos2fv_v(const State &glState,
                           bool isCallValid,
                           const GLfloat *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos2iv_v(const State &glState,
                           bool isCallValid,
                           const GLint *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos2sv_v(const State &glState,
                           bool isCallValid,
                           const GLshort *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos3dv_v(const State &glState,
                           bool isCallValid,
                           const GLdouble *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos3fv_v(const State &glState,
                           bool isCallValid,
                           const GLfloat *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos3iv_v(const State &glState,
                           bool isCallValid,
                           const GLint *v,
                           angle::ParamCapture *paramCapture);
void CaptureWindowPos3sv_v(const State &glState,
                           bool isCallValid,
                           const GLshort *v,
                           angle::ParamCapture *paramCapture);

// GL 1.5
void CaptureGetBufferSubData_data(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLintptr offset,
                                  GLsizeiptr size,
                                  void *data,
                                  angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectiv_params(const State &glState,
                                    bool isCallValid,
                                    QueryID idPacked,
                                    GLenum pname,
                                    GLint *params,
                                    angle::ParamCapture *paramCapture);
}  // namespace gl

#endif  // LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
