tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

capture_gl_1_autogen.h (113809B)


      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
      3 //
      4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
      5 // Use of this source code is governed by a BSD-style license that can be
      6 // found in the LICENSE file.
      7 //
      8 // capture_gl_1_autogen.h:
      9 //   Capture functions for the OpenGL ES Desktop GL 1.x entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
     13 
     14 #include "common/PackedEnums.h"
     15 #include "libANGLE/capture/FrameCapture.h"
     16 
     17 namespace gl
     18 {
     19 
     20 // Method Captures
     21 
     22 // GL 1.0
     23 angle::CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value);
     24 angle::CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode);
     25 angle::CallCapture CaptureBitmap(const State &glState,
     26                                 bool isCallValid,
     27                                 GLsizei width,
     28                                 GLsizei height,
     29                                 GLfloat xorig,
     30                                 GLfloat yorig,
     31                                 GLfloat xmove,
     32                                 GLfloat ymove,
     33                                 const GLubyte *bitmap);
     34 angle::CallCapture CaptureCallList(const State &glState, bool isCallValid, GLuint list);
     35 angle::CallCapture CaptureCallLists(const State &glState,
     36                                    bool isCallValid,
     37                                    GLsizei n,
     38                                    GLenum type,
     39                                    const void *lists);
     40 angle::CallCapture CaptureClearAccum(const State &glState,
     41                                     bool isCallValid,
     42                                     GLfloat red,
     43                                     GLfloat green,
     44                                     GLfloat blue,
     45                                     GLfloat alpha);
     46 angle::CallCapture CaptureClearDepth(const State &glState, bool isCallValid, GLdouble depth);
     47 angle::CallCapture CaptureClearIndex(const State &glState, bool isCallValid, GLfloat c);
     48 angle::CallCapture CaptureClipPlane(const State &glState,
     49                                    bool isCallValid,
     50                                    GLenum plane,
     51                                    const GLdouble *equation);
     52 angle::CallCapture CaptureColor3b(const State &glState,
     53                                  bool isCallValid,
     54                                  GLbyte red,
     55                                  GLbyte green,
     56                                  GLbyte blue);
     57 angle::CallCapture CaptureColor3bv(const State &glState, bool isCallValid, const GLbyte *v);
     58 angle::CallCapture CaptureColor3d(const State &glState,
     59                                  bool isCallValid,
     60                                  GLdouble red,
     61                                  GLdouble green,
     62                                  GLdouble blue);
     63 angle::CallCapture CaptureColor3dv(const State &glState, bool isCallValid, const GLdouble *v);
     64 angle::CallCapture CaptureColor3f(const State &glState,
     65                                  bool isCallValid,
     66                                  GLfloat red,
     67                                  GLfloat green,
     68                                  GLfloat blue);
     69 angle::CallCapture CaptureColor3fv(const State &glState, bool isCallValid, const GLfloat *v);
     70 angle::CallCapture CaptureColor3i(const State &glState,
     71                                  bool isCallValid,
     72                                  GLint red,
     73                                  GLint green,
     74                                  GLint blue);
     75 angle::CallCapture CaptureColor3iv(const State &glState, bool isCallValid, const GLint *v);
     76 angle::CallCapture CaptureColor3s(const State &glState,
     77                                  bool isCallValid,
     78                                  GLshort red,
     79                                  GLshort green,
     80                                  GLshort blue);
     81 angle::CallCapture CaptureColor3sv(const State &glState, bool isCallValid, const GLshort *v);
     82 angle::CallCapture CaptureColor3ub(const State &glState,
     83                                   bool isCallValid,
     84                                   GLubyte red,
     85                                   GLubyte green,
     86                                   GLubyte blue);
     87 angle::CallCapture CaptureColor3ubv(const State &glState, bool isCallValid, const GLubyte *v);
     88 angle::CallCapture CaptureColor3ui(const State &glState,
     89                                   bool isCallValid,
     90                                   GLuint red,
     91                                   GLuint green,
     92                                   GLuint blue);
     93 angle::CallCapture CaptureColor3uiv(const State &glState, bool isCallValid, const GLuint *v);
     94 angle::CallCapture CaptureColor3us(const State &glState,
     95                                   bool isCallValid,
     96                                   GLushort red,
     97                                   GLushort green,
     98                                   GLushort blue);
     99 angle::CallCapture CaptureColor3usv(const State &glState, bool isCallValid, const GLushort *v);
    100 angle::CallCapture CaptureColor4b(const State &glState,
    101                                  bool isCallValid,
    102                                  GLbyte red,
    103                                  GLbyte green,
    104                                  GLbyte blue,
    105                                  GLbyte alpha);
    106 angle::CallCapture CaptureColor4bv(const State &glState, bool isCallValid, const GLbyte *v);
    107 angle::CallCapture CaptureColor4d(const State &glState,
    108                                  bool isCallValid,
    109                                  GLdouble red,
    110                                  GLdouble green,
    111                                  GLdouble blue,
    112                                  GLdouble alpha);
    113 angle::CallCapture CaptureColor4dv(const State &glState, bool isCallValid, const GLdouble *v);
    114 angle::CallCapture CaptureColor4fv(const State &glState, bool isCallValid, const GLfloat *v);
    115 angle::CallCapture CaptureColor4i(const State &glState,
    116                                  bool isCallValid,
    117                                  GLint red,
    118                                  GLint green,
    119                                  GLint blue,
    120                                  GLint alpha);
    121 angle::CallCapture CaptureColor4iv(const State &glState, bool isCallValid, const GLint *v);
    122 angle::CallCapture CaptureColor4s(const State &glState,
    123                                  bool isCallValid,
    124                                  GLshort red,
    125                                  GLshort green,
    126                                  GLshort blue,
    127                                  GLshort alpha);
    128 angle::CallCapture CaptureColor4sv(const State &glState, bool isCallValid, const GLshort *v);
    129 angle::CallCapture CaptureColor4ubv(const State &glState, bool isCallValid, const GLubyte *v);
    130 angle::CallCapture CaptureColor4ui(const State &glState,
    131                                   bool isCallValid,
    132                                   GLuint red,
    133                                   GLuint green,
    134                                   GLuint blue,
    135                                   GLuint alpha);
    136 angle::CallCapture CaptureColor4uiv(const State &glState, bool isCallValid, const GLuint *v);
    137 angle::CallCapture CaptureColor4us(const State &glState,
    138                                   bool isCallValid,
    139                                   GLushort red,
    140                                   GLushort green,
    141                                   GLushort blue,
    142                                   GLushort alpha);
    143 angle::CallCapture CaptureColor4usv(const State &glState, bool isCallValid, const GLushort *v);
    144 angle::CallCapture CaptureColorMaterial(const State &glState,
    145                                        bool isCallValid,
    146                                        GLenum face,
    147                                        GLenum mode);
    148 angle::CallCapture CaptureCopyPixels(const State &glState,
    149                                     bool isCallValid,
    150                                     GLint x,
    151                                     GLint y,
    152                                     GLsizei width,
    153                                     GLsizei height,
    154                                     GLenum type);
    155 angle::CallCapture CaptureDeleteLists(const State &glState,
    156                                      bool isCallValid,
    157                                      GLuint list,
    158                                      GLsizei range);
    159 angle::CallCapture CaptureDepthRange(const State &glState,
    160                                     bool isCallValid,
    161                                     GLdouble n,
    162                                     GLdouble f);
    163 angle::CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf);
    164 angle::CallCapture CaptureDrawPixels(const State &glState,
    165                                     bool isCallValid,
    166                                     GLsizei width,
    167                                     GLsizei height,
    168                                     GLenum format,
    169                                     GLenum type,
    170                                     const void *pixels);
    171 angle::CallCapture CaptureEdgeFlag(const State &glState, bool isCallValid, GLboolean flag);
    172 angle::CallCapture CaptureEdgeFlagv(const State &glState, bool isCallValid, const GLboolean *flag);
    173 angle::CallCapture CaptureEnd(const State &glState, bool isCallValid);
    174 angle::CallCapture CaptureEndList(const State &glState, bool isCallValid);
    175 angle::CallCapture CaptureEvalCoord1d(const State &glState, bool isCallValid, GLdouble u);
    176 angle::CallCapture CaptureEvalCoord1dv(const State &glState, bool isCallValid, const GLdouble *u);
    177 angle::CallCapture CaptureEvalCoord1f(const State &glState, bool isCallValid, GLfloat u);
    178 angle::CallCapture CaptureEvalCoord1fv(const State &glState, bool isCallValid, const GLfloat *u);
    179 angle::CallCapture CaptureEvalCoord2d(const State &glState,
    180                                      bool isCallValid,
    181                                      GLdouble u,
    182                                      GLdouble v);
    183 angle::CallCapture CaptureEvalCoord2dv(const State &glState, bool isCallValid, const GLdouble *u);
    184 angle::CallCapture CaptureEvalCoord2f(const State &glState, bool isCallValid, GLfloat u, GLfloat v);
    185 angle::CallCapture CaptureEvalCoord2fv(const State &glState, bool isCallValid, const GLfloat *u);
    186 angle::CallCapture CaptureEvalMesh1(const State &glState,
    187                                    bool isCallValid,
    188                                    GLenum mode,
    189                                    GLint i1,
    190                                    GLint i2);
    191 angle::CallCapture CaptureEvalMesh2(const State &glState,
    192                                    bool isCallValid,
    193                                    GLenum mode,
    194                                    GLint i1,
    195                                    GLint i2,
    196                                    GLint j1,
    197                                    GLint j2);
    198 angle::CallCapture CaptureEvalPoint1(const State &glState, bool isCallValid, GLint i);
    199 angle::CallCapture CaptureEvalPoint2(const State &glState, bool isCallValid, GLint i, GLint j);
    200 angle::CallCapture CaptureFeedbackBuffer(const State &glState,
    201                                         bool isCallValid,
    202                                         GLsizei size,
    203                                         GLenum type,
    204                                         GLfloat *buffer);
    205 angle::CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GLint param);
    206 angle::CallCapture CaptureFogiv(const State &glState,
    207                                bool isCallValid,
    208                                GLenum pname,
    209                                const GLint *params);
    210 angle::CallCapture CaptureFrustum(const State &glState,
    211                                  bool isCallValid,
    212                                  GLdouble left,
    213                                  GLdouble right,
    214                                  GLdouble bottom,
    215                                  GLdouble top,
    216                                  GLdouble zNear,
    217                                  GLdouble zFar);
    218 angle::CallCapture CaptureGenLists(const State &glState,
    219                                   bool isCallValid,
    220                                   GLsizei range,
    221                                   GLuint returnValue);
    222 angle::CallCapture CaptureGetClipPlane(const State &glState,
    223                                       bool isCallValid,
    224                                       GLenum plane,
    225                                       GLdouble *equation);
    226 angle::CallCapture CaptureGetDoublev(const State &glState,
    227                                     bool isCallValid,
    228                                     GLenum pname,
    229                                     GLdouble *data);
    230 angle::CallCapture CaptureGetLightiv(const State &glState,
    231                                     bool isCallValid,
    232                                     GLenum light,
    233                                     GLenum pname,
    234                                     GLint *params);
    235 angle::CallCapture CaptureGetMapdv(const State &glState,
    236                                   bool isCallValid,
    237                                   GLenum target,
    238                                   GLenum query,
    239                                   GLdouble *v);
    240 angle::CallCapture CaptureGetMapfv(const State &glState,
    241                                   bool isCallValid,
    242                                   GLenum target,
    243                                   GLenum query,
    244                                   GLfloat *v);
    245 angle::CallCapture CaptureGetMapiv(const State &glState,
    246                                   bool isCallValid,
    247                                   GLenum target,
    248                                   GLenum query,
    249                                   GLint *v);
    250 angle::CallCapture CaptureGetMaterialiv(const State &glState,
    251                                        bool isCallValid,
    252                                        GLenum face,
    253                                        GLenum pname,
    254                                        GLint *params);
    255 angle::CallCapture CaptureGetPixelMapfv(const State &glState,
    256                                        bool isCallValid,
    257                                        GLenum map,
    258                                        GLfloat *values);
    259 angle::CallCapture CaptureGetPixelMapuiv(const State &glState,
    260                                         bool isCallValid,
    261                                         GLenum map,
    262                                         GLuint *values);
    263 angle::CallCapture CaptureGetPixelMapusv(const State &glState,
    264                                         bool isCallValid,
    265                                         GLenum map,
    266                                         GLushort *values);
    267 angle::CallCapture CaptureGetPolygonStipple(const State &glState, bool isCallValid, GLubyte *mask);
    268 angle::CallCapture CaptureGetTexGendv(const State &glState,
    269                                      bool isCallValid,
    270                                      GLenum coord,
    271                                      GLenum pname,
    272                                      GLdouble *params);
    273 angle::CallCapture CaptureGetTexGenfv(const State &glState,
    274                                      bool isCallValid,
    275                                      GLenum coord,
    276                                      GLenum pname,
    277                                      GLfloat *params);
    278 angle::CallCapture CaptureGetTexGeniv(const State &glState,
    279                                      bool isCallValid,
    280                                      GLenum coord,
    281                                      GLenum pname,
    282                                      GLint *params);
    283 angle::CallCapture CaptureGetTexImage(const State &glState,
    284                                      bool isCallValid,
    285                                      TextureTarget targetPacked,
    286                                      GLint level,
    287                                      GLenum format,
    288                                      GLenum type,
    289                                      void *pixels);
    290 angle::CallCapture CaptureIndexMask(const State &glState, bool isCallValid, GLuint mask);
    291 angle::CallCapture CaptureIndexd(const State &glState, bool isCallValid, GLdouble c);
    292 angle::CallCapture CaptureIndexdv(const State &glState, bool isCallValid, const GLdouble *c);
    293 angle::CallCapture CaptureIndexf(const State &glState, bool isCallValid, GLfloat c);
    294 angle::CallCapture CaptureIndexfv(const State &glState, bool isCallValid, const GLfloat *c);
    295 angle::CallCapture CaptureIndexi(const State &glState, bool isCallValid, GLint c);
    296 angle::CallCapture CaptureIndexiv(const State &glState, bool isCallValid, const GLint *c);
    297 angle::CallCapture CaptureIndexs(const State &glState, bool isCallValid, GLshort c);
    298 angle::CallCapture CaptureIndexsv(const State &glState, bool isCallValid, const GLshort *c);
    299 angle::CallCapture CaptureInitNames(const State &glState, bool isCallValid);
    300 angle::CallCapture CaptureIsList(const State &glState,
    301                                 bool isCallValid,
    302                                 GLuint list,
    303                                 GLboolean returnValue);
    304 angle::CallCapture CaptureLightModeli(const State &glState,
    305                                      bool isCallValid,
    306                                      GLenum pname,
    307                                      GLint param);
    308 angle::CallCapture CaptureLightModeliv(const State &glState,
    309                                       bool isCallValid,
    310                                       GLenum pname,
    311                                       const GLint *params);
    312 angle::CallCapture CaptureLighti(const State &glState,
    313                                 bool isCallValid,
    314                                 GLenum light,
    315                                 GLenum pname,
    316                                 GLint param);
    317 angle::CallCapture CaptureLightiv(const State &glState,
    318                                  bool isCallValid,
    319                                  GLenum light,
    320                                  GLenum pname,
    321                                  const GLint *params);
    322 angle::CallCapture CaptureLineStipple(const State &glState,
    323                                      bool isCallValid,
    324                                      GLint factor,
    325                                      GLushort pattern);
    326 angle::CallCapture CaptureListBase(const State &glState, bool isCallValid, GLuint base);
    327 angle::CallCapture CaptureLoadMatrixd(const State &glState, bool isCallValid, const GLdouble *m);
    328 angle::CallCapture CaptureLoadName(const State &glState, bool isCallValid, GLuint name);
    329 angle::CallCapture CaptureMap1d(const State &glState,
    330                                bool isCallValid,
    331                                GLenum target,
    332                                GLdouble u1,
    333                                GLdouble u2,
    334                                GLint stride,
    335                                GLint order,
    336                                const GLdouble *points);
    337 angle::CallCapture CaptureMap1f(const State &glState,
    338                                bool isCallValid,
    339                                GLenum target,
    340                                GLfloat u1,
    341                                GLfloat u2,
    342                                GLint stride,
    343                                GLint order,
    344                                const GLfloat *points);
    345 angle::CallCapture CaptureMap2d(const State &glState,
    346                                bool isCallValid,
    347                                GLenum target,
    348                                GLdouble u1,
    349                                GLdouble u2,
    350                                GLint ustride,
    351                                GLint uorder,
    352                                GLdouble v1,
    353                                GLdouble v2,
    354                                GLint vstride,
    355                                GLint vorder,
    356                                const GLdouble *points);
    357 angle::CallCapture CaptureMap2f(const State &glState,
    358                                bool isCallValid,
    359                                GLenum target,
    360                                GLfloat u1,
    361                                GLfloat u2,
    362                                GLint ustride,
    363                                GLint uorder,
    364                                GLfloat v1,
    365                                GLfloat v2,
    366                                GLint vstride,
    367                                GLint vorder,
    368                                const GLfloat *points);
    369 angle::CallCapture CaptureMapGrid1d(const State &glState,
    370                                    bool isCallValid,
    371                                    GLint un,
    372                                    GLdouble u1,
    373                                    GLdouble u2);
    374 angle::CallCapture CaptureMapGrid1f(const State &glState,
    375                                    bool isCallValid,
    376                                    GLint un,
    377                                    GLfloat u1,
    378                                    GLfloat u2);
    379 angle::CallCapture CaptureMapGrid2d(const State &glState,
    380                                    bool isCallValid,
    381                                    GLint un,
    382                                    GLdouble u1,
    383                                    GLdouble u2,
    384                                    GLint vn,
    385                                    GLdouble v1,
    386                                    GLdouble v2);
    387 angle::CallCapture CaptureMapGrid2f(const State &glState,
    388                                    bool isCallValid,
    389                                    GLint un,
    390                                    GLfloat u1,
    391                                    GLfloat u2,
    392                                    GLint vn,
    393                                    GLfloat v1,
    394                                    GLfloat v2);
    395 angle::CallCapture CaptureMateriali(const State &glState,
    396                                    bool isCallValid,
    397                                    GLenum face,
    398                                    GLenum pname,
    399                                    GLint param);
    400 angle::CallCapture CaptureMaterialiv(const State &glState,
    401                                     bool isCallValid,
    402                                     GLenum face,
    403                                     GLenum pname,
    404                                     const GLint *params);
    405 angle::CallCapture CaptureMultMatrixd(const State &glState, bool isCallValid, const GLdouble *m);
    406 angle::CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, GLenum mode);
    407 angle::CallCapture CaptureNormal3b(const State &glState,
    408                                   bool isCallValid,
    409                                   GLbyte nx,
    410                                   GLbyte ny,
    411                                   GLbyte nz);
    412 angle::CallCapture CaptureNormal3bv(const State &glState, bool isCallValid, const GLbyte *v);
    413 angle::CallCapture CaptureNormal3d(const State &glState,
    414                                   bool isCallValid,
    415                                   GLdouble nx,
    416                                   GLdouble ny,
    417                                   GLdouble nz);
    418 angle::CallCapture CaptureNormal3dv(const State &glState, bool isCallValid, const GLdouble *v);
    419 angle::CallCapture CaptureNormal3fv(const State &glState, bool isCallValid, const GLfloat *v);
    420 angle::CallCapture CaptureNormal3i(const State &glState,
    421                                   bool isCallValid,
    422                                   GLint nx,
    423                                   GLint ny,
    424                                   GLint nz);
    425 angle::CallCapture CaptureNormal3iv(const State &glState, bool isCallValid, const GLint *v);
    426 angle::CallCapture CaptureNormal3s(const State &glState,
    427                                   bool isCallValid,
    428                                   GLshort nx,
    429                                   GLshort ny,
    430                                   GLshort nz);
    431 angle::CallCapture CaptureNormal3sv(const State &glState, bool isCallValid, const GLshort *v);
    432 angle::CallCapture CaptureOrtho(const State &glState,
    433                                bool isCallValid,
    434                                GLdouble left,
    435                                GLdouble right,
    436                                GLdouble bottom,
    437                                GLdouble top,
    438                                GLdouble zNear,
    439                                GLdouble zFar);
    440 angle::CallCapture CapturePassThrough(const State &glState, bool isCallValid, GLfloat token);
    441 angle::CallCapture CapturePixelMapfv(const State &glState,
    442                                     bool isCallValid,
    443                                     GLenum map,
    444                                     GLsizei mapsize,
    445                                     const GLfloat *values);
    446 angle::CallCapture CapturePixelMapuiv(const State &glState,
    447                                      bool isCallValid,
    448                                      GLenum map,
    449                                      GLsizei mapsize,
    450                                      const GLuint *values);
    451 angle::CallCapture CapturePixelMapusv(const State &glState,
    452                                      bool isCallValid,
    453                                      GLenum map,
    454                                      GLsizei mapsize,
    455                                      const GLushort *values);
    456 angle::CallCapture CapturePixelStoref(const State &glState,
    457                                      bool isCallValid,
    458                                      GLenum pname,
    459                                      GLfloat param);
    460 angle::CallCapture CapturePixelTransferf(const State &glState,
    461                                         bool isCallValid,
    462                                         GLenum pname,
    463                                         GLfloat param);
    464 angle::CallCapture CapturePixelTransferi(const State &glState,
    465                                         bool isCallValid,
    466                                         GLenum pname,
    467                                         GLint param);
    468 angle::CallCapture CapturePixelZoom(const State &glState,
    469                                    bool isCallValid,
    470                                    GLfloat xfactor,
    471                                    GLfloat yfactor);
    472 angle::CallCapture CapturePolygonMode(const State &glState,
    473                                      bool isCallValid,
    474                                      GLenum face,
    475                                      GLenum mode);
    476 angle::CallCapture CapturePolygonStipple(const State &glState,
    477                                         bool isCallValid,
    478                                         const GLubyte *mask);
    479 angle::CallCapture CapturePopAttrib(const State &glState, bool isCallValid);
    480 angle::CallCapture CapturePopName(const State &glState, bool isCallValid);
    481 angle::CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield mask);
    482 angle::CallCapture CapturePushName(const State &glState, bool isCallValid, GLuint name);
    483 angle::CallCapture CaptureRasterPos2d(const State &glState,
    484                                      bool isCallValid,
    485                                      GLdouble x,
    486                                      GLdouble y);
    487 angle::CallCapture CaptureRasterPos2dv(const State &glState, bool isCallValid, const GLdouble *v);
    488 angle::CallCapture CaptureRasterPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
    489 angle::CallCapture CaptureRasterPos2fv(const State &glState, bool isCallValid, const GLfloat *v);
    490 angle::CallCapture CaptureRasterPos2i(const State &glState, bool isCallValid, GLint x, GLint y);
    491 angle::CallCapture CaptureRasterPos2iv(const State &glState, bool isCallValid, const GLint *v);
    492 angle::CallCapture CaptureRasterPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
    493 angle::CallCapture CaptureRasterPos2sv(const State &glState, bool isCallValid, const GLshort *v);
    494 angle::CallCapture CaptureRasterPos3d(const State &glState,
    495                                      bool isCallValid,
    496                                      GLdouble x,
    497                                      GLdouble y,
    498                                      GLdouble z);
    499 angle::CallCapture CaptureRasterPos3dv(const State &glState, bool isCallValid, const GLdouble *v);
    500 angle::CallCapture CaptureRasterPos3f(const State &glState,
    501                                      bool isCallValid,
    502                                      GLfloat x,
    503                                      GLfloat y,
    504                                      GLfloat z);
    505 angle::CallCapture CaptureRasterPos3fv(const State &glState, bool isCallValid, const GLfloat *v);
    506 angle::CallCapture CaptureRasterPos3i(const State &glState,
    507                                      bool isCallValid,
    508                                      GLint x,
    509                                      GLint y,
    510                                      GLint z);
    511 angle::CallCapture CaptureRasterPos3iv(const State &glState, bool isCallValid, const GLint *v);
    512 angle::CallCapture CaptureRasterPos3s(const State &glState,
    513                                      bool isCallValid,
    514                                      GLshort x,
    515                                      GLshort y,
    516                                      GLshort z);
    517 angle::CallCapture CaptureRasterPos3sv(const State &glState, bool isCallValid, const GLshort *v);
    518 angle::CallCapture CaptureRasterPos4d(const State &glState,
    519                                      bool isCallValid,
    520                                      GLdouble x,
    521                                      GLdouble y,
    522                                      GLdouble z,
    523                                      GLdouble w);
    524 angle::CallCapture CaptureRasterPos4dv(const State &glState, bool isCallValid, const GLdouble *v);
    525 angle::CallCapture CaptureRasterPos4f(const State &glState,
    526                                      bool isCallValid,
    527                                      GLfloat x,
    528                                      GLfloat y,
    529                                      GLfloat z,
    530                                      GLfloat w);
    531 angle::CallCapture CaptureRasterPos4fv(const State &glState, bool isCallValid, const GLfloat *v);
    532 angle::CallCapture CaptureRasterPos4i(const State &glState,
    533                                      bool isCallValid,
    534                                      GLint x,
    535                                      GLint y,
    536                                      GLint z,
    537                                      GLint w);
    538 angle::CallCapture CaptureRasterPos4iv(const State &glState, bool isCallValid, const GLint *v);
    539 angle::CallCapture CaptureRasterPos4s(const State &glState,
    540                                      bool isCallValid,
    541                                      GLshort x,
    542                                      GLshort y,
    543                                      GLshort z,
    544                                      GLshort w);
    545 angle::CallCapture CaptureRasterPos4sv(const State &glState, bool isCallValid, const GLshort *v);
    546 angle::CallCapture CaptureRectd(const State &glState,
    547                                bool isCallValid,
    548                                GLdouble x1,
    549                                GLdouble y1,
    550                                GLdouble x2,
    551                                GLdouble y2);
    552 angle::CallCapture CaptureRectdv(const State &glState,
    553                                 bool isCallValid,
    554                                 const GLdouble *v1,
    555                                 const GLdouble *v2);
    556 angle::CallCapture CaptureRectf(const State &glState,
    557                                bool isCallValid,
    558                                GLfloat x1,
    559                                GLfloat y1,
    560                                GLfloat x2,
    561                                GLfloat y2);
    562 angle::CallCapture CaptureRectfv(const State &glState,
    563                                 bool isCallValid,
    564                                 const GLfloat *v1,
    565                                 const GLfloat *v2);
    566 angle::CallCapture CaptureRecti(const State &glState,
    567                                bool isCallValid,
    568                                GLint x1,
    569                                GLint y1,
    570                                GLint x2,
    571                                GLint y2);
    572 angle::CallCapture CaptureRectiv(const State &glState,
    573                                 bool isCallValid,
    574                                 const GLint *v1,
    575                                 const GLint *v2);
    576 angle::CallCapture CaptureRects(const State &glState,
    577                                bool isCallValid,
    578                                GLshort x1,
    579                                GLshort y1,
    580                                GLshort x2,
    581                                GLshort y2);
    582 angle::CallCapture CaptureRectsv(const State &glState,
    583                                 bool isCallValid,
    584                                 const GLshort *v1,
    585                                 const GLshort *v2);
    586 angle::CallCapture CaptureRenderMode(const State &glState,
    587                                     bool isCallValid,
    588                                     GLenum mode,
    589                                     GLint returnValue);
    590 angle::CallCapture CaptureRotated(const State &glState,
    591                                  bool isCallValid,
    592                                  GLdouble angle,
    593                                  GLdouble x,
    594                                  GLdouble y,
    595                                  GLdouble z);
    596 angle::CallCapture CaptureScaled(const State &glState,
    597                                 bool isCallValid,
    598                                 GLdouble x,
    599                                 GLdouble y,
    600                                 GLdouble z);
    601 angle::CallCapture CaptureSelectBuffer(const State &glState,
    602                                       bool isCallValid,
    603                                       GLsizei size,
    604                                       GLuint *buffer);
    605 angle::CallCapture CaptureTexCoord1d(const State &glState, bool isCallValid, GLdouble s);
    606 angle::CallCapture CaptureTexCoord1dv(const State &glState, bool isCallValid, const GLdouble *v);
    607 angle::CallCapture CaptureTexCoord1f(const State &glState, bool isCallValid, GLfloat s);
    608 angle::CallCapture CaptureTexCoord1fv(const State &glState, bool isCallValid, const GLfloat *v);
    609 angle::CallCapture CaptureTexCoord1i(const State &glState, bool isCallValid, GLint s);
    610 angle::CallCapture CaptureTexCoord1iv(const State &glState, bool isCallValid, const GLint *v);
    611 angle::CallCapture CaptureTexCoord1s(const State &glState, bool isCallValid, GLshort s);
    612 angle::CallCapture CaptureTexCoord1sv(const State &glState, bool isCallValid, const GLshort *v);
    613 angle::CallCapture CaptureTexCoord2d(const State &glState,
    614                                     bool isCallValid,
    615                                     GLdouble s,
    616                                     GLdouble t);
    617 angle::CallCapture CaptureTexCoord2dv(const State &glState, bool isCallValid, const GLdouble *v);
    618 angle::CallCapture CaptureTexCoord2f(const State &glState, bool isCallValid, GLfloat s, GLfloat t);
    619 angle::CallCapture CaptureTexCoord2fv(const State &glState, bool isCallValid, const GLfloat *v);
    620 angle::CallCapture CaptureTexCoord2i(const State &glState, bool isCallValid, GLint s, GLint t);
    621 angle::CallCapture CaptureTexCoord2iv(const State &glState, bool isCallValid, const GLint *v);
    622 angle::CallCapture CaptureTexCoord2s(const State &glState, bool isCallValid, GLshort s, GLshort t);
    623 angle::CallCapture CaptureTexCoord2sv(const State &glState, bool isCallValid, const GLshort *v);
    624 angle::CallCapture CaptureTexCoord3d(const State &glState,
    625                                     bool isCallValid,
    626                                     GLdouble s,
    627                                     GLdouble t,
    628                                     GLdouble r);
    629 angle::CallCapture CaptureTexCoord3dv(const State &glState, bool isCallValid, const GLdouble *v);
    630 angle::CallCapture CaptureTexCoord3f(const State &glState,
    631                                     bool isCallValid,
    632                                     GLfloat s,
    633                                     GLfloat t,
    634                                     GLfloat r);
    635 angle::CallCapture CaptureTexCoord3fv(const State &glState, bool isCallValid, const GLfloat *v);
    636 angle::CallCapture CaptureTexCoord3i(const State &glState,
    637                                     bool isCallValid,
    638                                     GLint s,
    639                                     GLint t,
    640                                     GLint r);
    641 angle::CallCapture CaptureTexCoord3iv(const State &glState, bool isCallValid, const GLint *v);
    642 angle::CallCapture CaptureTexCoord3s(const State &glState,
    643                                     bool isCallValid,
    644                                     GLshort s,
    645                                     GLshort t,
    646                                     GLshort r);
    647 angle::CallCapture CaptureTexCoord3sv(const State &glState, bool isCallValid, const GLshort *v);
    648 angle::CallCapture CaptureTexCoord4d(const State &glState,
    649                                     bool isCallValid,
    650                                     GLdouble s,
    651                                     GLdouble t,
    652                                     GLdouble r,
    653                                     GLdouble q);
    654 angle::CallCapture CaptureTexCoord4dv(const State &glState, bool isCallValid, const GLdouble *v);
    655 angle::CallCapture CaptureTexCoord4f(const State &glState,
    656                                     bool isCallValid,
    657                                     GLfloat s,
    658                                     GLfloat t,
    659                                     GLfloat r,
    660                                     GLfloat q);
    661 angle::CallCapture CaptureTexCoord4fv(const State &glState, bool isCallValid, const GLfloat *v);
    662 angle::CallCapture CaptureTexCoord4i(const State &glState,
    663                                     bool isCallValid,
    664                                     GLint s,
    665                                     GLint t,
    666                                     GLint r,
    667                                     GLint q);
    668 angle::CallCapture CaptureTexCoord4iv(const State &glState, bool isCallValid, const GLint *v);
    669 angle::CallCapture CaptureTexCoord4s(const State &glState,
    670                                     bool isCallValid,
    671                                     GLshort s,
    672                                     GLshort t,
    673                                     GLshort r,
    674                                     GLshort q);
    675 angle::CallCapture CaptureTexCoord4sv(const State &glState, bool isCallValid, const GLshort *v);
    676 angle::CallCapture CaptureTexGend(const State &glState,
    677                                  bool isCallValid,
    678                                  GLenum coord,
    679                                  GLenum pname,
    680                                  GLdouble param);
    681 angle::CallCapture CaptureTexGendv(const State &glState,
    682                                   bool isCallValid,
    683                                   GLenum coord,
    684                                   GLenum pname,
    685                                   const GLdouble *params);
    686 angle::CallCapture CaptureTexGenf(const State &glState,
    687                                  bool isCallValid,
    688                                  GLenum coord,
    689                                  GLenum pname,
    690                                  GLfloat param);
    691 angle::CallCapture CaptureTexGenfv(const State &glState,
    692                                   bool isCallValid,
    693                                   GLenum coord,
    694                                   GLenum pname,
    695                                   const GLfloat *params);
    696 angle::CallCapture CaptureTexGeni(const State &glState,
    697                                  bool isCallValid,
    698                                  GLenum coord,
    699                                  GLenum pname,
    700                                  GLint param);
    701 angle::CallCapture CaptureTexGeniv(const State &glState,
    702                                   bool isCallValid,
    703                                   GLenum coord,
    704                                   GLenum pname,
    705                                   const GLint *params);
    706 angle::CallCapture CaptureTexImage1D(const State &glState,
    707                                     bool isCallValid,
    708                                     GLenum target,
    709                                     GLint level,
    710                                     GLint internalformat,
    711                                     GLsizei width,
    712                                     GLint border,
    713                                     GLenum format,
    714                                     GLenum type,
    715                                     const void *pixels);
    716 angle::CallCapture CaptureTranslated(const State &glState,
    717                                     bool isCallValid,
    718                                     GLdouble x,
    719                                     GLdouble y,
    720                                     GLdouble z);
    721 angle::CallCapture CaptureVertex2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y);
    722 angle::CallCapture CaptureVertex2dv(const State &glState, bool isCallValid, const GLdouble *v);
    723 angle::CallCapture CaptureVertex2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
    724 angle::CallCapture CaptureVertex2fv(const State &glState, bool isCallValid, const GLfloat *v);
    725 angle::CallCapture CaptureVertex2i(const State &glState, bool isCallValid, GLint x, GLint y);
    726 angle::CallCapture CaptureVertex2iv(const State &glState, bool isCallValid, const GLint *v);
    727 angle::CallCapture CaptureVertex2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
    728 angle::CallCapture CaptureVertex2sv(const State &glState, bool isCallValid, const GLshort *v);
    729 angle::CallCapture CaptureVertex3d(const State &glState,
    730                                   bool isCallValid,
    731                                   GLdouble x,
    732                                   GLdouble y,
    733                                   GLdouble z);
    734 angle::CallCapture CaptureVertex3dv(const State &glState, bool isCallValid, const GLdouble *v);
    735 angle::CallCapture CaptureVertex3f(const State &glState,
    736                                   bool isCallValid,
    737                                   GLfloat x,
    738                                   GLfloat y,
    739                                   GLfloat z);
    740 angle::CallCapture CaptureVertex3fv(const State &glState, bool isCallValid, const GLfloat *v);
    741 angle::CallCapture CaptureVertex3i(const State &glState,
    742                                   bool isCallValid,
    743                                   GLint x,
    744                                   GLint y,
    745                                   GLint z);
    746 angle::CallCapture CaptureVertex3iv(const State &glState, bool isCallValid, const GLint *v);
    747 angle::CallCapture CaptureVertex3s(const State &glState,
    748                                   bool isCallValid,
    749                                   GLshort x,
    750                                   GLshort y,
    751                                   GLshort z);
    752 angle::CallCapture CaptureVertex3sv(const State &glState, bool isCallValid, const GLshort *v);
    753 angle::CallCapture CaptureVertex4d(const State &glState,
    754                                   bool isCallValid,
    755                                   GLdouble x,
    756                                   GLdouble y,
    757                                   GLdouble z,
    758                                   GLdouble w);
    759 angle::CallCapture CaptureVertex4dv(const State &glState, bool isCallValid, const GLdouble *v);
    760 angle::CallCapture CaptureVertex4f(const State &glState,
    761                                   bool isCallValid,
    762                                   GLfloat x,
    763                                   GLfloat y,
    764                                   GLfloat z,
    765                                   GLfloat w);
    766 angle::CallCapture CaptureVertex4fv(const State &glState, bool isCallValid, const GLfloat *v);
    767 angle::CallCapture CaptureVertex4i(const State &glState,
    768                                   bool isCallValid,
    769                                   GLint x,
    770                                   GLint y,
    771                                   GLint z,
    772                                   GLint w);
    773 angle::CallCapture CaptureVertex4iv(const State &glState, bool isCallValid, const GLint *v);
    774 angle::CallCapture CaptureVertex4s(const State &glState,
    775                                   bool isCallValid,
    776                                   GLshort x,
    777                                   GLshort y,
    778                                   GLshort z,
    779                                   GLshort w);
    780 angle::CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLshort *v);
    781 
    782 // GL 1.1
    783 angle::CallCapture CaptureAreTexturesResident(const State &glState,
    784                                              bool isCallValid,
    785                                              GLsizei n,
    786                                              const GLuint *textures,
    787                                              GLboolean *residences,
    788                                              GLboolean returnValue);
    789 angle::CallCapture CaptureArrayElement(const State &glState, bool isCallValid, GLint i);
    790 angle::CallCapture CaptureCopyTexImage1D(const State &glState,
    791                                         bool isCallValid,
    792                                         GLenum target,
    793                                         GLint level,
    794                                         GLenum internalformat,
    795                                         GLint x,
    796                                         GLint y,
    797                                         GLsizei width,
    798                                         GLint border);
    799 angle::CallCapture CaptureCopyTexSubImage1D(const State &glState,
    800                                            bool isCallValid,
    801                                            GLenum target,
    802                                            GLint level,
    803                                            GLint xoffset,
    804                                            GLint x,
    805                                            GLint y,
    806                                            GLsizei width);
    807 angle::CallCapture CaptureEdgeFlagPointer(const State &glState,
    808                                          bool isCallValid,
    809                                          GLsizei stride,
    810                                          const void *pointer);
    811 angle::CallCapture CaptureIndexPointer(const State &glState,
    812                                       bool isCallValid,
    813                                       GLenum type,
    814                                       GLsizei stride,
    815                                       const void *pointer);
    816 angle::CallCapture CaptureIndexub(const State &glState, bool isCallValid, GLubyte c);
    817 angle::CallCapture CaptureIndexubv(const State &glState, bool isCallValid, const GLubyte *c);
    818 angle::CallCapture CaptureInterleavedArrays(const State &glState,
    819                                            bool isCallValid,
    820                                            GLenum format,
    821                                            GLsizei stride,
    822                                            const void *pointer);
    823 angle::CallCapture CapturePopClientAttrib(const State &glState, bool isCallValid);
    824 angle::CallCapture CapturePrioritizeTextures(const State &glState,
    825                                             bool isCallValid,
    826                                             GLsizei n,
    827                                             const GLuint *textures,
    828                                             const GLfloat *priorities);
    829 angle::CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbitfield mask);
    830 angle::CallCapture CaptureTexSubImage1D(const State &glState,
    831                                        bool isCallValid,
    832                                        GLenum target,
    833                                        GLint level,
    834                                        GLint xoffset,
    835                                        GLsizei width,
    836                                        GLenum format,
    837                                        GLenum type,
    838                                        const void *pixels);
    839 
    840 // GL 1.2
    841 
    842 // GL 1.3
    843 angle::CallCapture CaptureCompressedTexImage1D(const State &glState,
    844                                               bool isCallValid,
    845                                               GLenum target,
    846                                               GLint level,
    847                                               GLenum internalformat,
    848                                               GLsizei width,
    849                                               GLint border,
    850                                               GLsizei imageSize,
    851                                               const void *data);
    852 angle::CallCapture CaptureCompressedTexSubImage1D(const State &glState,
    853                                                  bool isCallValid,
    854                                                  GLenum target,
    855                                                  GLint level,
    856                                                  GLint xoffset,
    857                                                  GLsizei width,
    858                                                  GLenum format,
    859                                                  GLsizei imageSize,
    860                                                  const void *data);
    861 angle::CallCapture CaptureGetCompressedTexImage(const State &glState,
    862                                                bool isCallValid,
    863                                                TextureTarget targetPacked,
    864                                                GLint level,
    865                                                void *img);
    866 angle::CallCapture CaptureLoadTransposeMatrixd(const State &glState,
    867                                               bool isCallValid,
    868                                               const GLdouble *m);
    869 angle::CallCapture CaptureLoadTransposeMatrixf(const State &glState,
    870                                               bool isCallValid,
    871                                               const GLfloat *m);
    872 angle::CallCapture CaptureMultTransposeMatrixd(const State &glState,
    873                                               bool isCallValid,
    874                                               const GLdouble *m);
    875 angle::CallCapture CaptureMultTransposeMatrixf(const State &glState,
    876                                               bool isCallValid,
    877                                               const GLfloat *m);
    878 angle::CallCapture CaptureMultiTexCoord1d(const State &glState,
    879                                          bool isCallValid,
    880                                          GLenum target,
    881                                          GLdouble s);
    882 angle::CallCapture CaptureMultiTexCoord1dv(const State &glState,
    883                                           bool isCallValid,
    884                                           GLenum target,
    885                                           const GLdouble *v);
    886 angle::CallCapture CaptureMultiTexCoord1f(const State &glState,
    887                                          bool isCallValid,
    888                                          GLenum target,
    889                                          GLfloat s);
    890 angle::CallCapture CaptureMultiTexCoord1fv(const State &glState,
    891                                           bool isCallValid,
    892                                           GLenum target,
    893                                           const GLfloat *v);
    894 angle::CallCapture CaptureMultiTexCoord1i(const State &glState,
    895                                          bool isCallValid,
    896                                          GLenum target,
    897                                          GLint s);
    898 angle::CallCapture CaptureMultiTexCoord1iv(const State &glState,
    899                                           bool isCallValid,
    900                                           GLenum target,
    901                                           const GLint *v);
    902 angle::CallCapture CaptureMultiTexCoord1s(const State &glState,
    903                                          bool isCallValid,
    904                                          GLenum target,
    905                                          GLshort s);
    906 angle::CallCapture CaptureMultiTexCoord1sv(const State &glState,
    907                                           bool isCallValid,
    908                                           GLenum target,
    909                                           const GLshort *v);
    910 angle::CallCapture CaptureMultiTexCoord2d(const State &glState,
    911                                          bool isCallValid,
    912                                          GLenum target,
    913                                          GLdouble s,
    914                                          GLdouble t);
    915 angle::CallCapture CaptureMultiTexCoord2dv(const State &glState,
    916                                           bool isCallValid,
    917                                           GLenum target,
    918                                           const GLdouble *v);
    919 angle::CallCapture CaptureMultiTexCoord2f(const State &glState,
    920                                          bool isCallValid,
    921                                          GLenum target,
    922                                          GLfloat s,
    923                                          GLfloat t);
    924 angle::CallCapture CaptureMultiTexCoord2fv(const State &glState,
    925                                           bool isCallValid,
    926                                           GLenum target,
    927                                           const GLfloat *v);
    928 angle::CallCapture CaptureMultiTexCoord2i(const State &glState,
    929                                          bool isCallValid,
    930                                          GLenum target,
    931                                          GLint s,
    932                                          GLint t);
    933 angle::CallCapture CaptureMultiTexCoord2iv(const State &glState,
    934                                           bool isCallValid,
    935                                           GLenum target,
    936                                           const GLint *v);
    937 angle::CallCapture CaptureMultiTexCoord2s(const State &glState,
    938                                          bool isCallValid,
    939                                          GLenum target,
    940                                          GLshort s,
    941                                          GLshort t);
    942 angle::CallCapture CaptureMultiTexCoord2sv(const State &glState,
    943                                           bool isCallValid,
    944                                           GLenum target,
    945                                           const GLshort *v);
    946 angle::CallCapture CaptureMultiTexCoord3d(const State &glState,
    947                                          bool isCallValid,
    948                                          GLenum target,
    949                                          GLdouble s,
    950                                          GLdouble t,
    951                                          GLdouble r);
    952 angle::CallCapture CaptureMultiTexCoord3dv(const State &glState,
    953                                           bool isCallValid,
    954                                           GLenum target,
    955                                           const GLdouble *v);
    956 angle::CallCapture CaptureMultiTexCoord3f(const State &glState,
    957                                          bool isCallValid,
    958                                          GLenum target,
    959                                          GLfloat s,
    960                                          GLfloat t,
    961                                          GLfloat r);
    962 angle::CallCapture CaptureMultiTexCoord3fv(const State &glState,
    963                                           bool isCallValid,
    964                                           GLenum target,
    965                                           const GLfloat *v);
    966 angle::CallCapture CaptureMultiTexCoord3i(const State &glState,
    967                                          bool isCallValid,
    968                                          GLenum target,
    969                                          GLint s,
    970                                          GLint t,
    971                                          GLint r);
    972 angle::CallCapture CaptureMultiTexCoord3iv(const State &glState,
    973                                           bool isCallValid,
    974                                           GLenum target,
    975                                           const GLint *v);
    976 angle::CallCapture CaptureMultiTexCoord3s(const State &glState,
    977                                          bool isCallValid,
    978                                          GLenum target,
    979                                          GLshort s,
    980                                          GLshort t,
    981                                          GLshort r);
    982 angle::CallCapture CaptureMultiTexCoord3sv(const State &glState,
    983                                           bool isCallValid,
    984                                           GLenum target,
    985                                           const GLshort *v);
    986 angle::CallCapture CaptureMultiTexCoord4d(const State &glState,
    987                                          bool isCallValid,
    988                                          GLenum target,
    989                                          GLdouble s,
    990                                          GLdouble t,
    991                                          GLdouble r,
    992                                          GLdouble q);
    993 angle::CallCapture CaptureMultiTexCoord4dv(const State &glState,
    994                                           bool isCallValid,
    995                                           GLenum target,
    996                                           const GLdouble *v);
    997 angle::CallCapture CaptureMultiTexCoord4fv(const State &glState,
    998                                           bool isCallValid,
    999                                           GLenum target,
   1000                                           const GLfloat *v);
   1001 angle::CallCapture CaptureMultiTexCoord4i(const State &glState,
   1002                                          bool isCallValid,
   1003                                          GLenum target,
   1004                                          GLint s,
   1005                                          GLint t,
   1006                                          GLint r,
   1007                                          GLint q);
   1008 angle::CallCapture CaptureMultiTexCoord4iv(const State &glState,
   1009                                           bool isCallValid,
   1010                                           GLenum target,
   1011                                           const GLint *v);
   1012 angle::CallCapture CaptureMultiTexCoord4s(const State &glState,
   1013                                          bool isCallValid,
   1014                                          GLenum target,
   1015                                          GLshort s,
   1016                                          GLshort t,
   1017                                          GLshort r,
   1018                                          GLshort q);
   1019 angle::CallCapture CaptureMultiTexCoord4sv(const State &glState,
   1020                                           bool isCallValid,
   1021                                           GLenum target,
   1022                                           const GLshort *v);
   1023 
   1024 // GL 1.4
   1025 angle::CallCapture CaptureFogCoordPointer(const State &glState,
   1026                                          bool isCallValid,
   1027                                          GLenum type,
   1028                                          GLsizei stride,
   1029                                          const void *pointer);
   1030 angle::CallCapture CaptureFogCoordd(const State &glState, bool isCallValid, GLdouble coord);
   1031 angle::CallCapture CaptureFogCoorddv(const State &glState, bool isCallValid, const GLdouble *coord);
   1032 angle::CallCapture CaptureFogCoordf(const State &glState, bool isCallValid, GLfloat coord);
   1033 angle::CallCapture CaptureFogCoordfv(const State &glState, bool isCallValid, const GLfloat *coord);
   1034 angle::CallCapture CaptureMultiDrawArrays(const State &glState,
   1035                                          bool isCallValid,
   1036                                          PrimitiveMode modePacked,
   1037                                          const GLint *first,
   1038                                          const GLsizei *count,
   1039                                          GLsizei drawcount);
   1040 angle::CallCapture CaptureMultiDrawElements(const State &glState,
   1041                                            bool isCallValid,
   1042                                            PrimitiveMode modePacked,
   1043                                            const GLsizei *count,
   1044                                            DrawElementsType typePacked,
   1045                                            const void *const *indices,
   1046                                            GLsizei drawcount);
   1047 angle::CallCapture CapturePointParameteri(const State &glState,
   1048                                          bool isCallValid,
   1049                                          GLenum pname,
   1050                                          GLint param);
   1051 angle::CallCapture CapturePointParameteriv(const State &glState,
   1052                                           bool isCallValid,
   1053                                           GLenum pname,
   1054                                           const GLint *params);
   1055 angle::CallCapture CaptureSecondaryColor3b(const State &glState,
   1056                                           bool isCallValid,
   1057                                           GLbyte red,
   1058                                           GLbyte green,
   1059                                           GLbyte blue);
   1060 angle::CallCapture CaptureSecondaryColor3bv(const State &glState,
   1061                                            bool isCallValid,
   1062                                            const GLbyte *v);
   1063 angle::CallCapture CaptureSecondaryColor3d(const State &glState,
   1064                                           bool isCallValid,
   1065                                           GLdouble red,
   1066                                           GLdouble green,
   1067                                           GLdouble blue);
   1068 angle::CallCapture CaptureSecondaryColor3dv(const State &glState,
   1069                                            bool isCallValid,
   1070                                            const GLdouble *v);
   1071 angle::CallCapture CaptureSecondaryColor3f(const State &glState,
   1072                                           bool isCallValid,
   1073                                           GLfloat red,
   1074                                           GLfloat green,
   1075                                           GLfloat blue);
   1076 angle::CallCapture CaptureSecondaryColor3fv(const State &glState,
   1077                                            bool isCallValid,
   1078                                            const GLfloat *v);
   1079 angle::CallCapture CaptureSecondaryColor3i(const State &glState,
   1080                                           bool isCallValid,
   1081                                           GLint red,
   1082                                           GLint green,
   1083                                           GLint blue);
   1084 angle::CallCapture CaptureSecondaryColor3iv(const State &glState, bool isCallValid, const GLint *v);
   1085 angle::CallCapture CaptureSecondaryColor3s(const State &glState,
   1086                                           bool isCallValid,
   1087                                           GLshort red,
   1088                                           GLshort green,
   1089                                           GLshort blue);
   1090 angle::CallCapture CaptureSecondaryColor3sv(const State &glState,
   1091                                            bool isCallValid,
   1092                                            const GLshort *v);
   1093 angle::CallCapture CaptureSecondaryColor3ub(const State &glState,
   1094                                            bool isCallValid,
   1095                                            GLubyte red,
   1096                                            GLubyte green,
   1097                                            GLubyte blue);
   1098 angle::CallCapture CaptureSecondaryColor3ubv(const State &glState,
   1099                                             bool isCallValid,
   1100                                             const GLubyte *v);
   1101 angle::CallCapture CaptureSecondaryColor3ui(const State &glState,
   1102                                            bool isCallValid,
   1103                                            GLuint red,
   1104                                            GLuint green,
   1105                                            GLuint blue);
   1106 angle::CallCapture CaptureSecondaryColor3uiv(const State &glState,
   1107                                             bool isCallValid,
   1108                                             const GLuint *v);
   1109 angle::CallCapture CaptureSecondaryColor3us(const State &glState,
   1110                                            bool isCallValid,
   1111                                            GLushort red,
   1112                                            GLushort green,
   1113                                            GLushort blue);
   1114 angle::CallCapture CaptureSecondaryColor3usv(const State &glState,
   1115                                             bool isCallValid,
   1116                                             const GLushort *v);
   1117 angle::CallCapture CaptureSecondaryColorPointer(const State &glState,
   1118                                                bool isCallValid,
   1119                                                GLint size,
   1120                                                GLenum type,
   1121                                                GLsizei stride,
   1122                                                const void *pointer);
   1123 angle::CallCapture CaptureWindowPos2d(const State &glState,
   1124                                      bool isCallValid,
   1125                                      GLdouble x,
   1126                                      GLdouble y);
   1127 angle::CallCapture CaptureWindowPos2dv(const State &glState, bool isCallValid, const GLdouble *v);
   1128 angle::CallCapture CaptureWindowPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
   1129 angle::CallCapture CaptureWindowPos2fv(const State &glState, bool isCallValid, const GLfloat *v);
   1130 angle::CallCapture CaptureWindowPos2i(const State &glState, bool isCallValid, GLint x, GLint y);
   1131 angle::CallCapture CaptureWindowPos2iv(const State &glState, bool isCallValid, const GLint *v);
   1132 angle::CallCapture CaptureWindowPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
   1133 angle::CallCapture CaptureWindowPos2sv(const State &glState, bool isCallValid, const GLshort *v);
   1134 angle::CallCapture CaptureWindowPos3d(const State &glState,
   1135                                      bool isCallValid,
   1136                                      GLdouble x,
   1137                                      GLdouble y,
   1138                                      GLdouble z);
   1139 angle::CallCapture CaptureWindowPos3dv(const State &glState, bool isCallValid, const GLdouble *v);
   1140 angle::CallCapture CaptureWindowPos3f(const State &glState,
   1141                                      bool isCallValid,
   1142                                      GLfloat x,
   1143                                      GLfloat y,
   1144                                      GLfloat z);
   1145 angle::CallCapture CaptureWindowPos3fv(const State &glState, bool isCallValid, const GLfloat *v);
   1146 angle::CallCapture CaptureWindowPos3i(const State &glState,
   1147                                      bool isCallValid,
   1148                                      GLint x,
   1149                                      GLint y,
   1150                                      GLint z);
   1151 angle::CallCapture CaptureWindowPos3iv(const State &glState, bool isCallValid, const GLint *v);
   1152 angle::CallCapture CaptureWindowPos3s(const State &glState,
   1153                                      bool isCallValid,
   1154                                      GLshort x,
   1155                                      GLshort y,
   1156                                      GLshort z);
   1157 angle::CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GLshort *v);
   1158 
   1159 // GL 1.5
   1160 angle::CallCapture CaptureGetBufferSubData(const State &glState,
   1161                                           bool isCallValid,
   1162                                           GLenum target,
   1163                                           GLintptr offset,
   1164                                           GLsizeiptr size,
   1165                                           void *data);
   1166 angle::CallCapture CaptureGetQueryObjectiv(const State &glState,
   1167                                           bool isCallValid,
   1168                                           QueryID idPacked,
   1169                                           GLenum pname,
   1170                                           GLint *params);
   1171 angle::CallCapture CaptureMapBuffer(const State &glState,
   1172                                    bool isCallValid,
   1173                                    BufferBinding targetPacked,
   1174                                    GLenum access,
   1175                                    void *returnValue);
   1176 
   1177 // Parameter Captures
   1178 
   1179 // GL 1.0
   1180 void CaptureBitmap_bitmap(const State &glState,
   1181                          bool isCallValid,
   1182                          GLsizei width,
   1183                          GLsizei height,
   1184                          GLfloat xorig,
   1185                          GLfloat yorig,
   1186                          GLfloat xmove,
   1187                          GLfloat ymove,
   1188                          const GLubyte *bitmap,
   1189                          angle::ParamCapture *paramCapture);
   1190 void CaptureCallLists_lists(const State &glState,
   1191                            bool isCallValid,
   1192                            GLsizei n,
   1193                            GLenum type,
   1194                            const void *lists,
   1195                            angle::ParamCapture *paramCapture);
   1196 void CaptureClipPlane_equation(const State &glState,
   1197                               bool isCallValid,
   1198                               GLenum plane,
   1199                               const GLdouble *equation,
   1200                               angle::ParamCapture *paramCapture);
   1201 void CaptureColor3bv_v(const State &glState,
   1202                       bool isCallValid,
   1203                       const GLbyte *v,
   1204                       angle::ParamCapture *paramCapture);
   1205 void CaptureColor3dv_v(const State &glState,
   1206                       bool isCallValid,
   1207                       const GLdouble *v,
   1208                       angle::ParamCapture *paramCapture);
   1209 void CaptureColor3fv_v(const State &glState,
   1210                       bool isCallValid,
   1211                       const GLfloat *v,
   1212                       angle::ParamCapture *paramCapture);
   1213 void CaptureColor3iv_v(const State &glState,
   1214                       bool isCallValid,
   1215                       const GLint *v,
   1216                       angle::ParamCapture *paramCapture);
   1217 void CaptureColor3sv_v(const State &glState,
   1218                       bool isCallValid,
   1219                       const GLshort *v,
   1220                       angle::ParamCapture *paramCapture);
   1221 void CaptureColor3ubv_v(const State &glState,
   1222                        bool isCallValid,
   1223                        const GLubyte *v,
   1224                        angle::ParamCapture *paramCapture);
   1225 void CaptureColor3uiv_v(const State &glState,
   1226                        bool isCallValid,
   1227                        const GLuint *v,
   1228                        angle::ParamCapture *paramCapture);
   1229 void CaptureColor3usv_v(const State &glState,
   1230                        bool isCallValid,
   1231                        const GLushort *v,
   1232                        angle::ParamCapture *paramCapture);
   1233 void CaptureColor4bv_v(const State &glState,
   1234                       bool isCallValid,
   1235                       const GLbyte *v,
   1236                       angle::ParamCapture *paramCapture);
   1237 void CaptureColor4dv_v(const State &glState,
   1238                       bool isCallValid,
   1239                       const GLdouble *v,
   1240                       angle::ParamCapture *paramCapture);
   1241 void CaptureColor4fv_v(const State &glState,
   1242                       bool isCallValid,
   1243                       const GLfloat *v,
   1244                       angle::ParamCapture *paramCapture);
   1245 void CaptureColor4iv_v(const State &glState,
   1246                       bool isCallValid,
   1247                       const GLint *v,
   1248                       angle::ParamCapture *paramCapture);
   1249 void CaptureColor4sv_v(const State &glState,
   1250                       bool isCallValid,
   1251                       const GLshort *v,
   1252                       angle::ParamCapture *paramCapture);
   1253 void CaptureColor4ubv_v(const State &glState,
   1254                        bool isCallValid,
   1255                        const GLubyte *v,
   1256                        angle::ParamCapture *paramCapture);
   1257 void CaptureColor4uiv_v(const State &glState,
   1258                        bool isCallValid,
   1259                        const GLuint *v,
   1260                        angle::ParamCapture *paramCapture);
   1261 void CaptureColor4usv_v(const State &glState,
   1262                        bool isCallValid,
   1263                        const GLushort *v,
   1264                        angle::ParamCapture *paramCapture);
   1265 void CaptureDrawPixels_pixels(const State &glState,
   1266                              bool isCallValid,
   1267                              GLsizei width,
   1268                              GLsizei height,
   1269                              GLenum format,
   1270                              GLenum type,
   1271                              const void *pixels,
   1272                              angle::ParamCapture *paramCapture);
   1273 void CaptureEdgeFlagv_flag(const State &glState,
   1274                           bool isCallValid,
   1275                           const GLboolean *flag,
   1276                           angle::ParamCapture *paramCapture);
   1277 void CaptureEvalCoord1dv_u(const State &glState,
   1278                           bool isCallValid,
   1279                           const GLdouble *u,
   1280                           angle::ParamCapture *paramCapture);
   1281 void CaptureEvalCoord1fv_u(const State &glState,
   1282                           bool isCallValid,
   1283                           const GLfloat *u,
   1284                           angle::ParamCapture *paramCapture);
   1285 void CaptureEvalCoord2dv_u(const State &glState,
   1286                           bool isCallValid,
   1287                           const GLdouble *u,
   1288                           angle::ParamCapture *paramCapture);
   1289 void CaptureEvalCoord2fv_u(const State &glState,
   1290                           bool isCallValid,
   1291                           const GLfloat *u,
   1292                           angle::ParamCapture *paramCapture);
   1293 void CaptureFeedbackBuffer_buffer(const State &glState,
   1294                                  bool isCallValid,
   1295                                  GLsizei size,
   1296                                  GLenum type,
   1297                                  GLfloat *buffer,
   1298                                  angle::ParamCapture *paramCapture);
   1299 void CaptureFogiv_params(const State &glState,
   1300                         bool isCallValid,
   1301                         GLenum pname,
   1302                         const GLint *params,
   1303                         angle::ParamCapture *paramCapture);
   1304 void CaptureGetClipPlane_equation(const State &glState,
   1305                                  bool isCallValid,
   1306                                  GLenum plane,
   1307                                  GLdouble *equation,
   1308                                  angle::ParamCapture *paramCapture);
   1309 void CaptureGetDoublev_data(const State &glState,
   1310                            bool isCallValid,
   1311                            GLenum pname,
   1312                            GLdouble *data,
   1313                            angle::ParamCapture *paramCapture);
   1314 void CaptureGetLightiv_params(const State &glState,
   1315                              bool isCallValid,
   1316                              GLenum light,
   1317                              GLenum pname,
   1318                              GLint *params,
   1319                              angle::ParamCapture *paramCapture);
   1320 void CaptureGetMapdv_v(const State &glState,
   1321                       bool isCallValid,
   1322                       GLenum target,
   1323                       GLenum query,
   1324                       GLdouble *v,
   1325                       angle::ParamCapture *paramCapture);
   1326 void CaptureGetMapfv_v(const State &glState,
   1327                       bool isCallValid,
   1328                       GLenum target,
   1329                       GLenum query,
   1330                       GLfloat *v,
   1331                       angle::ParamCapture *paramCapture);
   1332 void CaptureGetMapiv_v(const State &glState,
   1333                       bool isCallValid,
   1334                       GLenum target,
   1335                       GLenum query,
   1336                       GLint *v,
   1337                       angle::ParamCapture *paramCapture);
   1338 void CaptureGetMaterialiv_params(const State &glState,
   1339                                 bool isCallValid,
   1340                                 GLenum face,
   1341                                 GLenum pname,
   1342                                 GLint *params,
   1343                                 angle::ParamCapture *paramCapture);
   1344 void CaptureGetPixelMapfv_values(const State &glState,
   1345                                 bool isCallValid,
   1346                                 GLenum map,
   1347                                 GLfloat *values,
   1348                                 angle::ParamCapture *paramCapture);
   1349 void CaptureGetPixelMapuiv_values(const State &glState,
   1350                                  bool isCallValid,
   1351                                  GLenum map,
   1352                                  GLuint *values,
   1353                                  angle::ParamCapture *paramCapture);
   1354 void CaptureGetPixelMapusv_values(const State &glState,
   1355                                  bool isCallValid,
   1356                                  GLenum map,
   1357                                  GLushort *values,
   1358                                  angle::ParamCapture *paramCapture);
   1359 void CaptureGetPolygonStipple_mask(const State &glState,
   1360                                   bool isCallValid,
   1361                                   GLubyte *mask,
   1362                                   angle::ParamCapture *paramCapture);
   1363 void CaptureGetTexGendv_params(const State &glState,
   1364                               bool isCallValid,
   1365                               GLenum coord,
   1366                               GLenum pname,
   1367                               GLdouble *params,
   1368                               angle::ParamCapture *paramCapture);
   1369 void CaptureGetTexGenfv_params(const State &glState,
   1370                               bool isCallValid,
   1371                               GLenum coord,
   1372                               GLenum pname,
   1373                               GLfloat *params,
   1374                               angle::ParamCapture *paramCapture);
   1375 void CaptureGetTexGeniv_params(const State &glState,
   1376                               bool isCallValid,
   1377                               GLenum coord,
   1378                               GLenum pname,
   1379                               GLint *params,
   1380                               angle::ParamCapture *paramCapture);
   1381 void CaptureGetTexImage_pixels(const State &glState,
   1382                               bool isCallValid,
   1383                               TextureTarget targetPacked,
   1384                               GLint level,
   1385                               GLenum format,
   1386                               GLenum type,
   1387                               void *pixels,
   1388                               angle::ParamCapture *paramCapture);
   1389 void CaptureIndexdv_c(const State &glState,
   1390                      bool isCallValid,
   1391                      const GLdouble *c,
   1392                      angle::ParamCapture *paramCapture);
   1393 void CaptureIndexfv_c(const State &glState,
   1394                      bool isCallValid,
   1395                      const GLfloat *c,
   1396                      angle::ParamCapture *paramCapture);
   1397 void CaptureIndexiv_c(const State &glState,
   1398                      bool isCallValid,
   1399                      const GLint *c,
   1400                      angle::ParamCapture *paramCapture);
   1401 void CaptureIndexsv_c(const State &glState,
   1402                      bool isCallValid,
   1403                      const GLshort *c,
   1404                      angle::ParamCapture *paramCapture);
   1405 void CaptureLightModeliv_params(const State &glState,
   1406                                bool isCallValid,
   1407                                GLenum pname,
   1408                                const GLint *params,
   1409                                angle::ParamCapture *paramCapture);
   1410 void CaptureLightiv_params(const State &glState,
   1411                           bool isCallValid,
   1412                           GLenum light,
   1413                           GLenum pname,
   1414                           const GLint *params,
   1415                           angle::ParamCapture *paramCapture);
   1416 void CaptureLoadMatrixd_m(const State &glState,
   1417                          bool isCallValid,
   1418                          const GLdouble *m,
   1419                          angle::ParamCapture *paramCapture);
   1420 void CaptureMap1d_points(const State &glState,
   1421                         bool isCallValid,
   1422                         GLenum target,
   1423                         GLdouble u1,
   1424                         GLdouble u2,
   1425                         GLint stride,
   1426                         GLint order,
   1427                         const GLdouble *points,
   1428                         angle::ParamCapture *paramCapture);
   1429 void CaptureMap1f_points(const State &glState,
   1430                         bool isCallValid,
   1431                         GLenum target,
   1432                         GLfloat u1,
   1433                         GLfloat u2,
   1434                         GLint stride,
   1435                         GLint order,
   1436                         const GLfloat *points,
   1437                         angle::ParamCapture *paramCapture);
   1438 void CaptureMap2d_points(const State &glState,
   1439                         bool isCallValid,
   1440                         GLenum target,
   1441                         GLdouble u1,
   1442                         GLdouble u2,
   1443                         GLint ustride,
   1444                         GLint uorder,
   1445                         GLdouble v1,
   1446                         GLdouble v2,
   1447                         GLint vstride,
   1448                         GLint vorder,
   1449                         const GLdouble *points,
   1450                         angle::ParamCapture *paramCapture);
   1451 void CaptureMap2f_points(const State &glState,
   1452                         bool isCallValid,
   1453                         GLenum target,
   1454                         GLfloat u1,
   1455                         GLfloat u2,
   1456                         GLint ustride,
   1457                         GLint uorder,
   1458                         GLfloat v1,
   1459                         GLfloat v2,
   1460                         GLint vstride,
   1461                         GLint vorder,
   1462                         const GLfloat *points,
   1463                         angle::ParamCapture *paramCapture);
   1464 void CaptureMaterialiv_params(const State &glState,
   1465                              bool isCallValid,
   1466                              GLenum face,
   1467                              GLenum pname,
   1468                              const GLint *params,
   1469                              angle::ParamCapture *paramCapture);
   1470 void CaptureMultMatrixd_m(const State &glState,
   1471                          bool isCallValid,
   1472                          const GLdouble *m,
   1473                          angle::ParamCapture *paramCapture);
   1474 void CaptureNormal3bv_v(const State &glState,
   1475                        bool isCallValid,
   1476                        const GLbyte *v,
   1477                        angle::ParamCapture *paramCapture);
   1478 void CaptureNormal3dv_v(const State &glState,
   1479                        bool isCallValid,
   1480                        const GLdouble *v,
   1481                        angle::ParamCapture *paramCapture);
   1482 void CaptureNormal3fv_v(const State &glState,
   1483                        bool isCallValid,
   1484                        const GLfloat *v,
   1485                        angle::ParamCapture *paramCapture);
   1486 void CaptureNormal3iv_v(const State &glState,
   1487                        bool isCallValid,
   1488                        const GLint *v,
   1489                        angle::ParamCapture *paramCapture);
   1490 void CaptureNormal3sv_v(const State &glState,
   1491                        bool isCallValid,
   1492                        const GLshort *v,
   1493                        angle::ParamCapture *paramCapture);
   1494 void CapturePixelMapfv_values(const State &glState,
   1495                              bool isCallValid,
   1496                              GLenum map,
   1497                              GLsizei mapsize,
   1498                              const GLfloat *values,
   1499                              angle::ParamCapture *paramCapture);
   1500 void CapturePixelMapuiv_values(const State &glState,
   1501                               bool isCallValid,
   1502                               GLenum map,
   1503                               GLsizei mapsize,
   1504                               const GLuint *values,
   1505                               angle::ParamCapture *paramCapture);
   1506 void CapturePixelMapusv_values(const State &glState,
   1507                               bool isCallValid,
   1508                               GLenum map,
   1509                               GLsizei mapsize,
   1510                               const GLushort *values,
   1511                               angle::ParamCapture *paramCapture);
   1512 void CapturePolygonStipple_mask(const State &glState,
   1513                                bool isCallValid,
   1514                                const GLubyte *mask,
   1515                                angle::ParamCapture *paramCapture);
   1516 void CaptureRasterPos2dv_v(const State &glState,
   1517                           bool isCallValid,
   1518                           const GLdouble *v,
   1519                           angle::ParamCapture *paramCapture);
   1520 void CaptureRasterPos2fv_v(const State &glState,
   1521                           bool isCallValid,
   1522                           const GLfloat *v,
   1523                           angle::ParamCapture *paramCapture);
   1524 void CaptureRasterPos2iv_v(const State &glState,
   1525                           bool isCallValid,
   1526                           const GLint *v,
   1527                           angle::ParamCapture *paramCapture);
   1528 void CaptureRasterPos2sv_v(const State &glState,
   1529                           bool isCallValid,
   1530                           const GLshort *v,
   1531                           angle::ParamCapture *paramCapture);
   1532 void CaptureRasterPos3dv_v(const State &glState,
   1533                           bool isCallValid,
   1534                           const GLdouble *v,
   1535                           angle::ParamCapture *paramCapture);
   1536 void CaptureRasterPos3fv_v(const State &glState,
   1537                           bool isCallValid,
   1538                           const GLfloat *v,
   1539                           angle::ParamCapture *paramCapture);
   1540 void CaptureRasterPos3iv_v(const State &glState,
   1541                           bool isCallValid,
   1542                           const GLint *v,
   1543                           angle::ParamCapture *paramCapture);
   1544 void CaptureRasterPos3sv_v(const State &glState,
   1545                           bool isCallValid,
   1546                           const GLshort *v,
   1547                           angle::ParamCapture *paramCapture);
   1548 void CaptureRasterPos4dv_v(const State &glState,
   1549                           bool isCallValid,
   1550                           const GLdouble *v,
   1551                           angle::ParamCapture *paramCapture);
   1552 void CaptureRasterPos4fv_v(const State &glState,
   1553                           bool isCallValid,
   1554                           const GLfloat *v,
   1555                           angle::ParamCapture *paramCapture);
   1556 void CaptureRasterPos4iv_v(const State &glState,
   1557                           bool isCallValid,
   1558                           const GLint *v,
   1559                           angle::ParamCapture *paramCapture);
   1560 void CaptureRasterPos4sv_v(const State &glState,
   1561                           bool isCallValid,
   1562                           const GLshort *v,
   1563                           angle::ParamCapture *paramCapture);
   1564 void CaptureRectdv_v1(const State &glState,
   1565                      bool isCallValid,
   1566                      const GLdouble *v1,
   1567                      const GLdouble *v2,
   1568                      angle::ParamCapture *paramCapture);
   1569 void CaptureRectdv_v2(const State &glState,
   1570                      bool isCallValid,
   1571                      const GLdouble *v1,
   1572                      const GLdouble *v2,
   1573                      angle::ParamCapture *paramCapture);
   1574 void CaptureRectfv_v1(const State &glState,
   1575                      bool isCallValid,
   1576                      const GLfloat *v1,
   1577                      const GLfloat *v2,
   1578                      angle::ParamCapture *paramCapture);
   1579 void CaptureRectfv_v2(const State &glState,
   1580                      bool isCallValid,
   1581                      const GLfloat *v1,
   1582                      const GLfloat *v2,
   1583                      angle::ParamCapture *paramCapture);
   1584 void CaptureRectiv_v1(const State &glState,
   1585                      bool isCallValid,
   1586                      const GLint *v1,
   1587                      const GLint *v2,
   1588                      angle::ParamCapture *paramCapture);
   1589 void CaptureRectiv_v2(const State &glState,
   1590                      bool isCallValid,
   1591                      const GLint *v1,
   1592                      const GLint *v2,
   1593                      angle::ParamCapture *paramCapture);
   1594 void CaptureRectsv_v1(const State &glState,
   1595                      bool isCallValid,
   1596                      const GLshort *v1,
   1597                      const GLshort *v2,
   1598                      angle::ParamCapture *paramCapture);
   1599 void CaptureRectsv_v2(const State &glState,
   1600                      bool isCallValid,
   1601                      const GLshort *v1,
   1602                      const GLshort *v2,
   1603                      angle::ParamCapture *paramCapture);
   1604 void CaptureSelectBuffer_buffer(const State &glState,
   1605                                bool isCallValid,
   1606                                GLsizei size,
   1607                                GLuint *buffer,
   1608                                angle::ParamCapture *paramCapture);
   1609 void CaptureTexCoord1dv_v(const State &glState,
   1610                          bool isCallValid,
   1611                          const GLdouble *v,
   1612                          angle::ParamCapture *paramCapture);
   1613 void CaptureTexCoord1fv_v(const State &glState,
   1614                          bool isCallValid,
   1615                          const GLfloat *v,
   1616                          angle::ParamCapture *paramCapture);
   1617 void CaptureTexCoord1iv_v(const State &glState,
   1618                          bool isCallValid,
   1619                          const GLint *v,
   1620                          angle::ParamCapture *paramCapture);
   1621 void CaptureTexCoord1sv_v(const State &glState,
   1622                          bool isCallValid,
   1623                          const GLshort *v,
   1624                          angle::ParamCapture *paramCapture);
   1625 void CaptureTexCoord2dv_v(const State &glState,
   1626                          bool isCallValid,
   1627                          const GLdouble *v,
   1628                          angle::ParamCapture *paramCapture);
   1629 void CaptureTexCoord2fv_v(const State &glState,
   1630                          bool isCallValid,
   1631                          const GLfloat *v,
   1632                          angle::ParamCapture *paramCapture);
   1633 void CaptureTexCoord2iv_v(const State &glState,
   1634                          bool isCallValid,
   1635                          const GLint *v,
   1636                          angle::ParamCapture *paramCapture);
   1637 void CaptureTexCoord2sv_v(const State &glState,
   1638                          bool isCallValid,
   1639                          const GLshort *v,
   1640                          angle::ParamCapture *paramCapture);
   1641 void CaptureTexCoord3dv_v(const State &glState,
   1642                          bool isCallValid,
   1643                          const GLdouble *v,
   1644                          angle::ParamCapture *paramCapture);
   1645 void CaptureTexCoord3fv_v(const State &glState,
   1646                          bool isCallValid,
   1647                          const GLfloat *v,
   1648                          angle::ParamCapture *paramCapture);
   1649 void CaptureTexCoord3iv_v(const State &glState,
   1650                          bool isCallValid,
   1651                          const GLint *v,
   1652                          angle::ParamCapture *paramCapture);
   1653 void CaptureTexCoord3sv_v(const State &glState,
   1654                          bool isCallValid,
   1655                          const GLshort *v,
   1656                          angle::ParamCapture *paramCapture);
   1657 void CaptureTexCoord4dv_v(const State &glState,
   1658                          bool isCallValid,
   1659                          const GLdouble *v,
   1660                          angle::ParamCapture *paramCapture);
   1661 void CaptureTexCoord4fv_v(const State &glState,
   1662                          bool isCallValid,
   1663                          const GLfloat *v,
   1664                          angle::ParamCapture *paramCapture);
   1665 void CaptureTexCoord4iv_v(const State &glState,
   1666                          bool isCallValid,
   1667                          const GLint *v,
   1668                          angle::ParamCapture *paramCapture);
   1669 void CaptureTexCoord4sv_v(const State &glState,
   1670                          bool isCallValid,
   1671                          const GLshort *v,
   1672                          angle::ParamCapture *paramCapture);
   1673 void CaptureTexGendv_params(const State &glState,
   1674                            bool isCallValid,
   1675                            GLenum coord,
   1676                            GLenum pname,
   1677                            const GLdouble *params,
   1678                            angle::ParamCapture *paramCapture);
   1679 void CaptureTexGenfv_params(const State &glState,
   1680                            bool isCallValid,
   1681                            GLenum coord,
   1682                            GLenum pname,
   1683                            const GLfloat *params,
   1684                            angle::ParamCapture *paramCapture);
   1685 void CaptureTexGeniv_params(const State &glState,
   1686                            bool isCallValid,
   1687                            GLenum coord,
   1688                            GLenum pname,
   1689                            const GLint *params,
   1690                            angle::ParamCapture *paramCapture);
   1691 void CaptureTexImage1D_pixels(const State &glState,
   1692                              bool isCallValid,
   1693                              GLenum target,
   1694                              GLint level,
   1695                              GLint internalformat,
   1696                              GLsizei width,
   1697                              GLint border,
   1698                              GLenum format,
   1699                              GLenum type,
   1700                              const void *pixels,
   1701                              angle::ParamCapture *paramCapture);
   1702 void CaptureVertex2dv_v(const State &glState,
   1703                        bool isCallValid,
   1704                        const GLdouble *v,
   1705                        angle::ParamCapture *paramCapture);
   1706 void CaptureVertex2fv_v(const State &glState,
   1707                        bool isCallValid,
   1708                        const GLfloat *v,
   1709                        angle::ParamCapture *paramCapture);
   1710 void CaptureVertex2iv_v(const State &glState,
   1711                        bool isCallValid,
   1712                        const GLint *v,
   1713                        angle::ParamCapture *paramCapture);
   1714 void CaptureVertex2sv_v(const State &glState,
   1715                        bool isCallValid,
   1716                        const GLshort *v,
   1717                        angle::ParamCapture *paramCapture);
   1718 void CaptureVertex3dv_v(const State &glState,
   1719                        bool isCallValid,
   1720                        const GLdouble *v,
   1721                        angle::ParamCapture *paramCapture);
   1722 void CaptureVertex3fv_v(const State &glState,
   1723                        bool isCallValid,
   1724                        const GLfloat *v,
   1725                        angle::ParamCapture *paramCapture);
   1726 void CaptureVertex3iv_v(const State &glState,
   1727                        bool isCallValid,
   1728                        const GLint *v,
   1729                        angle::ParamCapture *paramCapture);
   1730 void CaptureVertex3sv_v(const State &glState,
   1731                        bool isCallValid,
   1732                        const GLshort *v,
   1733                        angle::ParamCapture *paramCapture);
   1734 void CaptureVertex4dv_v(const State &glState,
   1735                        bool isCallValid,
   1736                        const GLdouble *v,
   1737                        angle::ParamCapture *paramCapture);
   1738 void CaptureVertex4fv_v(const State &glState,
   1739                        bool isCallValid,
   1740                        const GLfloat *v,
   1741                        angle::ParamCapture *paramCapture);
   1742 void CaptureVertex4iv_v(const State &glState,
   1743                        bool isCallValid,
   1744                        const GLint *v,
   1745                        angle::ParamCapture *paramCapture);
   1746 void CaptureVertex4sv_v(const State &glState,
   1747                        bool isCallValid,
   1748                        const GLshort *v,
   1749                        angle::ParamCapture *paramCapture);
   1750 
   1751 // GL 1.1
   1752 void CaptureAreTexturesResident_textures(const State &glState,
   1753                                         bool isCallValid,
   1754                                         GLsizei n,
   1755                                         const GLuint *textures,
   1756                                         GLboolean *residences,
   1757                                         angle::ParamCapture *paramCapture);
   1758 void CaptureAreTexturesResident_residences(const State &glState,
   1759                                           bool isCallValid,
   1760                                           GLsizei n,
   1761                                           const GLuint *textures,
   1762                                           GLboolean *residences,
   1763                                           angle::ParamCapture *paramCapture);
   1764 void CaptureEdgeFlagPointer_pointer(const State &glState,
   1765                                    bool isCallValid,
   1766                                    GLsizei stride,
   1767                                    const void *pointer,
   1768                                    angle::ParamCapture *paramCapture);
   1769 void CaptureIndexPointer_pointer(const State &glState,
   1770                                 bool isCallValid,
   1771                                 GLenum type,
   1772                                 GLsizei stride,
   1773                                 const void *pointer,
   1774                                 angle::ParamCapture *paramCapture);
   1775 void CaptureIndexubv_c(const State &glState,
   1776                       bool isCallValid,
   1777                       const GLubyte *c,
   1778                       angle::ParamCapture *paramCapture);
   1779 void CaptureInterleavedArrays_pointer(const State &glState,
   1780                                      bool isCallValid,
   1781                                      GLenum format,
   1782                                      GLsizei stride,
   1783                                      const void *pointer,
   1784                                      angle::ParamCapture *paramCapture);
   1785 void CapturePrioritizeTextures_textures(const State &glState,
   1786                                        bool isCallValid,
   1787                                        GLsizei n,
   1788                                        const GLuint *textures,
   1789                                        const GLfloat *priorities,
   1790                                        angle::ParamCapture *paramCapture);
   1791 void CapturePrioritizeTextures_priorities(const State &glState,
   1792                                          bool isCallValid,
   1793                                          GLsizei n,
   1794                                          const GLuint *textures,
   1795                                          const GLfloat *priorities,
   1796                                          angle::ParamCapture *paramCapture);
   1797 void CaptureTexSubImage1D_pixels(const State &glState,
   1798                                 bool isCallValid,
   1799                                 GLenum target,
   1800                                 GLint level,
   1801                                 GLint xoffset,
   1802                                 GLsizei width,
   1803                                 GLenum format,
   1804                                 GLenum type,
   1805                                 const void *pixels,
   1806                                 angle::ParamCapture *paramCapture);
   1807 
   1808 // GL 1.2
   1809 
   1810 // GL 1.3
   1811 void CaptureCompressedTexImage1D_data(const State &glState,
   1812                                      bool isCallValid,
   1813                                      GLenum target,
   1814                                      GLint level,
   1815                                      GLenum internalformat,
   1816                                      GLsizei width,
   1817                                      GLint border,
   1818                                      GLsizei imageSize,
   1819                                      const void *data,
   1820                                      angle::ParamCapture *paramCapture);
   1821 void CaptureCompressedTexSubImage1D_data(const State &glState,
   1822                                         bool isCallValid,
   1823                                         GLenum target,
   1824                                         GLint level,
   1825                                         GLint xoffset,
   1826                                         GLsizei width,
   1827                                         GLenum format,
   1828                                         GLsizei imageSize,
   1829                                         const void *data,
   1830                                         angle::ParamCapture *paramCapture);
   1831 void CaptureGetCompressedTexImage_img(const State &glState,
   1832                                      bool isCallValid,
   1833                                      TextureTarget targetPacked,
   1834                                      GLint level,
   1835                                      void *img,
   1836                                      angle::ParamCapture *paramCapture);
   1837 void CaptureLoadTransposeMatrixd_m(const State &glState,
   1838                                   bool isCallValid,
   1839                                   const GLdouble *m,
   1840                                   angle::ParamCapture *paramCapture);
   1841 void CaptureLoadTransposeMatrixf_m(const State &glState,
   1842                                   bool isCallValid,
   1843                                   const GLfloat *m,
   1844                                   angle::ParamCapture *paramCapture);
   1845 void CaptureMultTransposeMatrixd_m(const State &glState,
   1846                                   bool isCallValid,
   1847                                   const GLdouble *m,
   1848                                   angle::ParamCapture *paramCapture);
   1849 void CaptureMultTransposeMatrixf_m(const State &glState,
   1850                                   bool isCallValid,
   1851                                   const GLfloat *m,
   1852                                   angle::ParamCapture *paramCapture);
   1853 void CaptureMultiTexCoord1dv_v(const State &glState,
   1854                               bool isCallValid,
   1855                               GLenum target,
   1856                               const GLdouble *v,
   1857                               angle::ParamCapture *paramCapture);
   1858 void CaptureMultiTexCoord1fv_v(const State &glState,
   1859                               bool isCallValid,
   1860                               GLenum target,
   1861                               const GLfloat *v,
   1862                               angle::ParamCapture *paramCapture);
   1863 void CaptureMultiTexCoord1iv_v(const State &glState,
   1864                               bool isCallValid,
   1865                               GLenum target,
   1866                               const GLint *v,
   1867                               angle::ParamCapture *paramCapture);
   1868 void CaptureMultiTexCoord1sv_v(const State &glState,
   1869                               bool isCallValid,
   1870                               GLenum target,
   1871                               const GLshort *v,
   1872                               angle::ParamCapture *paramCapture);
   1873 void CaptureMultiTexCoord2dv_v(const State &glState,
   1874                               bool isCallValid,
   1875                               GLenum target,
   1876                               const GLdouble *v,
   1877                               angle::ParamCapture *paramCapture);
   1878 void CaptureMultiTexCoord2fv_v(const State &glState,
   1879                               bool isCallValid,
   1880                               GLenum target,
   1881                               const GLfloat *v,
   1882                               angle::ParamCapture *paramCapture);
   1883 void CaptureMultiTexCoord2iv_v(const State &glState,
   1884                               bool isCallValid,
   1885                               GLenum target,
   1886                               const GLint *v,
   1887                               angle::ParamCapture *paramCapture);
   1888 void CaptureMultiTexCoord2sv_v(const State &glState,
   1889                               bool isCallValid,
   1890                               GLenum target,
   1891                               const GLshort *v,
   1892                               angle::ParamCapture *paramCapture);
   1893 void CaptureMultiTexCoord3dv_v(const State &glState,
   1894                               bool isCallValid,
   1895                               GLenum target,
   1896                               const GLdouble *v,
   1897                               angle::ParamCapture *paramCapture);
   1898 void CaptureMultiTexCoord3fv_v(const State &glState,
   1899                               bool isCallValid,
   1900                               GLenum target,
   1901                               const GLfloat *v,
   1902                               angle::ParamCapture *paramCapture);
   1903 void CaptureMultiTexCoord3iv_v(const State &glState,
   1904                               bool isCallValid,
   1905                               GLenum target,
   1906                               const GLint *v,
   1907                               angle::ParamCapture *paramCapture);
   1908 void CaptureMultiTexCoord3sv_v(const State &glState,
   1909                               bool isCallValid,
   1910                               GLenum target,
   1911                               const GLshort *v,
   1912                               angle::ParamCapture *paramCapture);
   1913 void CaptureMultiTexCoord4dv_v(const State &glState,
   1914                               bool isCallValid,
   1915                               GLenum target,
   1916                               const GLdouble *v,
   1917                               angle::ParamCapture *paramCapture);
   1918 void CaptureMultiTexCoord4fv_v(const State &glState,
   1919                               bool isCallValid,
   1920                               GLenum target,
   1921                               const GLfloat *v,
   1922                               angle::ParamCapture *paramCapture);
   1923 void CaptureMultiTexCoord4iv_v(const State &glState,
   1924                               bool isCallValid,
   1925                               GLenum target,
   1926                               const GLint *v,
   1927                               angle::ParamCapture *paramCapture);
   1928 void CaptureMultiTexCoord4sv_v(const State &glState,
   1929                               bool isCallValid,
   1930                               GLenum target,
   1931                               const GLshort *v,
   1932                               angle::ParamCapture *paramCapture);
   1933 
   1934 // GL 1.4
   1935 void CaptureFogCoordPointer_pointer(const State &glState,
   1936                                    bool isCallValid,
   1937                                    GLenum type,
   1938                                    GLsizei stride,
   1939                                    const void *pointer,
   1940                                    angle::ParamCapture *paramCapture);
   1941 void CaptureFogCoorddv_coord(const State &glState,
   1942                             bool isCallValid,
   1943                             const GLdouble *coord,
   1944                             angle::ParamCapture *paramCapture);
   1945 void CaptureFogCoordfv_coord(const State &glState,
   1946                             bool isCallValid,
   1947                             const GLfloat *coord,
   1948                             angle::ParamCapture *paramCapture);
   1949 void CaptureMultiDrawArrays_first(const State &glState,
   1950                                  bool isCallValid,
   1951                                  PrimitiveMode modePacked,
   1952                                  const GLint *first,
   1953                                  const GLsizei *count,
   1954                                  GLsizei drawcount,
   1955                                  angle::ParamCapture *paramCapture);
   1956 void CaptureMultiDrawArrays_count(const State &glState,
   1957                                  bool isCallValid,
   1958                                  PrimitiveMode modePacked,
   1959                                  const GLint *first,
   1960                                  const GLsizei *count,
   1961                                  GLsizei drawcount,
   1962                                  angle::ParamCapture *paramCapture);
   1963 void CaptureMultiDrawElements_count(const State &glState,
   1964                                    bool isCallValid,
   1965                                    PrimitiveMode modePacked,
   1966                                    const GLsizei *count,
   1967                                    DrawElementsType typePacked,
   1968                                    const void *const *indices,
   1969                                    GLsizei drawcount,
   1970                                    angle::ParamCapture *paramCapture);
   1971 void CaptureMultiDrawElements_indices(const State &glState,
   1972                                      bool isCallValid,
   1973                                      PrimitiveMode modePacked,
   1974                                      const GLsizei *count,
   1975                                      DrawElementsType typePacked,
   1976                                      const void *const *indices,
   1977                                      GLsizei drawcount,
   1978                                      angle::ParamCapture *paramCapture);
   1979 void CapturePointParameteriv_params(const State &glState,
   1980                                    bool isCallValid,
   1981                                    GLenum pname,
   1982                                    const GLint *params,
   1983                                    angle::ParamCapture *paramCapture);
   1984 void CaptureSecondaryColor3bv_v(const State &glState,
   1985                                bool isCallValid,
   1986                                const GLbyte *v,
   1987                                angle::ParamCapture *paramCapture);
   1988 void CaptureSecondaryColor3dv_v(const State &glState,
   1989                                bool isCallValid,
   1990                                const GLdouble *v,
   1991                                angle::ParamCapture *paramCapture);
   1992 void CaptureSecondaryColor3fv_v(const State &glState,
   1993                                bool isCallValid,
   1994                                const GLfloat *v,
   1995                                angle::ParamCapture *paramCapture);
   1996 void CaptureSecondaryColor3iv_v(const State &glState,
   1997                                bool isCallValid,
   1998                                const GLint *v,
   1999                                angle::ParamCapture *paramCapture);
   2000 void CaptureSecondaryColor3sv_v(const State &glState,
   2001                                bool isCallValid,
   2002                                const GLshort *v,
   2003                                angle::ParamCapture *paramCapture);
   2004 void CaptureSecondaryColor3ubv_v(const State &glState,
   2005                                 bool isCallValid,
   2006                                 const GLubyte *v,
   2007                                 angle::ParamCapture *paramCapture);
   2008 void CaptureSecondaryColor3uiv_v(const State &glState,
   2009                                 bool isCallValid,
   2010                                 const GLuint *v,
   2011                                 angle::ParamCapture *paramCapture);
   2012 void CaptureSecondaryColor3usv_v(const State &glState,
   2013                                 bool isCallValid,
   2014                                 const GLushort *v,
   2015                                 angle::ParamCapture *paramCapture);
   2016 void CaptureSecondaryColorPointer_pointer(const State &glState,
   2017                                          bool isCallValid,
   2018                                          GLint size,
   2019                                          GLenum type,
   2020                                          GLsizei stride,
   2021                                          const void *pointer,
   2022                                          angle::ParamCapture *paramCapture);
   2023 void CaptureWindowPos2dv_v(const State &glState,
   2024                           bool isCallValid,
   2025                           const GLdouble *v,
   2026                           angle::ParamCapture *paramCapture);
   2027 void CaptureWindowPos2fv_v(const State &glState,
   2028                           bool isCallValid,
   2029                           const GLfloat *v,
   2030                           angle::ParamCapture *paramCapture);
   2031 void CaptureWindowPos2iv_v(const State &glState,
   2032                           bool isCallValid,
   2033                           const GLint *v,
   2034                           angle::ParamCapture *paramCapture);
   2035 void CaptureWindowPos2sv_v(const State &glState,
   2036                           bool isCallValid,
   2037                           const GLshort *v,
   2038                           angle::ParamCapture *paramCapture);
   2039 void CaptureWindowPos3dv_v(const State &glState,
   2040                           bool isCallValid,
   2041                           const GLdouble *v,
   2042                           angle::ParamCapture *paramCapture);
   2043 void CaptureWindowPos3fv_v(const State &glState,
   2044                           bool isCallValid,
   2045                           const GLfloat *v,
   2046                           angle::ParamCapture *paramCapture);
   2047 void CaptureWindowPos3iv_v(const State &glState,
   2048                           bool isCallValid,
   2049                           const GLint *v,
   2050                           angle::ParamCapture *paramCapture);
   2051 void CaptureWindowPos3sv_v(const State &glState,
   2052                           bool isCallValid,
   2053                           const GLshort *v,
   2054                           angle::ParamCapture *paramCapture);
   2055 
   2056 // GL 1.5
   2057 void CaptureGetBufferSubData_data(const State &glState,
   2058                                  bool isCallValid,
   2059                                  GLenum target,
   2060                                  GLintptr offset,
   2061                                  GLsizeiptr size,
   2062                                  void *data,
   2063                                  angle::ParamCapture *paramCapture);
   2064 void CaptureGetQueryObjectiv_params(const State &glState,
   2065                                    bool isCallValid,
   2066                                    QueryID idPacked,
   2067                                    GLenum pname,
   2068                                    GLint *params,
   2069                                    angle::ParamCapture *paramCapture);
   2070 }  // namespace gl
   2071 
   2072 #endif  // LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_