kc3-lang/angle/src/libANGLE/capture/capture_gl_1_autogen.h

• Show log

  Commit

• Hash : 98d5db70
  Author :
  Date : 2022-08-25T16:50:38
  

  Add capture functions for desktop GL entry points
  
  The parameter capture functions are left unimplemented for now.
  
  Bug: angleproject:7533
  Change-Id: Ief356e7401805cf9b417e1f5cc3790011237e03f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3858618
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Eddie Hatfield <eddiehatfield@google.com>
  

Download

• src/libANGLE/capture/capture_gl_1_autogen.h

• // 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_
  

Download