• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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                                       PolygonMode modePacked);
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_
2073