← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/capture_gles_ext_autogen.h

  • Committer: mmach
  • Date: 2023-06-16 17:21:37 UTC
  • Revision ID: netbit73@gmail.com-20230616172137-2rqx6yr96ga9g3kp
1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/ThirdParty/ANGLE/src/libANGLE/capture_gles_ext_autogen.h
 
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_gles_ext_autogen.h:
 
9
//   Capture functions for the OpenGL ES extension entry points.
 
10
 
 
11
#ifndef LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_
 
12
#define LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_
 
13
 
 
14
#include "common/PackedEnums.h"
 
15
#include "libANGLE/FrameCapture.h"
 
16
 
 
17
namespace gl
 
18
{
 
19
 
 
20
// Method Captures
 
21
 
 
22
// GL_ANGLE_base_vertex_base_instance
 
23
angle::CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const State &glState,
 
24
                                                               bool isCallValid,
 
25
                                                               PrimitiveMode modePacked,
 
26
                                                               GLint first,
 
27
                                                               GLsizei count,
 
28
                                                               GLsizei instanceCount,
 
29
                                                               GLuint baseInstance);
 
30
angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(
 
31
    const State &glState,
 
32
    bool isCallValid,
 
33
    PrimitiveMode modePacked,
 
34
    GLsizei count,
 
35
    DrawElementsType typePacked,
 
36
    const GLvoid *indices,
 
37
    GLsizei instanceCounts,
 
38
    GLint baseVertex,
 
39
    GLuint baseInstance);
 
40
angle::CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState,
 
41
                                                                    bool isCallValid,
 
42
                                                                    PrimitiveMode modePacked,
 
43
                                                                    const GLint *firsts,
 
44
                                                                    const GLsizei *counts,
 
45
                                                                    const GLsizei *instanceCounts,
 
46
                                                                    const GLuint *baseInstances,
 
47
                                                                    GLsizei drawcount);
 
48
angle::CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
 
49
    const State &glState,
 
50
    bool isCallValid,
 
51
    PrimitiveMode modePacked,
 
52
    const GLsizei *counts,
 
53
    DrawElementsType typePacked,
 
54
    const GLvoid *const *indices,
 
55
    const GLsizei *instanceCounts,
 
56
    const GLint *baseVertices,
 
57
    const GLuint *baseInstances,
 
58
    GLsizei drawcount);
 
59
 
 
60
// GL_ANGLE_copy_texture_3d
 
61
angle::CallCapture CaptureCopyTexture3DANGLE(const State &glState,
 
62
                                             bool isCallValid,
 
63
                                             TextureID sourceIdPacked,
 
64
                                             GLint sourceLevel,
 
65
                                             TextureTarget destTargetPacked,
 
66
                                             TextureID destIdPacked,
 
67
                                             GLint destLevel,
 
68
                                             GLint internalFormat,
 
69
                                             GLenum destType,
 
70
                                             GLboolean unpackFlipY,
 
71
                                             GLboolean unpackPremultiplyAlpha,
 
72
                                             GLboolean unpackUnmultiplyAlpha);
 
73
angle::CallCapture CaptureCopySubTexture3DANGLE(const State &glState,
 
74
                                                bool isCallValid,
 
75
                                                TextureID sourceIdPacked,
 
76
                                                GLint sourceLevel,
 
77
                                                TextureTarget destTargetPacked,
 
78
                                                TextureID destIdPacked,
 
79
                                                GLint destLevel,
 
80
                                                GLint xoffset,
 
81
                                                GLint yoffset,
 
82
                                                GLint zoffset,
 
83
                                                GLint x,
 
84
                                                GLint y,
 
85
                                                GLint z,
 
86
                                                GLint width,
 
87
                                                GLint height,
 
88
                                                GLint depth,
 
89
                                                GLboolean unpackFlipY,
 
90
                                                GLboolean unpackPremultiplyAlpha,
 
91
                                                GLboolean unpackUnmultiplyAlpha);
 
92
 
 
93
// GL_ANGLE_framebuffer_blit
 
94
angle::CallCapture CaptureBlitFramebufferANGLE(const State &glState,
 
95
                                               bool isCallValid,
 
96
                                               GLint srcX0,
 
97
                                               GLint srcY0,
 
98
                                               GLint srcX1,
 
99
                                               GLint srcY1,
 
100
                                               GLint dstX0,
 
101
                                               GLint dstY0,
 
102
                                               GLint dstX1,
 
103
                                               GLint dstY1,
 
104
                                               GLbitfield mask,
 
105
                                               GLenum filter);
 
106
 
 
107
// GL_ANGLE_framebuffer_multisample
 
108
angle::CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
 
109
                                                              bool isCallValid,
 
110
                                                              GLenum target,
 
111
                                                              GLsizei samples,
 
112
                                                              GLenum internalformat,
 
113
                                                              GLsizei width,
 
114
                                                              GLsizei height);
 
115
 
 
116
// GL_ANGLE_get_image
 
117
angle::CallCapture CaptureGetTexImageANGLE(const State &glState,
 
118
                                           bool isCallValid,
 
119
                                           TextureTarget targetPacked,
 
120
                                           GLint level,
 
121
                                           GLenum format,
 
122
                                           GLenum type,
 
123
                                           void *pixels);
 
124
angle::CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
 
125
                                                    bool isCallValid,
 
126
                                                    GLenum target,
 
127
                                                    GLenum format,
 
128
                                                    GLenum type,
 
129
                                                    void *pixels);
 
130
 
 
131
// GL_ANGLE_instanced_arrays
 
132
angle::CallCapture CaptureDrawArraysInstancedANGLE(const State &glState,
 
133
                                                   bool isCallValid,
 
134
                                                   PrimitiveMode modePacked,
 
135
                                                   GLint first,
 
136
                                                   GLsizei count,
 
137
                                                   GLsizei primcount);
 
138
angle::CallCapture CaptureDrawElementsInstancedANGLE(const State &glState,
 
139
                                                     bool isCallValid,
 
140
                                                     PrimitiveMode modePacked,
 
141
                                                     GLsizei count,
 
142
                                                     DrawElementsType typePacked,
 
143
                                                     const void *indices,
 
144
                                                     GLsizei primcount);
 
145
angle::CallCapture CaptureVertexAttribDivisorANGLE(const State &glState,
 
146
                                                   bool isCallValid,
 
147
                                                   GLuint index,
 
148
                                                   GLuint divisor);
 
149
 
 
150
// GL_ANGLE_multi_draw
 
151
angle::CallCapture CaptureMultiDrawArraysANGLE(const State &glState,
 
152
                                               bool isCallValid,
 
153
                                               PrimitiveMode modePacked,
 
154
                                               const GLint *firsts,
 
155
                                               const GLsizei *counts,
 
156
                                               GLsizei drawcount);
 
157
angle::CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState,
 
158
                                                        bool isCallValid,
 
159
                                                        PrimitiveMode modePacked,
 
160
                                                        const GLint *firsts,
 
161
                                                        const GLsizei *counts,
 
162
                                                        const GLsizei *instanceCounts,
 
163
                                                        GLsizei drawcount);
 
164
angle::CallCapture CaptureMultiDrawElementsANGLE(const State &glState,
 
165
                                                 bool isCallValid,
 
166
                                                 PrimitiveMode modePacked,
 
167
                                                 const GLsizei *counts,
 
168
                                                 DrawElementsType typePacked,
 
169
                                                 const GLvoid *const *indices,
 
170
                                                 GLsizei drawcount);
 
171
angle::CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
 
172
                                                          bool isCallValid,
 
173
                                                          PrimitiveMode modePacked,
 
174
                                                          const GLsizei *counts,
 
175
                                                          DrawElementsType typePacked,
 
176
                                                          const GLvoid *const *indices,
 
177
                                                          const GLsizei *instanceCounts,
 
178
                                                          GLsizei drawcount);
 
179
 
 
180
// GL_ANGLE_program_binary
 
181
 
 
182
// GL_ANGLE_provoking_vertex
 
183
angle::CallCapture CaptureProvokingVertexANGLE(const State &glState,
 
184
                                               bool isCallValid,
 
185
                                               ProvokingVertexConvention modePacked);
 
186
 
 
187
// GL_ANGLE_request_extension
 
188
angle::CallCapture CaptureRequestExtensionANGLE(const State &glState,
 
189
                                                bool isCallValid,
 
190
                                                const GLchar *name);
 
191
angle::CallCapture CaptureDisableExtensionANGLE(const State &glState,
 
192
                                                bool isCallValid,
 
193
                                                const GLchar *name);
 
194
 
 
195
// GL_ANGLE_robust_client_memory
 
196
angle::CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
 
197
                                                 bool isCallValid,
 
198
                                                 GLenum pname,
 
199
                                                 GLsizei bufSize,
 
200
                                                 GLsizei *length,
 
201
                                                 GLboolean *params);
 
202
angle::CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
 
203
                                                          bool isCallValid,
 
204
                                                          BufferBinding targetPacked,
 
205
                                                          GLenum pname,
 
206
                                                          GLsizei bufSize,
 
207
                                                          GLsizei *length,
 
208
                                                          GLint *params);
 
209
angle::CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
 
210
                                               bool isCallValid,
 
211
                                               GLenum pname,
 
212
                                               GLsizei bufSize,
 
213
                                               GLsizei *length,
 
214
                                               GLfloat *params);
 
215
angle::CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
 
216
                                                                         bool isCallValid,
 
217
                                                                         GLenum target,
 
218
                                                                         GLenum attachment,
 
219
                                                                         GLenum pname,
 
220
                                                                         GLsizei bufSize,
 
221
                                                                         GLsizei *length,
 
222
                                                                         GLint *params);
 
223
angle::CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
 
224
                                                 bool isCallValid,
 
225
                                                 GLenum pname,
 
226
                                                 GLsizei bufSize,
 
227
                                                 GLsizei *length,
 
228
                                                 GLint *data);
 
229
angle::CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
 
230
                                                  bool isCallValid,
 
231
                                                  ShaderProgramID programPacked,
 
232
                                                  GLenum pname,
 
233
                                                  GLsizei bufSize,
 
234
                                                  GLsizei *length,
 
235
                                                  GLint *params);
 
236
angle::CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
 
237
                                                                bool isCallValid,
 
238
                                                                GLenum target,
 
239
                                                                GLenum pname,
 
240
                                                                GLsizei bufSize,
 
241
                                                                GLsizei *length,
 
242
                                                                GLint *params);
 
243
angle::CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
 
244
                                                 bool isCallValid,
 
245
                                                 ShaderProgramID shaderPacked,
 
246
                                                 GLenum pname,
 
247
                                                 GLsizei bufSize,
 
248
                                                 GLsizei *length,
 
249
                                                 GLint *params);
 
250
angle::CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
 
251
                                                       bool isCallValid,
 
252
                                                       TextureType targetPacked,
 
253
                                                       GLenum pname,
 
254
                                                       GLsizei bufSize,
 
255
                                                       GLsizei *length,
 
256
                                                       GLfloat *params);
 
257
angle::CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
 
258
                                                       bool isCallValid,
 
259
                                                       TextureType targetPacked,
 
260
                                                       GLenum pname,
 
261
                                                       GLsizei bufSize,
 
262
                                                       GLsizei *length,
 
263
                                                       GLint *params);
 
264
angle::CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
 
265
                                                  bool isCallValid,
 
266
                                                  ShaderProgramID programPacked,
 
267
                                                  GLint location,
 
268
                                                  GLsizei bufSize,
 
269
                                                  GLsizei *length,
 
270
                                                  GLfloat *params);
 
271
angle::CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
 
272
                                                  bool isCallValid,
 
273
                                                  ShaderProgramID programPacked,
 
274
                                                  GLint location,
 
275
                                                  GLsizei bufSize,
 
276
                                                  GLsizei *length,
 
277
                                                  GLint *params);
 
278
angle::CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
 
279
                                                       bool isCallValid,
 
280
                                                       GLuint index,
 
281
                                                       GLenum pname,
 
282
                                                       GLsizei bufSize,
 
283
                                                       GLsizei *length,
 
284
                                                       GLfloat *params);
 
285
angle::CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
 
286
                                                       bool isCallValid,
 
287
                                                       GLuint index,
 
288
                                                       GLenum pname,
 
289
                                                       GLsizei bufSize,
 
290
                                                       GLsizei *length,
 
291
                                                       GLint *params);
 
292
angle::CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
 
293
                                                             bool isCallValid,
 
294
                                                             GLuint index,
 
295
                                                             GLenum pname,
 
296
                                                             GLsizei bufSize,
 
297
                                                             GLsizei *length,
 
298
                                                             void **pointer);
 
299
angle::CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
 
300
                                                bool isCallValid,
 
301
                                                GLint x,
 
302
                                                GLint y,
 
303
                                                GLsizei width,
 
304
                                                GLsizei height,
 
305
                                                GLenum format,
 
306
                                                GLenum type,
 
307
                                                GLsizei bufSize,
 
308
                                                GLsizei *length,
 
309
                                                GLsizei *columns,
 
310
                                                GLsizei *rows,
 
311
                                                void *pixels);
 
312
angle::CallCapture CaptureTexImage2DRobustANGLE(const State &glState,
 
313
                                                bool isCallValid,
 
314
                                                TextureTarget targetPacked,
 
315
                                                GLint level,
 
316
                                                GLint internalformat,
 
317
                                                GLsizei width,
 
318
                                                GLsizei height,
 
319
                                                GLint border,
 
320
                                                GLenum format,
 
321
                                                GLenum type,
 
322
                                                GLsizei bufSize,
 
323
                                                const void *pixels);
 
324
angle::CallCapture CaptureTexParameterfvRobustANGLE(const State &glState,
 
325
                                                    bool isCallValid,
 
326
                                                    TextureType targetPacked,
 
327
                                                    GLenum pname,
 
328
                                                    GLsizei bufSize,
 
329
                                                    const GLfloat *params);
 
330
angle::CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
 
331
                                                    bool isCallValid,
 
332
                                                    TextureType targetPacked,
 
333
                                                    GLenum pname,
 
334
                                                    GLsizei bufSize,
 
335
                                                    const GLint *params);
 
336
angle::CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
 
337
                                                   bool isCallValid,
 
338
                                                   TextureTarget targetPacked,
 
339
                                                   GLint level,
 
340
                                                   GLint xoffset,
 
341
                                                   GLint yoffset,
 
342
                                                   GLsizei width,
 
343
                                                   GLsizei height,
 
344
                                                   GLenum format,
 
345
                                                   GLenum type,
 
346
                                                   GLsizei bufSize,
 
347
                                                   const void *pixels);
 
348
angle::CallCapture CaptureTexImage3DRobustANGLE(const State &glState,
 
349
                                                bool isCallValid,
 
350
                                                TextureTarget targetPacked,
 
351
                                                GLint level,
 
352
                                                GLint internalformat,
 
353
                                                GLsizei width,
 
354
                                                GLsizei height,
 
355
                                                GLsizei depth,
 
356
                                                GLint border,
 
357
                                                GLenum format,
 
358
                                                GLenum type,
 
359
                                                GLsizei bufSize,
 
360
                                                const void *pixels);
 
361
angle::CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState,
 
362
                                                   bool isCallValid,
 
363
                                                   TextureTarget targetPacked,
 
364
                                                   GLint level,
 
365
                                                   GLint xoffset,
 
366
                                                   GLint yoffset,
 
367
                                                   GLint zoffset,
 
368
                                                   GLsizei width,
 
369
                                                   GLsizei height,
 
370
                                                   GLsizei depth,
 
371
                                                   GLenum format,
 
372
                                                   GLenum type,
 
373
                                                   GLsizei bufSize,
 
374
                                                   const void *pixels);
 
375
angle::CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState,
 
376
                                                          bool isCallValid,
 
377
                                                          TextureTarget targetPacked,
 
378
                                                          GLint level,
 
379
                                                          GLenum internalformat,
 
380
                                                          GLsizei width,
 
381
                                                          GLsizei height,
 
382
                                                          GLint border,
 
383
                                                          GLsizei imageSize,
 
384
                                                          GLsizei dataSize,
 
385
                                                          const GLvoid *data);
 
386
angle::CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState,
 
387
                                                             bool isCallValid,
 
388
                                                             TextureTarget targetPacked,
 
389
                                                             GLint level,
 
390
                                                             GLsizei xoffset,
 
391
                                                             GLsizei yoffset,
 
392
                                                             GLsizei width,
 
393
                                                             GLsizei height,
 
394
                                                             GLenum format,
 
395
                                                             GLsizei imageSize,
 
396
                                                             GLsizei dataSize,
 
397
                                                             const GLvoid *data);
 
398
angle::CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState,
 
399
                                                          bool isCallValid,
 
400
                                                          TextureTarget targetPacked,
 
401
                                                          GLint level,
 
402
                                                          GLenum internalformat,
 
403
                                                          GLsizei width,
 
404
                                                          GLsizei height,
 
405
                                                          GLsizei depth,
 
406
                                                          GLint border,
 
407
                                                          GLsizei imageSize,
 
408
                                                          GLsizei dataSize,
 
409
                                                          const GLvoid *data);
 
410
angle::CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState,
 
411
                                                             bool isCallValid,
 
412
                                                             TextureTarget targetPacked,
 
413
                                                             GLint level,
 
414
                                                             GLint xoffset,
 
415
                                                             GLint yoffset,
 
416
                                                             GLint zoffset,
 
417
                                                             GLsizei width,
 
418
                                                             GLsizei height,
 
419
                                                             GLsizei depth,
 
420
                                                             GLenum format,
 
421
                                                             GLsizei imageSize,
 
422
                                                             GLsizei dataSize,
 
423
                                                             const GLvoid *data);
 
424
angle::CallCapture CaptureGetQueryivRobustANGLE(const State &glState,
 
425
                                                bool isCallValid,
 
426
                                                QueryType targetPacked,
 
427
                                                GLenum pname,
 
428
                                                GLsizei bufSize,
 
429
                                                GLsizei *length,
 
430
                                                GLint *params);
 
431
angle::CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
 
432
                                                       bool isCallValid,
 
433
                                                       QueryID idPacked,
 
434
                                                       GLenum pname,
 
435
                                                       GLsizei bufSize,
 
436
                                                       GLsizei *length,
 
437
                                                       GLuint *params);
 
438
angle::CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
 
439
                                                       bool isCallValid,
 
440
                                                       BufferBinding targetPacked,
 
441
                                                       GLenum pname,
 
442
                                                       GLsizei bufSize,
 
443
                                                       GLsizei *length,
 
444
                                                       void **params);
 
445
angle::CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
 
446
                                                   bool isCallValid,
 
447
                                                   GLenum target,
 
448
                                                   GLuint index,
 
449
                                                   GLsizei bufSize,
 
450
                                                   GLsizei *length,
 
451
                                                   GLint *data);
 
452
angle::CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
 
453
                                                         bool isCallValid,
 
454
                                                         GLenum target,
 
455
                                                         GLenum internalformat,
 
456
                                                         GLenum pname,
 
457
                                                         GLsizei bufSize,
 
458
                                                         GLsizei *length,
 
459
                                                         GLint *params);
 
460
angle::CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
 
461
                                                        bool isCallValid,
 
462
                                                        GLuint index,
 
463
                                                        GLenum pname,
 
464
                                                        GLsizei bufSize,
 
465
                                                        GLsizei *length,
 
466
                                                        GLint *params);
 
467
angle::CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
 
468
                                                         bool isCallValid,
 
469
                                                         GLuint index,
 
470
                                                         GLenum pname,
 
471
                                                         GLsizei bufSize,
 
472
                                                         GLsizei *length,
 
473
                                                         GLuint *params);
 
474
angle::CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
 
475
                                                   bool isCallValid,
 
476
                                                   ShaderProgramID programPacked,
 
477
                                                   GLint location,
 
478
                                                   GLsizei bufSize,
 
479
                                                   GLsizei *length,
 
480
                                                   GLuint *params);
 
481
angle::CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState,
 
482
                                                             bool isCallValid,
 
483
                                                             ShaderProgramID programPacked,
 
484
                                                             GLuint uniformBlockIndex,
 
485
                                                             GLenum pname,
 
486
                                                             GLsizei bufSize,
 
487
                                                             GLsizei *length,
 
488
                                                             GLint *params);
 
489
angle::CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
 
490
                                                   bool isCallValid,
 
491
                                                   GLenum pname,
 
492
                                                   GLsizei bufSize,
 
493
                                                   GLsizei *length,
 
494
                                                   GLint64 *data);
 
495
angle::CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
 
496
                                                     bool isCallValid,
 
497
                                                     GLenum target,
 
498
                                                     GLuint index,
 
499
                                                     GLsizei bufSize,
 
500
                                                     GLsizei *length,
 
501
                                                     GLint64 *data);
 
502
angle::CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
 
503
                                                            bool isCallValid,
 
504
                                                            BufferBinding targetPacked,
 
505
                                                            GLenum pname,
 
506
                                                            GLsizei bufSize,
 
507
                                                            GLsizei *length,
 
508
                                                            GLint64 *params);
 
509
angle::CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
 
510
                                                        bool isCallValid,
 
511
                                                        SamplerID samplerPacked,
 
512
                                                        GLuint pname,
 
513
                                                        GLsizei bufSize,
 
514
                                                        const GLint *param);
 
515
angle::CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
 
516
                                                        bool isCallValid,
 
517
                                                        SamplerID samplerPacked,
 
518
                                                        GLenum pname,
 
519
                                                        GLsizei bufSize,
 
520
                                                        const GLfloat *param);
 
521
angle::CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
 
522
                                                           bool isCallValid,
 
523
                                                           SamplerID samplerPacked,
 
524
                                                           GLenum pname,
 
525
                                                           GLsizei bufSize,
 
526
                                                           GLsizei *length,
 
527
                                                           GLint *params);
 
528
angle::CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
 
529
                                                           bool isCallValid,
 
530
                                                           SamplerID samplerPacked,
 
531
                                                           GLenum pname,
 
532
                                                           GLsizei bufSize,
 
533
                                                           GLsizei *length,
 
534
                                                           GLfloat *params);
 
535
angle::CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
 
536
                                                               bool isCallValid,
 
537
                                                               GLenum target,
 
538
                                                               GLenum pname,
 
539
                                                               GLsizei bufSize,
 
540
                                                               GLsizei *length,
 
541
                                                               GLint *params);
 
542
angle::CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
 
543
                                                           bool isCallValid,
 
544
                                                           ShaderProgramID programPacked,
 
545
                                                           GLenum programInterface,
 
546
                                                           GLenum pname,
 
547
                                                           GLsizei bufSize,
 
548
                                                           GLsizei *length,
 
549
                                                           GLint *params);
 
550
angle::CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
 
551
                                                   bool isCallValid,
 
552
                                                   GLenum target,
 
553
                                                   GLuint index,
 
554
                                                   GLsizei bufSize,
 
555
                                                   GLsizei *length,
 
556
                                                   GLboolean *data);
 
557
angle::CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
 
558
                                                      bool isCallValid,
 
559
                                                      GLenum pname,
 
560
                                                      GLuint index,
 
561
                                                      GLsizei bufSize,
 
562
                                                      GLsizei *length,
 
563
                                                      GLfloat *val);
 
564
angle::CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
 
565
                                                            bool isCallValid,
 
566
                                                            TextureTarget targetPacked,
 
567
                                                            GLint level,
 
568
                                                            GLenum pname,
 
569
                                                            GLsizei bufSize,
 
570
                                                            GLsizei *length,
 
571
                                                            GLint *params);
 
572
angle::CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
 
573
                                                            bool isCallValid,
 
574
                                                            TextureTarget targetPacked,
 
575
                                                            GLint level,
 
576
                                                            GLenum pname,
 
577
                                                            GLsizei bufSize,
 
578
                                                            GLsizei *length,
 
579
                                                            GLfloat *params);
 
580
angle::CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
 
581
                                                            bool isCallValid,
 
582
                                                            GLenum pname,
 
583
                                                            GLsizei bufSize,
 
584
                                                            GLsizei *length,
 
585
                                                            void **params);
 
586
angle::CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
 
587
                                                 bool isCallValid,
 
588
                                                 GLint x,
 
589
                                                 GLint y,
 
590
                                                 GLsizei width,
 
591
                                                 GLsizei height,
 
592
                                                 GLenum format,
 
593
                                                 GLenum type,
 
594
                                                 GLsizei bufSize,
 
595
                                                 GLsizei *length,
 
596
                                                 GLsizei *columns,
 
597
                                                 GLsizei *rows,
 
598
                                                 void *data);
 
599
angle::CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
 
600
                                                   bool isCallValid,
 
601
                                                   ShaderProgramID programPacked,
 
602
                                                   GLint location,
 
603
                                                   GLsizei bufSize,
 
604
                                                   GLsizei *length,
 
605
                                                   GLfloat *params);
 
606
angle::CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
 
607
                                                   bool isCallValid,
 
608
                                                   ShaderProgramID programPacked,
 
609
                                                   GLint location,
 
610
                                                   GLsizei bufSize,
 
611
                                                   GLsizei *length,
 
612
                                                   GLint *params);
 
613
angle::CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
 
614
                                                    bool isCallValid,
 
615
                                                    ShaderProgramID programPacked,
 
616
                                                    GLint location,
 
617
                                                    GLsizei bufSize,
 
618
                                                    GLsizei *length,
 
619
                                                    GLuint *params);
 
620
angle::CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
 
621
                                                     bool isCallValid,
 
622
                                                     TextureType targetPacked,
 
623
                                                     GLenum pname,
 
624
                                                     GLsizei bufSize,
 
625
                                                     const GLint *params);
 
626
angle::CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
 
627
                                                      bool isCallValid,
 
628
                                                      TextureType targetPacked,
 
629
                                                      GLenum pname,
 
630
                                                      GLsizei bufSize,
 
631
                                                      const GLuint *params);
 
632
angle::CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
 
633
                                                        bool isCallValid,
 
634
                                                        TextureType targetPacked,
 
635
                                                        GLenum pname,
 
636
                                                        GLsizei bufSize,
 
637
                                                        GLsizei *length,
 
638
                                                        GLint *params);
 
639
angle::CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
 
640
                                                         bool isCallValid,
 
641
                                                         TextureType targetPacked,
 
642
                                                         GLenum pname,
 
643
                                                         GLsizei bufSize,
 
644
                                                         GLsizei *length,
 
645
                                                         GLuint *params);
 
646
angle::CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
 
647
                                                         bool isCallValid,
 
648
                                                         SamplerID samplerPacked,
 
649
                                                         GLenum pname,
 
650
                                                         GLsizei bufSize,
 
651
                                                         const GLint *param);
 
652
angle::CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
 
653
                                                          bool isCallValid,
 
654
                                                          SamplerID samplerPacked,
 
655
                                                          GLenum pname,
 
656
                                                          GLsizei bufSize,
 
657
                                                          const GLuint *param);
 
658
angle::CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
 
659
                                                            bool isCallValid,
 
660
                                                            SamplerID samplerPacked,
 
661
                                                            GLenum pname,
 
662
                                                            GLsizei bufSize,
 
663
                                                            GLsizei *length,
 
664
                                                            GLint *params);
 
665
angle::CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
 
666
                                                             bool isCallValid,
 
667
                                                             SamplerID samplerPacked,
 
668
                                                             GLenum pname,
 
669
                                                             GLsizei bufSize,
 
670
                                                             GLsizei *length,
 
671
                                                             GLuint *params);
 
672
angle::CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
 
673
                                                      bool isCallValid,
 
674
                                                      QueryID idPacked,
 
675
                                                      GLenum pname,
 
676
                                                      GLsizei bufSize,
 
677
                                                      GLsizei *length,
 
678
                                                      GLint *params);
 
679
angle::CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
 
680
                                                        bool isCallValid,
 
681
                                                        QueryID idPacked,
 
682
                                                        GLenum pname,
 
683
                                                        GLsizei bufSize,
 
684
                                                        GLsizei *length,
 
685
                                                        GLint64 *params);
 
686
angle::CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
 
687
                                                         bool isCallValid,
 
688
                                                         QueryID idPacked,
 
689
                                                         GLenum pname,
 
690
                                                         GLsizei bufSize,
 
691
                                                         GLsizei *length,
 
692
                                                         GLuint64 *params);
 
693
 
 
694
// GL_ANGLE_texture_external_update
 
695
angle::CallCapture CaptureTexImage2DExternalANGLE(const State &glState,
 
696
                                                  bool isCallValid,
 
697
                                                  TextureTarget targetPacked,
 
698
                                                  GLint level,
 
699
                                                  GLint internalformat,
 
700
                                                  GLsizei width,
 
701
                                                  GLsizei height,
 
702
                                                  GLint border,
 
703
                                                  GLenum format,
 
704
                                                  GLenum type);
 
705
angle::CallCapture CaptureInvalidateTextureANGLE(const State &glState,
 
706
                                                 bool isCallValid,
 
707
                                                 TextureType targetPacked);
 
708
 
 
709
// GL_ANGLE_texture_multisample
 
710
angle::CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
 
711
                                                       bool isCallValid,
 
712
                                                       TextureType targetPacked,
 
713
                                                       GLsizei samples,
 
714
                                                       GLenum internalformat,
 
715
                                                       GLsizei width,
 
716
                                                       GLsizei height,
 
717
                                                       GLboolean fixedsamplelocations);
 
718
angle::CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
 
719
                                                      bool isCallValid,
 
720
                                                      TextureTarget targetPacked,
 
721
                                                      GLint level,
 
722
                                                      GLenum pname,
 
723
                                                      GLint *params);
 
724
angle::CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
 
725
                                                      bool isCallValid,
 
726
                                                      TextureTarget targetPacked,
 
727
                                                      GLint level,
 
728
                                                      GLenum pname,
 
729
                                                      GLfloat *params);
 
730
angle::CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
 
731
                                                bool isCallValid,
 
732
                                                GLenum pname,
 
733
                                                GLuint index,
 
734
                                                GLfloat *val);
 
735
angle::CallCapture CaptureSampleMaskiANGLE(const State &glState,
 
736
                                           bool isCallValid,
 
737
                                           GLuint maskNumber,
 
738
                                           GLbitfield mask);
 
739
 
 
740
// GL_ANGLE_translated_shader_source
 
741
angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
 
742
                                                         bool isCallValid,
 
743
                                                         ShaderProgramID shaderPacked,
 
744
                                                         GLsizei bufsize,
 
745
                                                         GLsizei *length,
 
746
                                                         GLchar *source);
 
747
 
 
748
// GL_CHROMIUM_bind_uniform_location
 
749
angle::CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
 
750
                                                      bool isCallValid,
 
751
                                                      ShaderProgramID programPacked,
 
752
                                                      GLint location,
 
753
                                                      const GLchar *name);
 
754
 
 
755
// GL_CHROMIUM_copy_compressed_texture
 
756
angle::CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
 
757
                                                        bool isCallValid,
 
758
                                                        TextureID sourceIdPacked,
 
759
                                                        TextureID destIdPacked);
 
760
 
 
761
// GL_CHROMIUM_copy_texture
 
762
angle::CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
 
763
                                              bool isCallValid,
 
764
                                              TextureID sourceIdPacked,
 
765
                                              GLint sourceLevel,
 
766
                                              TextureTarget destTargetPacked,
 
767
                                              TextureID destIdPacked,
 
768
                                              GLint destLevel,
 
769
                                              GLint internalFormat,
 
770
                                              GLenum destType,
 
771
                                              GLboolean unpackFlipY,
 
772
                                              GLboolean unpackPremultiplyAlpha,
 
773
                                              GLboolean unpackUnmultiplyAlpha);
 
774
angle::CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
 
775
                                                 bool isCallValid,
 
776
                                                 TextureID sourceIdPacked,
 
777
                                                 GLint sourceLevel,
 
778
                                                 TextureTarget destTargetPacked,
 
779
                                                 TextureID destIdPacked,
 
780
                                                 GLint destLevel,
 
781
                                                 GLint xoffset,
 
782
                                                 GLint yoffset,
 
783
                                                 GLint x,
 
784
                                                 GLint y,
 
785
                                                 GLint width,
 
786
                                                 GLint height,
 
787
                                                 GLboolean unpackFlipY,
 
788
                                                 GLboolean unpackPremultiplyAlpha,
 
789
                                                 GLboolean unpackUnmultiplyAlpha);
 
790
 
 
791
// GL_CHROMIUM_framebuffer_mixed_samples
 
792
angle::CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
 
793
                                                     bool isCallValid,
 
794
                                                     GLenum components);
 
795
angle::CallCapture CaptureMatrixLoadfCHROMIUM(const State &glState,
 
796
                                              bool isCallValid,
 
797
                                              GLenum matrixMode,
 
798
                                              const GLfloat *matrix);
 
799
angle::CallCapture CaptureMatrixLoadIdentityCHROMIUM(const State &glState,
 
800
                                                     bool isCallValid,
 
801
                                                     GLenum matrixMode);
 
802
 
 
803
// GL_CHROMIUM_lose_context
 
804
angle::CallCapture CaptureLoseContextCHROMIUM(const State &glState,
 
805
                                              bool isCallValid,
 
806
                                              GraphicsResetStatus currentPacked,
 
807
                                              GraphicsResetStatus otherPacked);
 
808
 
 
809
// GL_CHROMIUM_path_rendering
 
810
angle::CallCapture CaptureGenPathsCHROMIUM(const State &glState,
 
811
                                           bool isCallValid,
 
812
                                           GLsizei range,
 
813
                                           GLuint returnValue);
 
814
angle::CallCapture CaptureDeletePathsCHROMIUM(const State &glState,
 
815
                                              bool isCallValid,
 
816
                                              PathID firstPacked,
 
817
                                              GLsizei range);
 
818
angle::CallCapture CaptureIsPathCHROMIUM(const State &glState,
 
819
                                         bool isCallValid,
 
820
                                         PathID pathPacked,
 
821
                                         GLboolean returnValue);
 
822
angle::CallCapture CapturePathCommandsCHROMIUM(const State &glState,
 
823
                                               bool isCallValid,
 
824
                                               PathID pathPacked,
 
825
                                               GLsizei numCommands,
 
826
                                               const GLubyte *commands,
 
827
                                               GLsizei numCoords,
 
828
                                               GLenum coordType,
 
829
                                               const void *coords);
 
830
angle::CallCapture CapturePathParameterfCHROMIUM(const State &glState,
 
831
                                                 bool isCallValid,
 
832
                                                 PathID pathPacked,
 
833
                                                 GLenum pname,
 
834
                                                 GLfloat value);
 
835
angle::CallCapture CapturePathParameteriCHROMIUM(const State &glState,
 
836
                                                 bool isCallValid,
 
837
                                                 PathID pathPacked,
 
838
                                                 GLenum pname,
 
839
                                                 GLint value);
 
840
angle::CallCapture CaptureGetPathParameterfvCHROMIUM(const State &glState,
 
841
                                                     bool isCallValid,
 
842
                                                     PathID pathPacked,
 
843
                                                     GLenum pname,
 
844
                                                     GLfloat *value);
 
845
angle::CallCapture CaptureGetPathParameterivCHROMIUM(const State &glState,
 
846
                                                     bool isCallValid,
 
847
                                                     PathID pathPacked,
 
848
                                                     GLenum pname,
 
849
                                                     GLint *value);
 
850
angle::CallCapture CapturePathStencilFuncCHROMIUM(const State &glState,
 
851
                                                  bool isCallValid,
 
852
                                                  GLenum func,
 
853
                                                  GLint ref,
 
854
                                                  GLuint mask);
 
855
angle::CallCapture CaptureStencilFillPathCHROMIUM(const State &glState,
 
856
                                                  bool isCallValid,
 
857
                                                  PathID pathPacked,
 
858
                                                  GLenum fillMode,
 
859
                                                  GLuint mask);
 
860
angle::CallCapture CaptureStencilStrokePathCHROMIUM(const State &glState,
 
861
                                                    bool isCallValid,
 
862
                                                    PathID pathPacked,
 
863
                                                    GLint reference,
 
864
                                                    GLuint mask);
 
865
angle::CallCapture CaptureCoverFillPathCHROMIUM(const State &glState,
 
866
                                                bool isCallValid,
 
867
                                                PathID pathPacked,
 
868
                                                GLenum coverMode);
 
869
angle::CallCapture CaptureCoverStrokePathCHROMIUM(const State &glState,
 
870
                                                  bool isCallValid,
 
871
                                                  PathID pathPacked,
 
872
                                                  GLenum coverMode);
 
873
angle::CallCapture CaptureStencilThenCoverFillPathCHROMIUM(const State &glState,
 
874
                                                           bool isCallValid,
 
875
                                                           PathID pathPacked,
 
876
                                                           GLenum fillMode,
 
877
                                                           GLuint mask,
 
878
                                                           GLenum coverMode);
 
879
angle::CallCapture CaptureStencilThenCoverStrokePathCHROMIUM(const State &glState,
 
880
                                                             bool isCallValid,
 
881
                                                             PathID pathPacked,
 
882
                                                             GLint reference,
 
883
                                                             GLuint mask,
 
884
                                                             GLenum coverMode);
 
885
angle::CallCapture CaptureCoverFillPathInstancedCHROMIUM(const State &glState,
 
886
                                                         bool isCallValid,
 
887
                                                         GLsizei numPath,
 
888
                                                         GLenum pathNameType,
 
889
                                                         const void *paths,
 
890
                                                         PathID pathBasePacked,
 
891
                                                         GLenum coverMode,
 
892
                                                         GLenum transformType,
 
893
                                                         const GLfloat *transformValues);
 
894
angle::CallCapture CaptureCoverStrokePathInstancedCHROMIUM(const State &glState,
 
895
                                                           bool isCallValid,
 
896
                                                           GLsizei numPath,
 
897
                                                           GLenum pathNameType,
 
898
                                                           const void *paths,
 
899
                                                           PathID pathBasePacked,
 
900
                                                           GLenum coverMode,
 
901
                                                           GLenum transformType,
 
902
                                                           const GLfloat *transformValues);
 
903
angle::CallCapture CaptureStencilStrokePathInstancedCHROMIUM(const State &glState,
 
904
                                                             bool isCallValid,
 
905
                                                             GLsizei numPath,
 
906
                                                             GLenum pathNameType,
 
907
                                                             const void *paths,
 
908
                                                             PathID pathBasePacked,
 
909
                                                             GLint reference,
 
910
                                                             GLuint mask,
 
911
                                                             GLenum transformType,
 
912
                                                             const GLfloat *transformValues);
 
913
angle::CallCapture CaptureStencilFillPathInstancedCHROMIUM(const State &glState,
 
914
                                                           bool isCallValid,
 
915
                                                           GLsizei numPaths,
 
916
                                                           GLenum pathNameType,
 
917
                                                           const void *paths,
 
918
                                                           PathID pathBasePacked,
 
919
                                                           GLenum fillMode,
 
920
                                                           GLuint mask,
 
921
                                                           GLenum transformType,
 
922
                                                           const GLfloat *transformValues);
 
923
angle::CallCapture CaptureStencilThenCoverFillPathInstancedCHROMIUM(const State &glState,
 
924
                                                                    bool isCallValid,
 
925
                                                                    GLsizei numPaths,
 
926
                                                                    GLenum pathNameType,
 
927
                                                                    const void *paths,
 
928
                                                                    PathID pathBasePacked,
 
929
                                                                    GLenum fillMode,
 
930
                                                                    GLuint mask,
 
931
                                                                    GLenum coverMode,
 
932
                                                                    GLenum transformType,
 
933
                                                                    const GLfloat *transformValues);
 
934
angle::CallCapture CaptureStencilThenCoverStrokePathInstancedCHROMIUM(
 
935
    const State &glState,
 
936
    bool isCallValid,
 
937
    GLsizei numPaths,
 
938
    GLenum pathNameType,
 
939
    const void *paths,
 
940
    PathID pathBasePacked,
 
941
    GLint reference,
 
942
    GLuint mask,
 
943
    GLenum coverMode,
 
944
    GLenum transformType,
 
945
    const GLfloat *transformValues);
 
946
angle::CallCapture CaptureBindFragmentInputLocationCHROMIUM(const State &glState,
 
947
                                                            bool isCallValid,
 
948
                                                            ShaderProgramID programsPacked,
 
949
                                                            GLint location,
 
950
                                                            const GLchar *name);
 
951
angle::CallCapture CaptureProgramPathFragmentInputGenCHROMIUM(const State &glState,
 
952
                                                              bool isCallValid,
 
953
                                                              ShaderProgramID programPacked,
 
954
                                                              GLint location,
 
955
                                                              GLenum genMode,
 
956
                                                              GLint components,
 
957
                                                              const GLfloat *coeffs);
 
958
 
 
959
// GL_EXT_blend_func_extended
 
960
angle::CallCapture CaptureBindFragDataLocationEXT(const State &glState,
 
961
                                                  bool isCallValid,
 
962
                                                  ShaderProgramID programPacked,
 
963
                                                  GLuint color,
 
964
                                                  const GLchar *name);
 
965
angle::CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
 
966
                                                         bool isCallValid,
 
967
                                                         ShaderProgramID programPacked,
 
968
                                                         GLuint colorNumber,
 
969
                                                         GLuint index,
 
970
                                                         const GLchar *name);
 
971
angle::CallCapture CaptureGetFragDataIndexEXT(const State &glState,
 
972
                                              bool isCallValid,
 
973
                                              ShaderProgramID programPacked,
 
974
                                              const GLchar *name,
 
975
                                              GLint returnValue);
 
976
angle::CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
 
977
                                                             bool isCallValid,
 
978
                                                             ShaderProgramID programPacked,
 
979
                                                             GLenum programInterface,
 
980
                                                             const GLchar *name,
 
981
                                                             GLint returnValue);
 
982
 
 
983
// GL_EXT_debug_marker
 
984
angle::CallCapture CaptureInsertEventMarkerEXT(const State &glState,
 
985
                                               bool isCallValid,
 
986
                                               GLsizei length,
 
987
                                               const GLchar *marker);
 
988
angle::CallCapture CapturePopGroupMarkerEXT(const State &glState, bool isCallValid);
 
989
angle::CallCapture CapturePushGroupMarkerEXT(const State &glState,
 
990
                                             bool isCallValid,
 
991
                                             GLsizei length,
 
992
                                             const GLchar *marker);
 
993
 
 
994
// GL_EXT_discard_framebuffer
 
995
angle::CallCapture CaptureDiscardFramebufferEXT(const State &glState,
 
996
                                                bool isCallValid,
 
997
                                                GLenum target,
 
998
                                                GLsizei numAttachments,
 
999
                                                const GLenum *attachments);
 
1000
 
 
1001
// GL_EXT_disjoint_timer_query
 
1002
angle::CallCapture CaptureBeginQueryEXT(const State &glState,
 
1003
                                        bool isCallValid,
 
1004
                                        QueryType targetPacked,
 
1005
                                        QueryID idPacked);
 
1006
angle::CallCapture CaptureDeleteQueriesEXT(const State &glState,
 
1007
                                           bool isCallValid,
 
1008
                                           GLsizei n,
 
1009
                                           const QueryID *idsPacked);
 
1010
angle::CallCapture CaptureEndQueryEXT(const State &glState,
 
1011
                                      bool isCallValid,
 
1012
                                      QueryType targetPacked);
 
1013
angle::CallCapture CaptureGenQueriesEXT(const State &glState,
 
1014
                                        bool isCallValid,
 
1015
                                        GLsizei n,
 
1016
                                        QueryID *idsPacked);
 
1017
angle::CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
 
1018
                                                bool isCallValid,
 
1019
                                                QueryID idPacked,
 
1020
                                                GLenum pname,
 
1021
                                                GLint64 *params);
 
1022
angle::CallCapture CaptureGetQueryObjectivEXT(const State &glState,
 
1023
                                              bool isCallValid,
 
1024
                                              QueryID idPacked,
 
1025
                                              GLenum pname,
 
1026
                                              GLint *params);
 
1027
angle::CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
 
1028
                                                 bool isCallValid,
 
1029
                                                 QueryID idPacked,
 
1030
                                                 GLenum pname,
 
1031
                                                 GLuint64 *params);
 
1032
angle::CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
 
1033
                                               bool isCallValid,
 
1034
                                               QueryID idPacked,
 
1035
                                               GLenum pname,
 
1036
                                               GLuint *params);
 
1037
angle::CallCapture CaptureGetQueryivEXT(const State &glState,
 
1038
                                        bool isCallValid,
 
1039
                                        QueryType targetPacked,
 
1040
                                        GLenum pname,
 
1041
                                        GLint *params);
 
1042
angle::CallCapture CaptureIsQueryEXT(const State &glState,
 
1043
                                     bool isCallValid,
 
1044
                                     QueryID idPacked,
 
1045
                                     GLboolean returnValue);
 
1046
angle::CallCapture CaptureQueryCounterEXT(const State &glState,
 
1047
                                          bool isCallValid,
 
1048
                                          QueryID idPacked,
 
1049
                                          QueryType targetPacked);
 
1050
 
 
1051
// GL_EXT_draw_buffers
 
1052
angle::CallCapture CaptureDrawBuffersEXT(const State &glState,
 
1053
                                         bool isCallValid,
 
1054
                                         GLsizei n,
 
1055
                                         const GLenum *bufs);
 
1056
 
 
1057
// GL_EXT_draw_elements_base_vertex
 
1058
angle::CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
 
1059
                                                    bool isCallValid,
 
1060
                                                    PrimitiveMode modePacked,
 
1061
                                                    GLsizei count,
 
1062
                                                    DrawElementsType typePacked,
 
1063
                                                    const void *indices,
 
1064
                                                    GLint basevertex);
 
1065
angle::CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
 
1066
                                                             bool isCallValid,
 
1067
                                                             PrimitiveMode modePacked,
 
1068
                                                             GLsizei count,
 
1069
                                                             DrawElementsType typePacked,
 
1070
                                                             const void *indices,
 
1071
                                                             GLsizei instancecount,
 
1072
                                                             GLint basevertex);
 
1073
angle::CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
 
1074
                                                         bool isCallValid,
 
1075
                                                         PrimitiveMode modePacked,
 
1076
                                                         GLuint start,
 
1077
                                                         GLuint end,
 
1078
                                                         GLsizei count,
 
1079
                                                         DrawElementsType typePacked,
 
1080
                                                         const void *indices,
 
1081
                                                         GLint basevertex);
 
1082
angle::CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
 
1083
                                                         bool isCallValid,
 
1084
                                                         PrimitiveMode modePacked,
 
1085
                                                         const GLsizei *count,
 
1086
                                                         DrawElementsType typePacked,
 
1087
                                                         const void *const *indices,
 
1088
                                                         GLsizei primcount,
 
1089
                                                         const GLint *basevertex);
 
1090
 
 
1091
// GL_EXT_geometry_shader
 
1092
angle::CallCapture CaptureFramebufferTextureEXT(const State &glState,
 
1093
                                                bool isCallValid,
 
1094
                                                GLenum target,
 
1095
                                                GLenum attachment,
 
1096
                                                TextureID texturePacked,
 
1097
                                                GLint level);
 
1098
 
 
1099
// GL_EXT_instanced_arrays
 
1100
angle::CallCapture CaptureDrawArraysInstancedEXT(const State &glState,
 
1101
                                                 bool isCallValid,
 
1102
                                                 PrimitiveMode modePacked,
 
1103
                                                 GLint start,
 
1104
                                                 GLsizei count,
 
1105
                                                 GLsizei primcount);
 
1106
angle::CallCapture CaptureDrawElementsInstancedEXT(const State &glState,
 
1107
                                                   bool isCallValid,
 
1108
                                                   PrimitiveMode modePacked,
 
1109
                                                   GLsizei count,
 
1110
                                                   DrawElementsType typePacked,
 
1111
                                                   const void *indices,
 
1112
                                                   GLsizei primcount);
 
1113
angle::CallCapture CaptureVertexAttribDivisorEXT(const State &glState,
 
1114
                                                 bool isCallValid,
 
1115
                                                 GLuint index,
 
1116
                                                 GLuint divisor);
 
1117
 
 
1118
// GL_EXT_map_buffer_range
 
1119
angle::CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState,
 
1120
                                                    bool isCallValid,
 
1121
                                                    BufferBinding targetPacked,
 
1122
                                                    GLintptr offset,
 
1123
                                                    GLsizeiptr length);
 
1124
angle::CallCapture CaptureMapBufferRangeEXT(const State &glState,
 
1125
                                            bool isCallValid,
 
1126
                                            BufferBinding targetPacked,
 
1127
                                            GLintptr offset,
 
1128
                                            GLsizeiptr length,
 
1129
                                            GLbitfield access,
 
1130
                                            void *returnValue);
 
1131
 
 
1132
// GL_EXT_memory_object
 
1133
angle::CallCapture CaptureBufferStorageMemEXT(const State &glState,
 
1134
                                              bool isCallValid,
 
1135
                                              TextureType targetPacked,
 
1136
                                              GLsizeiptr size,
 
1137
                                              MemoryObjectID memoryPacked,
 
1138
                                              GLuint64 offset);
 
1139
angle::CallCapture CaptureCreateMemoryObjectsEXT(const State &glState,
 
1140
                                                 bool isCallValid,
 
1141
                                                 GLsizei n,
 
1142
                                                 MemoryObjectID *memoryObjectsPacked);
 
1143
angle::CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState,
 
1144
                                                 bool isCallValid,
 
1145
                                                 GLsizei n,
 
1146
                                                 const MemoryObjectID *memoryObjectsPacked);
 
1147
angle::CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState,
 
1148
                                                        bool isCallValid,
 
1149
                                                        MemoryObjectID memoryObjectPacked,
 
1150
                                                        GLenum pname,
 
1151
                                                        GLint *params);
 
1152
angle::CallCapture CaptureGetUnsignedBytevEXT(const State &glState,
 
1153
                                              bool isCallValid,
 
1154
                                              GLenum pname,
 
1155
                                              GLubyte *data);
 
1156
angle::CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState,
 
1157
                                                bool isCallValid,
 
1158
                                                GLenum target,
 
1159
                                                GLuint index,
 
1160
                                                GLubyte *data);
 
1161
angle::CallCapture CaptureIsMemoryObjectEXT(const State &glState,
 
1162
                                            bool isCallValid,
 
1163
                                            MemoryObjectID memoryObjectPacked,
 
1164
                                            GLboolean returnValue);
 
1165
angle::CallCapture CaptureMemoryObjectParameterivEXT(const State &glState,
 
1166
                                                     bool isCallValid,
 
1167
                                                     MemoryObjectID memoryObjectPacked,
 
1168
                                                     GLenum pname,
 
1169
                                                     const GLint *params);
 
1170
angle::CallCapture CaptureTexStorageMem2DEXT(const State &glState,
 
1171
                                             bool isCallValid,
 
1172
                                             TextureType targetPacked,
 
1173
                                             GLsizei levels,
 
1174
                                             GLenum internalFormat,
 
1175
                                             GLsizei width,
 
1176
                                             GLsizei height,
 
1177
                                             MemoryObjectID memoryPacked,
 
1178
                                             GLuint64 offset);
 
1179
angle::CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState,
 
1180
                                                        bool isCallValid,
 
1181
                                                        TextureType targetPacked,
 
1182
                                                        GLsizei samples,
 
1183
                                                        GLenum internalFormat,
 
1184
                                                        GLsizei width,
 
1185
                                                        GLsizei height,
 
1186
                                                        GLboolean fixedSampleLocations,
 
1187
                                                        MemoryObjectID memoryPacked,
 
1188
                                                        GLuint64 offset);
 
1189
angle::CallCapture CaptureTexStorageMem3DEXT(const State &glState,
 
1190
                                             bool isCallValid,
 
1191
                                             TextureType targetPacked,
 
1192
                                             GLsizei levels,
 
1193
                                             GLenum internalFormat,
 
1194
                                             GLsizei width,
 
1195
                                             GLsizei height,
 
1196
                                             GLsizei depth,
 
1197
                                             MemoryObjectID memoryPacked,
 
1198
                                             GLuint64 offset);
 
1199
angle::CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState,
 
1200
                                                        bool isCallValid,
 
1201
                                                        TextureType targetPacked,
 
1202
                                                        GLsizei samples,
 
1203
                                                        GLenum internalFormat,
 
1204
                                                        GLsizei width,
 
1205
                                                        GLsizei height,
 
1206
                                                        GLsizei depth,
 
1207
                                                        GLboolean fixedSampleLocations,
 
1208
                                                        MemoryObjectID memoryPacked,
 
1209
                                                        GLuint64 offset);
 
1210
 
 
1211
// GL_EXT_memory_object_fd
 
1212
angle::CallCapture CaptureImportMemoryFdEXT(const State &glState,
 
1213
                                            bool isCallValid,
 
1214
                                            MemoryObjectID memoryPacked,
 
1215
                                            GLuint64 size,
 
1216
                                            HandleType handleTypePacked,
 
1217
                                            GLint fd);
 
1218
 
 
1219
// GL_EXT_multisampled_render_to_texture
 
1220
angle::CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
 
1221
                                                             bool isCallValid,
 
1222
                                                             GLenum target,
 
1223
                                                             GLenum attachment,
 
1224
                                                             GLenum textarget,
 
1225
                                                             GLuint texture,
 
1226
                                                             GLint level,
 
1227
                                                             GLsizei samples);
 
1228
angle::CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
 
1229
                                                            bool isCallValid,
 
1230
                                                            GLenum target,
 
1231
                                                            GLsizei samples,
 
1232
                                                            GLenum internalformat,
 
1233
                                                            GLsizei width,
 
1234
                                                            GLsizei height);
 
1235
 
 
1236
// GL_EXT_occlusion_query_boolean
 
1237
 
 
1238
// GL_EXT_read_format_bgra
 
1239
 
 
1240
// GL_EXT_robustness
 
1241
angle::CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
 
1242
                                                    bool isCallValid,
 
1243
                                                    GLenum returnValue);
 
1244
angle::CallCapture CaptureGetnUniformfvEXT(const State &glState,
 
1245
                                           bool isCallValid,
 
1246
                                           ShaderProgramID programPacked,
 
1247
                                           GLint location,
 
1248
                                           GLsizei bufSize,
 
1249
                                           GLfloat *params);
 
1250
angle::CallCapture CaptureGetnUniformivEXT(const State &glState,
 
1251
                                           bool isCallValid,
 
1252
                                           ShaderProgramID programPacked,
 
1253
                                           GLint location,
 
1254
                                           GLsizei bufSize,
 
1255
                                           GLint *params);
 
1256
angle::CallCapture CaptureReadnPixelsEXT(const State &glState,
 
1257
                                         bool isCallValid,
 
1258
                                         GLint x,
 
1259
                                         GLint y,
 
1260
                                         GLsizei width,
 
1261
                                         GLsizei height,
 
1262
                                         GLenum format,
 
1263
                                         GLenum type,
 
1264
                                         GLsizei bufSize,
 
1265
                                         void *data);
 
1266
 
 
1267
// GL_EXT_sRGB
 
1268
 
 
1269
// GL_EXT_semaphore
 
1270
angle::CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
 
1271
                                              bool isCallValid,
 
1272
                                              GLsizei n,
 
1273
                                              const SemaphoreID *semaphoresPacked);
 
1274
angle::CallCapture CaptureGenSemaphoresEXT(const State &glState,
 
1275
                                           bool isCallValid,
 
1276
                                           GLsizei n,
 
1277
                                           SemaphoreID *semaphoresPacked);
 
1278
angle::CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
 
1279
                                                        bool isCallValid,
 
1280
                                                        SemaphoreID semaphorePacked,
 
1281
                                                        GLenum pname,
 
1282
                                                        GLuint64 *params);
 
1283
angle::CallCapture CaptureIsSemaphoreEXT(const State &glState,
 
1284
                                         bool isCallValid,
 
1285
                                         SemaphoreID semaphorePacked,
 
1286
                                         GLboolean returnValue);
 
1287
angle::CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
 
1288
                                                     bool isCallValid,
 
1289
                                                     SemaphoreID semaphorePacked,
 
1290
                                                     GLenum pname,
 
1291
                                                     const GLuint64 *params);
 
1292
angle::CallCapture CaptureSignalSemaphoreEXT(const State &glState,
 
1293
                                             bool isCallValid,
 
1294
                                             SemaphoreID semaphorePacked,
 
1295
                                             GLuint numBufferBarriers,
 
1296
                                             const BufferID *buffersPacked,
 
1297
                                             GLuint numTextureBarriers,
 
1298
                                             const TextureID *texturesPacked,
 
1299
                                             const GLenum *dstLayouts);
 
1300
angle::CallCapture CaptureWaitSemaphoreEXT(const State &glState,
 
1301
                                           bool isCallValid,
 
1302
                                           SemaphoreID semaphorePacked,
 
1303
                                           GLuint numBufferBarriers,
 
1304
                                           const BufferID *buffersPacked,
 
1305
                                           GLuint numTextureBarriers,
 
1306
                                           const TextureID *texturesPacked,
 
1307
                                           const GLenum *srcLayouts);
 
1308
 
 
1309
// GL_EXT_semaphore_fd
 
1310
angle::CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
 
1311
                                               bool isCallValid,
 
1312
                                               SemaphoreID semaphorePacked,
 
1313
                                               HandleType handleTypePacked,
 
1314
                                               GLint fd);
 
1315
 
 
1316
// GL_EXT_texture_compression_bptc
 
1317
 
 
1318
// GL_EXT_texture_compression_dxt1
 
1319
 
 
1320
// GL_EXT_texture_compression_s3tc
 
1321
 
 
1322
// GL_EXT_texture_compression_s3tc_srgb
 
1323
 
 
1324
// GL_EXT_texture_filter_anisotropic
 
1325
 
 
1326
// GL_EXT_texture_format_BGRA8888
 
1327
 
 
1328
// GL_EXT_texture_storage
 
1329
angle::CallCapture CaptureTexStorage1DEXT(const State &glState,
 
1330
                                          bool isCallValid,
 
1331
                                          GLenum target,
 
1332
                                          GLsizei levels,
 
1333
                                          GLenum internalformat,
 
1334
                                          GLsizei width);
 
1335
angle::CallCapture CaptureTexStorage2DEXT(const State &glState,
 
1336
                                          bool isCallValid,
 
1337
                                          TextureType targetPacked,
 
1338
                                          GLsizei levels,
 
1339
                                          GLenum internalformat,
 
1340
                                          GLsizei width,
 
1341
                                          GLsizei height);
 
1342
angle::CallCapture CaptureTexStorage3DEXT(const State &glState,
 
1343
                                          bool isCallValid,
 
1344
                                          TextureType targetPacked,
 
1345
                                          GLsizei levels,
 
1346
                                          GLenum internalformat,
 
1347
                                          GLsizei width,
 
1348
                                          GLsizei height,
 
1349
                                          GLsizei depth);
 
1350
 
 
1351
// GL_KHR_debug
 
1352
angle::CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
 
1353
                                                  bool isCallValid,
 
1354
                                                  GLDEBUGPROCKHR callback,
 
1355
                                                  const void *userParam);
 
1356
angle::CallCapture CaptureDebugMessageControlKHR(const State &glState,
 
1357
                                                 bool isCallValid,
 
1358
                                                 GLenum source,
 
1359
                                                 GLenum type,
 
1360
                                                 GLenum severity,
 
1361
                                                 GLsizei count,
 
1362
                                                 const GLuint *ids,
 
1363
                                                 GLboolean enabled);
 
1364
angle::CallCapture CaptureDebugMessageInsertKHR(const State &glState,
 
1365
                                                bool isCallValid,
 
1366
                                                GLenum source,
 
1367
                                                GLenum type,
 
1368
                                                GLuint id,
 
1369
                                                GLenum severity,
 
1370
                                                GLsizei length,
 
1371
                                                const GLchar *buf);
 
1372
angle::CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
 
1373
                                                bool isCallValid,
 
1374
                                                GLuint count,
 
1375
                                                GLsizei bufSize,
 
1376
                                                GLenum *sources,
 
1377
                                                GLenum *types,
 
1378
                                                GLuint *ids,
 
1379
                                                GLenum *severities,
 
1380
                                                GLsizei *lengths,
 
1381
                                                GLchar *messageLog,
 
1382
                                                GLuint returnValue);
 
1383
angle::CallCapture CaptureGetObjectLabelKHR(const State &glState,
 
1384
                                            bool isCallValid,
 
1385
                                            GLenum identifier,
 
1386
                                            GLuint name,
 
1387
                                            GLsizei bufSize,
 
1388
                                            GLsizei *length,
 
1389
                                            GLchar *label);
 
1390
angle::CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
 
1391
                                               bool isCallValid,
 
1392
                                               const void *ptr,
 
1393
                                               GLsizei bufSize,
 
1394
                                               GLsizei *length,
 
1395
                                               GLchar *label);
 
1396
angle::CallCapture CaptureGetPointervKHR(const State &glState,
 
1397
                                         bool isCallValid,
 
1398
                                         GLenum pname,
 
1399
                                         void **params);
 
1400
angle::CallCapture CaptureObjectLabelKHR(const State &glState,
 
1401
                                         bool isCallValid,
 
1402
                                         GLenum identifier,
 
1403
                                         GLuint name,
 
1404
                                         GLsizei length,
 
1405
                                         const GLchar *label);
 
1406
angle::CallCapture CaptureObjectPtrLabelKHR(const State &glState,
 
1407
                                            bool isCallValid,
 
1408
                                            const void *ptr,
 
1409
                                            GLsizei length,
 
1410
                                            const GLchar *label);
 
1411
angle::CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid);
 
1412
angle::CallCapture CapturePushDebugGroupKHR(const State &glState,
 
1413
                                            bool isCallValid,
 
1414
                                            GLenum source,
 
1415
                                            GLuint id,
 
1416
                                            GLsizei length,
 
1417
                                            const GLchar *message);
 
1418
 
 
1419
// GL_KHR_parallel_shader_compile
 
1420
angle::CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState,
 
1421
                                                      bool isCallValid,
 
1422
                                                      GLuint count);
 
1423
 
 
1424
// GL_NV_fence
 
1425
angle::CallCapture CaptureDeleteFencesNV(const State &glState,
 
1426
                                         bool isCallValid,
 
1427
                                         GLsizei n,
 
1428
                                         const FenceNVID *fencesPacked);
 
1429
angle::CallCapture CaptureFinishFenceNV(const State &glState,
 
1430
                                        bool isCallValid,
 
1431
                                        FenceNVID fencePacked);
 
1432
angle::CallCapture CaptureGenFencesNV(const State &glState,
 
1433
                                      bool isCallValid,
 
1434
                                      GLsizei n,
 
1435
                                      FenceNVID *fencesPacked);
 
1436
angle::CallCapture CaptureGetFenceivNV(const State &glState,
 
1437
                                       bool isCallValid,
 
1438
                                       FenceNVID fencePacked,
 
1439
                                       GLenum pname,
 
1440
                                       GLint *params);
 
1441
angle::CallCapture CaptureIsFenceNV(const State &glState,
 
1442
                                    bool isCallValid,
 
1443
                                    FenceNVID fencePacked,
 
1444
                                    GLboolean returnValue);
 
1445
angle::CallCapture CaptureSetFenceNV(const State &glState,
 
1446
                                     bool isCallValid,
 
1447
                                     FenceNVID fencePacked,
 
1448
                                     GLenum condition);
 
1449
angle::CallCapture CaptureTestFenceNV(const State &glState,
 
1450
                                      bool isCallValid,
 
1451
                                      FenceNVID fencePacked,
 
1452
                                      GLboolean returnValue);
 
1453
 
 
1454
// GL_OES_EGL_image
 
1455
angle::CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
 
1456
                                                               bool isCallValid,
 
1457
                                                               GLenum target,
 
1458
                                                               GLeglImageOES image);
 
1459
angle::CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
 
1460
                                                     bool isCallValid,
 
1461
                                                     TextureType targetPacked,
 
1462
                                                     GLeglImageOES image);
 
1463
 
 
1464
// GL_OES_compressed_ETC1_RGB8_texture
 
1465
 
 
1466
// GL_OES_depth32
 
1467
 
 
1468
// GL_OES_draw_elements_base_vertex
 
1469
angle::CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
 
1470
                                                    bool isCallValid,
 
1471
                                                    PrimitiveMode modePacked,
 
1472
                                                    GLsizei count,
 
1473
                                                    DrawElementsType typePacked,
 
1474
                                                    const void *indices,
 
1475
                                                    GLint basevertex);
 
1476
angle::CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
 
1477
                                                             bool isCallValid,
 
1478
                                                             PrimitiveMode modePacked,
 
1479
                                                             GLsizei count,
 
1480
                                                             DrawElementsType typePacked,
 
1481
                                                             const void *indices,
 
1482
                                                             GLsizei instancecount,
 
1483
                                                             GLint basevertex);
 
1484
angle::CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
 
1485
                                                         bool isCallValid,
 
1486
                                                         PrimitiveMode modePacked,
 
1487
                                                         GLuint start,
 
1488
                                                         GLuint end,
 
1489
                                                         GLsizei count,
 
1490
                                                         DrawElementsType typePacked,
 
1491
                                                         const void *indices,
 
1492
                                                         GLint basevertex);
 
1493
 
 
1494
// GL_OES_draw_texture
 
1495
angle::CallCapture CaptureDrawTexfOES(const State &glState,
 
1496
                                      bool isCallValid,
 
1497
                                      GLfloat x,
 
1498
                                      GLfloat y,
 
1499
                                      GLfloat z,
 
1500
                                      GLfloat width,
 
1501
                                      GLfloat height);
 
1502
angle::CallCapture CaptureDrawTexfvOES(const State &glState,
 
1503
                                       bool isCallValid,
 
1504
                                       const GLfloat *coords);
 
1505
angle::CallCapture CaptureDrawTexiOES(const State &glState,
 
1506
                                      bool isCallValid,
 
1507
                                      GLint x,
 
1508
                                      GLint y,
 
1509
                                      GLint z,
 
1510
                                      GLint width,
 
1511
                                      GLint height);
 
1512
angle::CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords);
 
1513
angle::CallCapture CaptureDrawTexsOES(const State &glState,
 
1514
                                      bool isCallValid,
 
1515
                                      GLshort x,
 
1516
                                      GLshort y,
 
1517
                                      GLshort z,
 
1518
                                      GLshort width,
 
1519
                                      GLshort height);
 
1520
angle::CallCapture CaptureDrawTexsvOES(const State &glState,
 
1521
                                       bool isCallValid,
 
1522
                                       const GLshort *coords);
 
1523
angle::CallCapture CaptureDrawTexxOES(const State &glState,
 
1524
                                      bool isCallValid,
 
1525
                                      GLfixed x,
 
1526
                                      GLfixed y,
 
1527
                                      GLfixed z,
 
1528
                                      GLfixed width,
 
1529
                                      GLfixed height);
 
1530
angle::CallCapture CaptureDrawTexxvOES(const State &glState,
 
1531
                                       bool isCallValid,
 
1532
                                       const GLfixed *coords);
 
1533
 
 
1534
// GL_OES_framebuffer_object
 
1535
angle::CallCapture CaptureBindFramebufferOES(const State &glState,
 
1536
                                             bool isCallValid,
 
1537
                                             GLenum target,
 
1538
                                             FramebufferID framebufferPacked);
 
1539
angle::CallCapture CaptureBindRenderbufferOES(const State &glState,
 
1540
                                              bool isCallValid,
 
1541
                                              GLenum target,
 
1542
                                              RenderbufferID renderbufferPacked);
 
1543
angle::CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
 
1544
                                                    bool isCallValid,
 
1545
                                                    GLenum target,
 
1546
                                                    GLenum returnValue);
 
1547
angle::CallCapture CaptureDeleteFramebuffersOES(const State &glState,
 
1548
                                                bool isCallValid,
 
1549
                                                GLsizei n,
 
1550
                                                const FramebufferID *framebuffersPacked);
 
1551
angle::CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
 
1552
                                                 bool isCallValid,
 
1553
                                                 GLsizei n,
 
1554
                                                 const RenderbufferID *renderbuffersPacked);
 
1555
angle::CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
 
1556
                                                     bool isCallValid,
 
1557
                                                     GLenum target,
 
1558
                                                     GLenum attachment,
 
1559
                                                     GLenum renderbuffertarget,
 
1560
                                                     RenderbufferID renderbufferPacked);
 
1561
angle::CallCapture CaptureFramebufferTexture2DOES(const State &glState,
 
1562
                                                  bool isCallValid,
 
1563
                                                  GLenum target,
 
1564
                                                  GLenum attachment,
 
1565
                                                  TextureTarget textargetPacked,
 
1566
                                                  TextureID texturePacked,
 
1567
                                                  GLint level);
 
1568
angle::CallCapture CaptureGenFramebuffersOES(const State &glState,
 
1569
                                             bool isCallValid,
 
1570
                                             GLsizei n,
 
1571
                                             FramebufferID *framebuffersPacked);
 
1572
angle::CallCapture CaptureGenRenderbuffersOES(const State &glState,
 
1573
                                              bool isCallValid,
 
1574
                                              GLsizei n,
 
1575
                                              RenderbufferID *renderbuffersPacked);
 
1576
angle::CallCapture CaptureGenerateMipmapOES(const State &glState,
 
1577
                                            bool isCallValid,
 
1578
                                            TextureType targetPacked);
 
1579
angle::CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
 
1580
                                                                 bool isCallValid,
 
1581
                                                                 GLenum target,
 
1582
                                                                 GLenum attachment,
 
1583
                                                                 GLenum pname,
 
1584
                                                                 GLint *params);
 
1585
angle::CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
 
1586
                                                        bool isCallValid,
 
1587
                                                        GLenum target,
 
1588
                                                        GLenum pname,
 
1589
                                                        GLint *params);
 
1590
angle::CallCapture CaptureIsFramebufferOES(const State &glState,
 
1591
                                           bool isCallValid,
 
1592
                                           FramebufferID framebufferPacked,
 
1593
                                           GLboolean returnValue);
 
1594
angle::CallCapture CaptureIsRenderbufferOES(const State &glState,
 
1595
                                            bool isCallValid,
 
1596
                                            RenderbufferID renderbufferPacked,
 
1597
                                            GLboolean returnValue);
 
1598
angle::CallCapture CaptureRenderbufferStorageOES(const State &glState,
 
1599
                                                 bool isCallValid,
 
1600
                                                 GLenum target,
 
1601
                                                 GLenum internalformat,
 
1602
                                                 GLsizei width,
 
1603
                                                 GLsizei height);
 
1604
 
 
1605
// GL_OES_get_program_binary
 
1606
angle::CallCapture CaptureGetProgramBinaryOES(const State &glState,
 
1607
                                              bool isCallValid,
 
1608
                                              ShaderProgramID programPacked,
 
1609
                                              GLsizei bufSize,
 
1610
                                              GLsizei *length,
 
1611
                                              GLenum *binaryFormat,
 
1612
                                              void *binary);
 
1613
angle::CallCapture CaptureProgramBinaryOES(const State &glState,
 
1614
                                           bool isCallValid,
 
1615
                                           ShaderProgramID programPacked,
 
1616
                                           GLenum binaryFormat,
 
1617
                                           const void *binary,
 
1618
                                           GLint length);
 
1619
 
 
1620
// GL_OES_mapbuffer
 
1621
angle::CallCapture CaptureGetBufferPointervOES(const State &glState,
 
1622
                                               bool isCallValid,
 
1623
                                               BufferBinding targetPacked,
 
1624
                                               GLenum pname,
 
1625
                                               void **params);
 
1626
angle::CallCapture CaptureMapBufferOES(const State &glState,
 
1627
                                       bool isCallValid,
 
1628
                                       BufferBinding targetPacked,
 
1629
                                       GLenum access,
 
1630
                                       void *returnValue);
 
1631
angle::CallCapture CaptureUnmapBufferOES(const State &glState,
 
1632
                                         bool isCallValid,
 
1633
                                         BufferBinding targetPacked,
 
1634
                                         GLboolean returnValue);
 
1635
 
 
1636
// GL_OES_matrix_palette
 
1637
angle::CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
 
1638
                                                  bool isCallValid,
 
1639
                                                  GLuint matrixpaletteindex);
 
1640
angle::CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid);
 
1641
angle::CallCapture CaptureMatrixIndexPointerOES(const State &glState,
 
1642
                                                bool isCallValid,
 
1643
                                                GLint size,
 
1644
                                                GLenum type,
 
1645
                                                GLsizei stride,
 
1646
                                                const void *pointer);
 
1647
angle::CallCapture CaptureWeightPointerOES(const State &glState,
 
1648
                                           bool isCallValid,
 
1649
                                           GLint size,
 
1650
                                           GLenum type,
 
1651
                                           GLsizei stride,
 
1652
                                           const void *pointer);
 
1653
 
 
1654
// GL_OES_point_size_array
 
1655
angle::CallCapture CapturePointSizePointerOES(const State &glState,
 
1656
                                              bool isCallValid,
 
1657
                                              VertexAttribType typePacked,
 
1658
                                              GLsizei stride,
 
1659
                                              const void *pointer);
 
1660
 
 
1661
// GL_OES_query_matrix
 
1662
angle::CallCapture CaptureQueryMatrixxOES(const State &glState,
 
1663
                                          bool isCallValid,
 
1664
                                          GLfixed *mantissa,
 
1665
                                          GLint *exponent,
 
1666
                                          GLbitfield returnValue);
 
1667
 
 
1668
// GL_OES_texture_3D
 
1669
angle::CallCapture CaptureCompressedTexImage3DOES(const State &glState,
 
1670
                                                  bool isCallValid,
 
1671
                                                  TextureTarget targetPacked,
 
1672
                                                  GLint level,
 
1673
                                                  GLenum internalformat,
 
1674
                                                  GLsizei width,
 
1675
                                                  GLsizei height,
 
1676
                                                  GLsizei depth,
 
1677
                                                  GLint border,
 
1678
                                                  GLsizei imageSize,
 
1679
                                                  const void *data);
 
1680
angle::CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
 
1681
                                                     bool isCallValid,
 
1682
                                                     TextureTarget targetPacked,
 
1683
                                                     GLint level,
 
1684
                                                     GLint xoffset,
 
1685
                                                     GLint yoffset,
 
1686
                                                     GLint zoffset,
 
1687
                                                     GLsizei width,
 
1688
                                                     GLsizei height,
 
1689
                                                     GLsizei depth,
 
1690
                                                     GLenum format,
 
1691
                                                     GLsizei imageSize,
 
1692
                                                     const void *data);
 
1693
angle::CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
 
1694
                                               bool isCallValid,
 
1695
                                               TextureTarget targetPacked,
 
1696
                                               GLint level,
 
1697
                                               GLint xoffset,
 
1698
                                               GLint yoffset,
 
1699
                                               GLint zoffset,
 
1700
                                               GLint x,
 
1701
                                               GLint y,
 
1702
                                               GLsizei width,
 
1703
                                               GLsizei height);
 
1704
angle::CallCapture CaptureFramebufferTexture3DOES(const State &glState,
 
1705
                                                  bool isCallValid,
 
1706
                                                  GLenum target,
 
1707
                                                  GLenum attachment,
 
1708
                                                  TextureTarget textargetPacked,
 
1709
                                                  TextureID texturePacked,
 
1710
                                                  GLint level,
 
1711
                                                  GLint zoffset);
 
1712
angle::CallCapture CaptureTexImage3DOES(const State &glState,
 
1713
                                        bool isCallValid,
 
1714
                                        TextureTarget targetPacked,
 
1715
                                        GLint level,
 
1716
                                        GLenum internalformat,
 
1717
                                        GLsizei width,
 
1718
                                        GLsizei height,
 
1719
                                        GLsizei depth,
 
1720
                                        GLint border,
 
1721
                                        GLenum format,
 
1722
                                        GLenum type,
 
1723
                                        const void *pixels);
 
1724
angle::CallCapture CaptureTexSubImage3DOES(const State &glState,
 
1725
                                           bool isCallValid,
 
1726
                                           TextureTarget targetPacked,
 
1727
                                           GLint level,
 
1728
                                           GLint xoffset,
 
1729
                                           GLint yoffset,
 
1730
                                           GLint zoffset,
 
1731
                                           GLsizei width,
 
1732
                                           GLsizei height,
 
1733
                                           GLsizei depth,
 
1734
                                           GLenum format,
 
1735
                                           GLenum type,
 
1736
                                           const void *pixels);
 
1737
 
 
1738
// GL_OES_texture_border_clamp
 
1739
angle::CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
 
1740
                                                    bool isCallValid,
 
1741
                                                    SamplerID samplerPacked,
 
1742
                                                    GLenum pname,
 
1743
                                                    GLint *params);
 
1744
angle::CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
 
1745
                                                     bool isCallValid,
 
1746
                                                     SamplerID samplerPacked,
 
1747
                                                     GLenum pname,
 
1748
                                                     GLuint *params);
 
1749
angle::CallCapture CaptureGetTexParameterIivOES(const State &glState,
 
1750
                                                bool isCallValid,
 
1751
                                                TextureType targetPacked,
 
1752
                                                GLenum pname,
 
1753
                                                GLint *params);
 
1754
angle::CallCapture CaptureGetTexParameterIuivOES(const State &glState,
 
1755
                                                 bool isCallValid,
 
1756
                                                 TextureType targetPacked,
 
1757
                                                 GLenum pname,
 
1758
                                                 GLuint *params);
 
1759
angle::CallCapture CaptureSamplerParameterIivOES(const State &glState,
 
1760
                                                 bool isCallValid,
 
1761
                                                 SamplerID samplerPacked,
 
1762
                                                 GLenum pname,
 
1763
                                                 const GLint *param);
 
1764
angle::CallCapture CaptureSamplerParameterIuivOES(const State &glState,
 
1765
                                                  bool isCallValid,
 
1766
                                                  SamplerID samplerPacked,
 
1767
                                                  GLenum pname,
 
1768
                                                  const GLuint *param);
 
1769
angle::CallCapture CaptureTexParameterIivOES(const State &glState,
 
1770
                                             bool isCallValid,
 
1771
                                             TextureType targetPacked,
 
1772
                                             GLenum pname,
 
1773
                                             const GLint *params);
 
1774
angle::CallCapture CaptureTexParameterIuivOES(const State &glState,
 
1775
                                              bool isCallValid,
 
1776
                                              TextureType targetPacked,
 
1777
                                              GLenum pname,
 
1778
                                              const GLuint *params);
 
1779
 
 
1780
// GL_OES_texture_cube_map
 
1781
angle::CallCapture CaptureGetTexGenfvOES(const State &glState,
 
1782
                                         bool isCallValid,
 
1783
                                         GLenum coord,
 
1784
                                         GLenum pname,
 
1785
                                         GLfloat *params);
 
1786
angle::CallCapture CaptureGetTexGenivOES(const State &glState,
 
1787
                                         bool isCallValid,
 
1788
                                         GLenum coord,
 
1789
                                         GLenum pname,
 
1790
                                         GLint *params);
 
1791
angle::CallCapture CaptureGetTexGenxvOES(const State &glState,
 
1792
                                         bool isCallValid,
 
1793
                                         GLenum coord,
 
1794
                                         GLenum pname,
 
1795
                                         GLfixed *params);
 
1796
angle::CallCapture CaptureTexGenfOES(const State &glState,
 
1797
                                     bool isCallValid,
 
1798
                                     GLenum coord,
 
1799
                                     GLenum pname,
 
1800
                                     GLfloat param);
 
1801
angle::CallCapture CaptureTexGenfvOES(const State &glState,
 
1802
                                      bool isCallValid,
 
1803
                                      GLenum coord,
 
1804
                                      GLenum pname,
 
1805
                                      const GLfloat *params);
 
1806
angle::CallCapture CaptureTexGeniOES(const State &glState,
 
1807
                                     bool isCallValid,
 
1808
                                     GLenum coord,
 
1809
                                     GLenum pname,
 
1810
                                     GLint param);
 
1811
angle::CallCapture CaptureTexGenivOES(const State &glState,
 
1812
                                      bool isCallValid,
 
1813
                                      GLenum coord,
 
1814
                                      GLenum pname,
 
1815
                                      const GLint *params);
 
1816
angle::CallCapture CaptureTexGenxOES(const State &glState,
 
1817
                                     bool isCallValid,
 
1818
                                     GLenum coord,
 
1819
                                     GLenum pname,
 
1820
                                     GLfixed param);
 
1821
angle::CallCapture CaptureTexGenxvOES(const State &glState,
 
1822
                                      bool isCallValid,
 
1823
                                      GLenum coord,
 
1824
                                      GLenum pname,
 
1825
                                      const GLfixed *params);
 
1826
 
 
1827
// GL_OES_texture_half_float
 
1828
 
 
1829
// GL_OES_texture_storage_multisample_2d_array
 
1830
angle::CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
 
1831
                                                     bool isCallValid,
 
1832
                                                     TextureType targetPacked,
 
1833
                                                     GLsizei samples,
 
1834
                                                     GLenum internalformat,
 
1835
                                                     GLsizei width,
 
1836
                                                     GLsizei height,
 
1837
                                                     GLsizei depth,
 
1838
                                                     GLboolean fixedsamplelocations);
 
1839
 
 
1840
// GL_OES_vertex_array_object
 
1841
angle::CallCapture CaptureBindVertexArrayOES(const State &glState,
 
1842
                                             bool isCallValid,
 
1843
                                             VertexArrayID arrayPacked);
 
1844
angle::CallCapture CaptureDeleteVertexArraysOES(const State &glState,
 
1845
                                                bool isCallValid,
 
1846
                                                GLsizei n,
 
1847
                                                const VertexArrayID *arraysPacked);
 
1848
angle::CallCapture CaptureGenVertexArraysOES(const State &glState,
 
1849
                                             bool isCallValid,
 
1850
                                             GLsizei n,
 
1851
                                             VertexArrayID *arraysPacked);
 
1852
angle::CallCapture CaptureIsVertexArrayOES(const State &glState,
 
1853
                                           bool isCallValid,
 
1854
                                           VertexArrayID arrayPacked,
 
1855
                                           GLboolean returnValue);
 
1856
 
 
1857
// GL_OVR_multiview
 
1858
angle::CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
 
1859
                                                         bool isCallValid,
 
1860
                                                         GLenum target,
 
1861
                                                         GLenum attachment,
 
1862
                                                         TextureID texturePacked,
 
1863
                                                         GLint level,
 
1864
                                                         GLint baseViewIndex,
 
1865
                                                         GLsizei numViews);
 
1866
 
 
1867
// GL_OVR_multiview2
 
1868
 
 
1869
// Parameter Captures
 
1870
 
 
1871
void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
 
1872
    const State &glState,
 
1873
    bool isCallValid,
 
1874
    PrimitiveMode modePacked,
 
1875
    GLsizei count,
 
1876
    DrawElementsType typePacked,
 
1877
    const GLvoid *indices,
 
1878
    GLsizei instanceCounts,
 
1879
    GLint baseVertex,
 
1880
    GLuint baseInstance,
 
1881
    angle::ParamCapture *paramCapture);
 
1882
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(const State &glState,
 
1883
                                                             bool isCallValid,
 
1884
                                                             PrimitiveMode modePacked,
 
1885
                                                             const GLint *firsts,
 
1886
                                                             const GLsizei *counts,
 
1887
                                                             const GLsizei *instanceCounts,
 
1888
                                                             const GLuint *baseInstances,
 
1889
                                                             GLsizei drawcount,
 
1890
                                                             angle::ParamCapture *paramCapture);
 
1891
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(const State &glState,
 
1892
                                                             bool isCallValid,
 
1893
                                                             PrimitiveMode modePacked,
 
1894
                                                             const GLint *firsts,
 
1895
                                                             const GLsizei *counts,
 
1896
                                                             const GLsizei *instanceCounts,
 
1897
                                                             const GLuint *baseInstances,
 
1898
                                                             GLsizei drawcount,
 
1899
                                                             angle::ParamCapture *paramCapture);
 
1900
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
 
1901
    const State &glState,
 
1902
    bool isCallValid,
 
1903
    PrimitiveMode modePacked,
 
1904
    const GLint *firsts,
 
1905
    const GLsizei *counts,
 
1906
    const GLsizei *instanceCounts,
 
1907
    const GLuint *baseInstances,
 
1908
    GLsizei drawcount,
 
1909
    angle::ParamCapture *paramCapture);
 
1910
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
 
1911
    const State &glState,
 
1912
    bool isCallValid,
 
1913
    PrimitiveMode modePacked,
 
1914
    const GLint *firsts,
 
1915
    const GLsizei *counts,
 
1916
    const GLsizei *instanceCounts,
 
1917
    const GLuint *baseInstances,
 
1918
    GLsizei drawcount,
 
1919
    angle::ParamCapture *paramCapture);
 
1920
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
 
1921
    const State &glState,
 
1922
    bool isCallValid,
 
1923
    PrimitiveMode modePacked,
 
1924
    const GLsizei *counts,
 
1925
    DrawElementsType typePacked,
 
1926
    const GLvoid *const *indices,
 
1927
    const GLsizei *instanceCounts,
 
1928
    const GLint *baseVertices,
 
1929
    const GLuint *baseInstances,
 
1930
    GLsizei drawcount,
 
1931
    angle::ParamCapture *paramCapture);
 
1932
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
 
1933
    const State &glState,
 
1934
    bool isCallValid,
 
1935
    PrimitiveMode modePacked,
 
1936
    const GLsizei *counts,
 
1937
    DrawElementsType typePacked,
 
1938
    const GLvoid *const *indices,
 
1939
    const GLsizei *instanceCounts,
 
1940
    const GLint *baseVertices,
 
1941
    const GLuint *baseInstances,
 
1942
    GLsizei drawcount,
 
1943
    angle::ParamCapture *paramCapture);
 
1944
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
 
1945
    const State &glState,
 
1946
    bool isCallValid,
 
1947
    PrimitiveMode modePacked,
 
1948
    const GLsizei *counts,
 
1949
    DrawElementsType typePacked,
 
1950
    const GLvoid *const *indices,
 
1951
    const GLsizei *instanceCounts,
 
1952
    const GLint *baseVertices,
 
1953
    const GLuint *baseInstances,
 
1954
    GLsizei drawcount,
 
1955
    angle::ParamCapture *paramCapture);
 
1956
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
 
1957
    const State &glState,
 
1958
    bool isCallValid,
 
1959
    PrimitiveMode modePacked,
 
1960
    const GLsizei *counts,
 
1961
    DrawElementsType typePacked,
 
1962
    const GLvoid *const *indices,
 
1963
    const GLsizei *instanceCounts,
 
1964
    const GLint *baseVertices,
 
1965
    const GLuint *baseInstances,
 
1966
    GLsizei drawcount,
 
1967
    angle::ParamCapture *paramCapture);
 
1968
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
 
1969
    const State &glState,
 
1970
    bool isCallValid,
 
1971
    PrimitiveMode modePacked,
 
1972
    const GLsizei *counts,
 
1973
    DrawElementsType typePacked,
 
1974
    const GLvoid *const *indices,
 
1975
    const GLsizei *instanceCounts,
 
1976
    const GLint *baseVertices,
 
1977
    const GLuint *baseInstances,
 
1978
    GLsizei drawcount,
 
1979
    angle::ParamCapture *paramCapture);
 
1980
void CaptureGetTexImageANGLE_pixels(const State &glState,
 
1981
                                    bool isCallValid,
 
1982
                                    TextureTarget targetPacked,
 
1983
                                    GLint level,
 
1984
                                    GLenum format,
 
1985
                                    GLenum type,
 
1986
                                    void *pixels,
 
1987
                                    angle::ParamCapture *paramCapture);
 
1988
void CaptureGetRenderbufferImageANGLE_pixels(const State &glState,
 
1989
                                             bool isCallValid,
 
1990
                                             GLenum target,
 
1991
                                             GLenum format,
 
1992
                                             GLenum type,
 
1993
                                             void *pixels,
 
1994
                                             angle::ParamCapture *paramCapture);
 
1995
void CaptureDrawElementsInstancedANGLE_indices(const State &glState,
 
1996
                                               bool isCallValid,
 
1997
                                               PrimitiveMode modePacked,
 
1998
                                               GLsizei count,
 
1999
                                               DrawElementsType typePacked,
 
2000
                                               const void *indices,
 
2001
                                               GLsizei primcount,
 
2002
                                               angle::ParamCapture *paramCapture);
 
2003
void CaptureMultiDrawArraysANGLE_firsts(const State &glState,
 
2004
                                        bool isCallValid,
 
2005
                                        PrimitiveMode modePacked,
 
2006
                                        const GLint *firsts,
 
2007
                                        const GLsizei *counts,
 
2008
                                        GLsizei drawcount,
 
2009
                                        angle::ParamCapture *paramCapture);
 
2010
void CaptureMultiDrawArraysANGLE_counts(const State &glState,
 
2011
                                        bool isCallValid,
 
2012
                                        PrimitiveMode modePacked,
 
2013
                                        const GLint *firsts,
 
2014
                                        const GLsizei *counts,
 
2015
                                        GLsizei drawcount,
 
2016
                                        angle::ParamCapture *paramCapture);
 
2017
void CaptureMultiDrawArraysInstancedANGLE_firsts(const State &glState,
 
2018
                                                 bool isCallValid,
 
2019
                                                 PrimitiveMode modePacked,
 
2020
                                                 const GLint *firsts,
 
2021
                                                 const GLsizei *counts,
 
2022
                                                 const GLsizei *instanceCounts,
 
2023
                                                 GLsizei drawcount,
 
2024
                                                 angle::ParamCapture *paramCapture);
 
2025
void CaptureMultiDrawArraysInstancedANGLE_counts(const State &glState,
 
2026
                                                 bool isCallValid,
 
2027
                                                 PrimitiveMode modePacked,
 
2028
                                                 const GLint *firsts,
 
2029
                                                 const GLsizei *counts,
 
2030
                                                 const GLsizei *instanceCounts,
 
2031
                                                 GLsizei drawcount,
 
2032
                                                 angle::ParamCapture *paramCapture);
 
2033
void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(const State &glState,
 
2034
                                                         bool isCallValid,
 
2035
                                                         PrimitiveMode modePacked,
 
2036
                                                         const GLint *firsts,
 
2037
                                                         const GLsizei *counts,
 
2038
                                                         const GLsizei *instanceCounts,
 
2039
                                                         GLsizei drawcount,
 
2040
                                                         angle::ParamCapture *paramCapture);
 
2041
void CaptureMultiDrawElementsANGLE_counts(const State &glState,
 
2042
                                          bool isCallValid,
 
2043
                                          PrimitiveMode modePacked,
 
2044
                                          const GLsizei *counts,
 
2045
                                          DrawElementsType typePacked,
 
2046
                                          const GLvoid *const *indices,
 
2047
                                          GLsizei drawcount,
 
2048
                                          angle::ParamCapture *paramCapture);
 
2049
void CaptureMultiDrawElementsANGLE_indices(const State &glState,
 
2050
                                           bool isCallValid,
 
2051
                                           PrimitiveMode modePacked,
 
2052
                                           const GLsizei *counts,
 
2053
                                           DrawElementsType typePacked,
 
2054
                                           const GLvoid *const *indices,
 
2055
                                           GLsizei drawcount,
 
2056
                                           angle::ParamCapture *paramCapture);
 
2057
void CaptureMultiDrawElementsInstancedANGLE_counts(const State &glState,
 
2058
                                                   bool isCallValid,
 
2059
                                                   PrimitiveMode modePacked,
 
2060
                                                   const GLsizei *counts,
 
2061
                                                   DrawElementsType typePacked,
 
2062
                                                   const GLvoid *const *indices,
 
2063
                                                   const GLsizei *instanceCounts,
 
2064
                                                   GLsizei drawcount,
 
2065
                                                   angle::ParamCapture *paramCapture);
 
2066
void CaptureMultiDrawElementsInstancedANGLE_indices(const State &glState,
 
2067
                                                    bool isCallValid,
 
2068
                                                    PrimitiveMode modePacked,
 
2069
                                                    const GLsizei *counts,
 
2070
                                                    DrawElementsType typePacked,
 
2071
                                                    const GLvoid *const *indices,
 
2072
                                                    const GLsizei *instanceCounts,
 
2073
                                                    GLsizei drawcount,
 
2074
                                                    angle::ParamCapture *paramCapture);
 
2075
void CaptureMultiDrawElementsInstancedANGLE_instanceCounts(const State &glState,
 
2076
                                                           bool isCallValid,
 
2077
                                                           PrimitiveMode modePacked,
 
2078
                                                           const GLsizei *counts,
 
2079
                                                           DrawElementsType typePacked,
 
2080
                                                           const GLvoid *const *indices,
 
2081
                                                           const GLsizei *instanceCounts,
 
2082
                                                           GLsizei drawcount,
 
2083
                                                           angle::ParamCapture *paramCapture);
 
2084
void CaptureRequestExtensionANGLE_name(const State &glState,
 
2085
                                       bool isCallValid,
 
2086
                                       const GLchar *name,
 
2087
                                       angle::ParamCapture *paramCapture);
 
2088
void CaptureDisableExtensionANGLE_name(const State &glState,
 
2089
                                       bool isCallValid,
 
2090
                                       const GLchar *name,
 
2091
                                       angle::ParamCapture *paramCapture);
 
2092
void CaptureGetBooleanvRobustANGLE_length(const State &glState,
 
2093
                                          bool isCallValid,
 
2094
                                          GLenum pname,
 
2095
                                          GLsizei bufSize,
 
2096
                                          GLsizei *length,
 
2097
                                          GLboolean *params,
 
2098
                                          angle::ParamCapture *paramCapture);
 
2099
void CaptureGetBooleanvRobustANGLE_params(const State &glState,
 
2100
                                          bool isCallValid,
 
2101
                                          GLenum pname,
 
2102
                                          GLsizei bufSize,
 
2103
                                          GLsizei *length,
 
2104
                                          GLboolean *params,
 
2105
                                          angle::ParamCapture *paramCapture);
 
2106
void CaptureGetBufferParameterivRobustANGLE_length(const State &glState,
 
2107
                                                   bool isCallValid,
 
2108
                                                   BufferBinding targetPacked,
 
2109
                                                   GLenum pname,
 
2110
                                                   GLsizei bufSize,
 
2111
                                                   GLsizei *length,
 
2112
                                                   GLint *params,
 
2113
                                                   angle::ParamCapture *paramCapture);
 
2114
void CaptureGetBufferParameterivRobustANGLE_params(const State &glState,
 
2115
                                                   bool isCallValid,
 
2116
                                                   BufferBinding targetPacked,
 
2117
                                                   GLenum pname,
 
2118
                                                   GLsizei bufSize,
 
2119
                                                   GLsizei *length,
 
2120
                                                   GLint *params,
 
2121
                                                   angle::ParamCapture *paramCapture);
 
2122
void CaptureGetFloatvRobustANGLE_length(const State &glState,
 
2123
                                        bool isCallValid,
 
2124
                                        GLenum pname,
 
2125
                                        GLsizei bufSize,
 
2126
                                        GLsizei *length,
 
2127
                                        GLfloat *params,
 
2128
                                        angle::ParamCapture *paramCapture);
 
2129
void CaptureGetFloatvRobustANGLE_params(const State &glState,
 
2130
                                        bool isCallValid,
 
2131
                                        GLenum pname,
 
2132
                                        GLsizei bufSize,
 
2133
                                        GLsizei *length,
 
2134
                                        GLfloat *params,
 
2135
                                        angle::ParamCapture *paramCapture);
 
2136
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
 
2137
    const State &glState,
 
2138
    bool isCallValid,
 
2139
    GLenum target,
 
2140
    GLenum attachment,
 
2141
    GLenum pname,
 
2142
    GLsizei bufSize,
 
2143
    GLsizei *length,
 
2144
    GLint *params,
 
2145
    angle::ParamCapture *paramCapture);
 
2146
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
 
2147
    const State &glState,
 
2148
    bool isCallValid,
 
2149
    GLenum target,
 
2150
    GLenum attachment,
 
2151
    GLenum pname,
 
2152
    GLsizei bufSize,
 
2153
    GLsizei *length,
 
2154
    GLint *params,
 
2155
    angle::ParamCapture *paramCapture);
 
2156
void CaptureGetIntegervRobustANGLE_length(const State &glState,
 
2157
                                          bool isCallValid,
 
2158
                                          GLenum pname,
 
2159
                                          GLsizei bufSize,
 
2160
                                          GLsizei *length,
 
2161
                                          GLint *data,
 
2162
                                          angle::ParamCapture *paramCapture);
 
2163
void CaptureGetIntegervRobustANGLE_data(const State &glState,
 
2164
                                        bool isCallValid,
 
2165
                                        GLenum pname,
 
2166
                                        GLsizei bufSize,
 
2167
                                        GLsizei *length,
 
2168
                                        GLint *data,
 
2169
                                        angle::ParamCapture *paramCapture);
 
2170
void CaptureGetProgramivRobustANGLE_length(const State &glState,
 
2171
                                           bool isCallValid,
 
2172
                                           ShaderProgramID programPacked,
 
2173
                                           GLenum pname,
 
2174
                                           GLsizei bufSize,
 
2175
                                           GLsizei *length,
 
2176
                                           GLint *params,
 
2177
                                           angle::ParamCapture *paramCapture);
 
2178
void CaptureGetProgramivRobustANGLE_params(const State &glState,
 
2179
                                           bool isCallValid,
 
2180
                                           ShaderProgramID programPacked,
 
2181
                                           GLenum pname,
 
2182
                                           GLsizei bufSize,
 
2183
                                           GLsizei *length,
 
2184
                                           GLint *params,
 
2185
                                           angle::ParamCapture *paramCapture);
 
2186
void CaptureGetRenderbufferParameterivRobustANGLE_length(const State &glState,
 
2187
                                                         bool isCallValid,
 
2188
                                                         GLenum target,
 
2189
                                                         GLenum pname,
 
2190
                                                         GLsizei bufSize,
 
2191
                                                         GLsizei *length,
 
2192
                                                         GLint *params,
 
2193
                                                         angle::ParamCapture *paramCapture);
 
2194
void CaptureGetRenderbufferParameterivRobustANGLE_params(const State &glState,
 
2195
                                                         bool isCallValid,
 
2196
                                                         GLenum target,
 
2197
                                                         GLenum pname,
 
2198
                                                         GLsizei bufSize,
 
2199
                                                         GLsizei *length,
 
2200
                                                         GLint *params,
 
2201
                                                         angle::ParamCapture *paramCapture);
 
2202
void CaptureGetShaderivRobustANGLE_length(const State &glState,
 
2203
                                          bool isCallValid,
 
2204
                                          ShaderProgramID shaderPacked,
 
2205
                                          GLenum pname,
 
2206
                                          GLsizei bufSize,
 
2207
                                          GLsizei *length,
 
2208
                                          GLint *params,
 
2209
                                          angle::ParamCapture *paramCapture);
 
2210
void CaptureGetShaderivRobustANGLE_params(const State &glState,
 
2211
                                          bool isCallValid,
 
2212
                                          ShaderProgramID shaderPacked,
 
2213
                                          GLenum pname,
 
2214
                                          GLsizei bufSize,
 
2215
                                          GLsizei *length,
 
2216
                                          GLint *params,
 
2217
                                          angle::ParamCapture *paramCapture);
 
2218
void CaptureGetTexParameterfvRobustANGLE_length(const State &glState,
 
2219
                                                bool isCallValid,
 
2220
                                                TextureType targetPacked,
 
2221
                                                GLenum pname,
 
2222
                                                GLsizei bufSize,
 
2223
                                                GLsizei *length,
 
2224
                                                GLfloat *params,
 
2225
                                                angle::ParamCapture *paramCapture);
 
2226
void CaptureGetTexParameterfvRobustANGLE_params(const State &glState,
 
2227
                                                bool isCallValid,
 
2228
                                                TextureType targetPacked,
 
2229
                                                GLenum pname,
 
2230
                                                GLsizei bufSize,
 
2231
                                                GLsizei *length,
 
2232
                                                GLfloat *params,
 
2233
                                                angle::ParamCapture *paramCapture);
 
2234
void CaptureGetTexParameterivRobustANGLE_length(const State &glState,
 
2235
                                                bool isCallValid,
 
2236
                                                TextureType targetPacked,
 
2237
                                                GLenum pname,
 
2238
                                                GLsizei bufSize,
 
2239
                                                GLsizei *length,
 
2240
                                                GLint *params,
 
2241
                                                angle::ParamCapture *paramCapture);
 
2242
void CaptureGetTexParameterivRobustANGLE_params(const State &glState,
 
2243
                                                bool isCallValid,
 
2244
                                                TextureType targetPacked,
 
2245
                                                GLenum pname,
 
2246
                                                GLsizei bufSize,
 
2247
                                                GLsizei *length,
 
2248
                                                GLint *params,
 
2249
                                                angle::ParamCapture *paramCapture);
 
2250
void CaptureGetUniformfvRobustANGLE_length(const State &glState,
 
2251
                                           bool isCallValid,
 
2252
                                           ShaderProgramID programPacked,
 
2253
                                           GLint location,
 
2254
                                           GLsizei bufSize,
 
2255
                                           GLsizei *length,
 
2256
                                           GLfloat *params,
 
2257
                                           angle::ParamCapture *paramCapture);
 
2258
void CaptureGetUniformfvRobustANGLE_params(const State &glState,
 
2259
                                           bool isCallValid,
 
2260
                                           ShaderProgramID programPacked,
 
2261
                                           GLint location,
 
2262
                                           GLsizei bufSize,
 
2263
                                           GLsizei *length,
 
2264
                                           GLfloat *params,
 
2265
                                           angle::ParamCapture *paramCapture);
 
2266
void CaptureGetUniformivRobustANGLE_length(const State &glState,
 
2267
                                           bool isCallValid,
 
2268
                                           ShaderProgramID programPacked,
 
2269
                                           GLint location,
 
2270
                                           GLsizei bufSize,
 
2271
                                           GLsizei *length,
 
2272
                                           GLint *params,
 
2273
                                           angle::ParamCapture *paramCapture);
 
2274
void CaptureGetUniformivRobustANGLE_params(const State &glState,
 
2275
                                           bool isCallValid,
 
2276
                                           ShaderProgramID programPacked,
 
2277
                                           GLint location,
 
2278
                                           GLsizei bufSize,
 
2279
                                           GLsizei *length,
 
2280
                                           GLint *params,
 
2281
                                           angle::ParamCapture *paramCapture);
 
2282
void CaptureGetVertexAttribfvRobustANGLE_length(const State &glState,
 
2283
                                                bool isCallValid,
 
2284
                                                GLuint index,
 
2285
                                                GLenum pname,
 
2286
                                                GLsizei bufSize,
 
2287
                                                GLsizei *length,
 
2288
                                                GLfloat *params,
 
2289
                                                angle::ParamCapture *paramCapture);
 
2290
void CaptureGetVertexAttribfvRobustANGLE_params(const State &glState,
 
2291
                                                bool isCallValid,
 
2292
                                                GLuint index,
 
2293
                                                GLenum pname,
 
2294
                                                GLsizei bufSize,
 
2295
                                                GLsizei *length,
 
2296
                                                GLfloat *params,
 
2297
                                                angle::ParamCapture *paramCapture);
 
2298
void CaptureGetVertexAttribivRobustANGLE_length(const State &glState,
 
2299
                                                bool isCallValid,
 
2300
                                                GLuint index,
 
2301
                                                GLenum pname,
 
2302
                                                GLsizei bufSize,
 
2303
                                                GLsizei *length,
 
2304
                                                GLint *params,
 
2305
                                                angle::ParamCapture *paramCapture);
 
2306
void CaptureGetVertexAttribivRobustANGLE_params(const State &glState,
 
2307
                                                bool isCallValid,
 
2308
                                                GLuint index,
 
2309
                                                GLenum pname,
 
2310
                                                GLsizei bufSize,
 
2311
                                                GLsizei *length,
 
2312
                                                GLint *params,
 
2313
                                                angle::ParamCapture *paramCapture);
 
2314
void CaptureGetVertexAttribPointervRobustANGLE_length(const State &glState,
 
2315
                                                      bool isCallValid,
 
2316
                                                      GLuint index,
 
2317
                                                      GLenum pname,
 
2318
                                                      GLsizei bufSize,
 
2319
                                                      GLsizei *length,
 
2320
                                                      void **pointer,
 
2321
                                                      angle::ParamCapture *paramCapture);
 
2322
void CaptureGetVertexAttribPointervRobustANGLE_pointer(const State &glState,
 
2323
                                                       bool isCallValid,
 
2324
                                                       GLuint index,
 
2325
                                                       GLenum pname,
 
2326
                                                       GLsizei bufSize,
 
2327
                                                       GLsizei *length,
 
2328
                                                       void **pointer,
 
2329
                                                       angle::ParamCapture *paramCapture);
 
2330
void CaptureReadPixelsRobustANGLE_length(const State &glState,
 
2331
                                         bool isCallValid,
 
2332
                                         GLint x,
 
2333
                                         GLint y,
 
2334
                                         GLsizei width,
 
2335
                                         GLsizei height,
 
2336
                                         GLenum format,
 
2337
                                         GLenum type,
 
2338
                                         GLsizei bufSize,
 
2339
                                         GLsizei *length,
 
2340
                                         GLsizei *columns,
 
2341
                                         GLsizei *rows,
 
2342
                                         void *pixels,
 
2343
                                         angle::ParamCapture *paramCapture);
 
2344
void CaptureReadPixelsRobustANGLE_columns(const State &glState,
 
2345
                                          bool isCallValid,
 
2346
                                          GLint x,
 
2347
                                          GLint y,
 
2348
                                          GLsizei width,
 
2349
                                          GLsizei height,
 
2350
                                          GLenum format,
 
2351
                                          GLenum type,
 
2352
                                          GLsizei bufSize,
 
2353
                                          GLsizei *length,
 
2354
                                          GLsizei *columns,
 
2355
                                          GLsizei *rows,
 
2356
                                          void *pixels,
 
2357
                                          angle::ParamCapture *paramCapture);
 
2358
void CaptureReadPixelsRobustANGLE_rows(const State &glState,
 
2359
                                       bool isCallValid,
 
2360
                                       GLint x,
 
2361
                                       GLint y,
 
2362
                                       GLsizei width,
 
2363
                                       GLsizei height,
 
2364
                                       GLenum format,
 
2365
                                       GLenum type,
 
2366
                                       GLsizei bufSize,
 
2367
                                       GLsizei *length,
 
2368
                                       GLsizei *columns,
 
2369
                                       GLsizei *rows,
 
2370
                                       void *pixels,
 
2371
                                       angle::ParamCapture *paramCapture);
 
2372
void CaptureReadPixelsRobustANGLE_pixels(const State &glState,
 
2373
                                         bool isCallValid,
 
2374
                                         GLint x,
 
2375
                                         GLint y,
 
2376
                                         GLsizei width,
 
2377
                                         GLsizei height,
 
2378
                                         GLenum format,
 
2379
                                         GLenum type,
 
2380
                                         GLsizei bufSize,
 
2381
                                         GLsizei *length,
 
2382
                                         GLsizei *columns,
 
2383
                                         GLsizei *rows,
 
2384
                                         void *pixels,
 
2385
                                         angle::ParamCapture *paramCapture);
 
2386
void CaptureTexImage2DRobustANGLE_pixels(const State &glState,
 
2387
                                         bool isCallValid,
 
2388
                                         TextureTarget targetPacked,
 
2389
                                         GLint level,
 
2390
                                         GLint internalformat,
 
2391
                                         GLsizei width,
 
2392
                                         GLsizei height,
 
2393
                                         GLint border,
 
2394
                                         GLenum format,
 
2395
                                         GLenum type,
 
2396
                                         GLsizei bufSize,
 
2397
                                         const void *pixels,
 
2398
                                         angle::ParamCapture *paramCapture);
 
2399
void CaptureTexParameterfvRobustANGLE_params(const State &glState,
 
2400
                                             bool isCallValid,
 
2401
                                             TextureType targetPacked,
 
2402
                                             GLenum pname,
 
2403
                                             GLsizei bufSize,
 
2404
                                             const GLfloat *params,
 
2405
                                             angle::ParamCapture *paramCapture);
 
2406
void CaptureTexParameterivRobustANGLE_params(const State &glState,
 
2407
                                             bool isCallValid,
 
2408
                                             TextureType targetPacked,
 
2409
                                             GLenum pname,
 
2410
                                             GLsizei bufSize,
 
2411
                                             const GLint *params,
 
2412
                                             angle::ParamCapture *paramCapture);
 
2413
void CaptureTexSubImage2DRobustANGLE_pixels(const State &glState,
 
2414
                                            bool isCallValid,
 
2415
                                            TextureTarget targetPacked,
 
2416
                                            GLint level,
 
2417
                                            GLint xoffset,
 
2418
                                            GLint yoffset,
 
2419
                                            GLsizei width,
 
2420
                                            GLsizei height,
 
2421
                                            GLenum format,
 
2422
                                            GLenum type,
 
2423
                                            GLsizei bufSize,
 
2424
                                            const void *pixels,
 
2425
                                            angle::ParamCapture *paramCapture);
 
2426
void CaptureTexImage3DRobustANGLE_pixels(const State &glState,
 
2427
                                         bool isCallValid,
 
2428
                                         TextureTarget targetPacked,
 
2429
                                         GLint level,
 
2430
                                         GLint internalformat,
 
2431
                                         GLsizei width,
 
2432
                                         GLsizei height,
 
2433
                                         GLsizei depth,
 
2434
                                         GLint border,
 
2435
                                         GLenum format,
 
2436
                                         GLenum type,
 
2437
                                         GLsizei bufSize,
 
2438
                                         const void *pixels,
 
2439
                                         angle::ParamCapture *paramCapture);
 
2440
void CaptureTexSubImage3DRobustANGLE_pixels(const State &glState,
 
2441
                                            bool isCallValid,
 
2442
                                            TextureTarget targetPacked,
 
2443
                                            GLint level,
 
2444
                                            GLint xoffset,
 
2445
                                            GLint yoffset,
 
2446
                                            GLint zoffset,
 
2447
                                            GLsizei width,
 
2448
                                            GLsizei height,
 
2449
                                            GLsizei depth,
 
2450
                                            GLenum format,
 
2451
                                            GLenum type,
 
2452
                                            GLsizei bufSize,
 
2453
                                            const void *pixels,
 
2454
                                            angle::ParamCapture *paramCapture);
 
2455
void CaptureCompressedTexImage2DRobustANGLE_data(const State &glState,
 
2456
                                                 bool isCallValid,
 
2457
                                                 TextureTarget targetPacked,
 
2458
                                                 GLint level,
 
2459
                                                 GLenum internalformat,
 
2460
                                                 GLsizei width,
 
2461
                                                 GLsizei height,
 
2462
                                                 GLint border,
 
2463
                                                 GLsizei imageSize,
 
2464
                                                 GLsizei dataSize,
 
2465
                                                 const GLvoid *data,
 
2466
                                                 angle::ParamCapture *paramCapture);
 
2467
void CaptureCompressedTexSubImage2DRobustANGLE_data(const State &glState,
 
2468
                                                    bool isCallValid,
 
2469
                                                    TextureTarget targetPacked,
 
2470
                                                    GLint level,
 
2471
                                                    GLsizei xoffset,
 
2472
                                                    GLsizei yoffset,
 
2473
                                                    GLsizei width,
 
2474
                                                    GLsizei height,
 
2475
                                                    GLenum format,
 
2476
                                                    GLsizei imageSize,
 
2477
                                                    GLsizei dataSize,
 
2478
                                                    const GLvoid *data,
 
2479
                                                    angle::ParamCapture *paramCapture);
 
2480
void CaptureCompressedTexImage3DRobustANGLE_data(const State &glState,
 
2481
                                                 bool isCallValid,
 
2482
                                                 TextureTarget targetPacked,
 
2483
                                                 GLint level,
 
2484
                                                 GLenum internalformat,
 
2485
                                                 GLsizei width,
 
2486
                                                 GLsizei height,
 
2487
                                                 GLsizei depth,
 
2488
                                                 GLint border,
 
2489
                                                 GLsizei imageSize,
 
2490
                                                 GLsizei dataSize,
 
2491
                                                 const GLvoid *data,
 
2492
                                                 angle::ParamCapture *paramCapture);
 
2493
void CaptureCompressedTexSubImage3DRobustANGLE_data(const State &glState,
 
2494
                                                    bool isCallValid,
 
2495
                                                    TextureTarget targetPacked,
 
2496
                                                    GLint level,
 
2497
                                                    GLint xoffset,
 
2498
                                                    GLint yoffset,
 
2499
                                                    GLint zoffset,
 
2500
                                                    GLsizei width,
 
2501
                                                    GLsizei height,
 
2502
                                                    GLsizei depth,
 
2503
                                                    GLenum format,
 
2504
                                                    GLsizei imageSize,
 
2505
                                                    GLsizei dataSize,
 
2506
                                                    const GLvoid *data,
 
2507
                                                    angle::ParamCapture *paramCapture);
 
2508
void CaptureGetQueryivRobustANGLE_length(const State &glState,
 
2509
                                         bool isCallValid,
 
2510
                                         QueryType targetPacked,
 
2511
                                         GLenum pname,
 
2512
                                         GLsizei bufSize,
 
2513
                                         GLsizei *length,
 
2514
                                         GLint *params,
 
2515
                                         angle::ParamCapture *paramCapture);
 
2516
void CaptureGetQueryivRobustANGLE_params(const State &glState,
 
2517
                                         bool isCallValid,
 
2518
                                         QueryType targetPacked,
 
2519
                                         GLenum pname,
 
2520
                                         GLsizei bufSize,
 
2521
                                         GLsizei *length,
 
2522
                                         GLint *params,
 
2523
                                         angle::ParamCapture *paramCapture);
 
2524
void CaptureGetQueryObjectuivRobustANGLE_length(const State &glState,
 
2525
                                                bool isCallValid,
 
2526
                                                QueryID idPacked,
 
2527
                                                GLenum pname,
 
2528
                                                GLsizei bufSize,
 
2529
                                                GLsizei *length,
 
2530
                                                GLuint *params,
 
2531
                                                angle::ParamCapture *paramCapture);
 
2532
void CaptureGetQueryObjectuivRobustANGLE_params(const State &glState,
 
2533
                                                bool isCallValid,
 
2534
                                                QueryID idPacked,
 
2535
                                                GLenum pname,
 
2536
                                                GLsizei bufSize,
 
2537
                                                GLsizei *length,
 
2538
                                                GLuint *params,
 
2539
                                                angle::ParamCapture *paramCapture);
 
2540
void CaptureGetBufferPointervRobustANGLE_length(const State &glState,
 
2541
                                                bool isCallValid,
 
2542
                                                BufferBinding targetPacked,
 
2543
                                                GLenum pname,
 
2544
                                                GLsizei bufSize,
 
2545
                                                GLsizei *length,
 
2546
                                                void **params,
 
2547
                                                angle::ParamCapture *paramCapture);
 
2548
void CaptureGetBufferPointervRobustANGLE_params(const State &glState,
 
2549
                                                bool isCallValid,
 
2550
                                                BufferBinding targetPacked,
 
2551
                                                GLenum pname,
 
2552
                                                GLsizei bufSize,
 
2553
                                                GLsizei *length,
 
2554
                                                void **params,
 
2555
                                                angle::ParamCapture *paramCapture);
 
2556
void CaptureGetIntegeri_vRobustANGLE_length(const State &glState,
 
2557
                                            bool isCallValid,
 
2558
                                            GLenum target,
 
2559
                                            GLuint index,
 
2560
                                            GLsizei bufSize,
 
2561
                                            GLsizei *length,
 
2562
                                            GLint *data,
 
2563
                                            angle::ParamCapture *paramCapture);
 
2564
void CaptureGetIntegeri_vRobustANGLE_data(const State &glState,
 
2565
                                          bool isCallValid,
 
2566
                                          GLenum target,
 
2567
                                          GLuint index,
 
2568
                                          GLsizei bufSize,
 
2569
                                          GLsizei *length,
 
2570
                                          GLint *data,
 
2571
                                          angle::ParamCapture *paramCapture);
 
2572
void CaptureGetInternalformativRobustANGLE_length(const State &glState,
 
2573
                                                  bool isCallValid,
 
2574
                                                  GLenum target,
 
2575
                                                  GLenum internalformat,
 
2576
                                                  GLenum pname,
 
2577
                                                  GLsizei bufSize,
 
2578
                                                  GLsizei *length,
 
2579
                                                  GLint *params,
 
2580
                                                  angle::ParamCapture *paramCapture);
 
2581
void CaptureGetInternalformativRobustANGLE_params(const State &glState,
 
2582
                                                  bool isCallValid,
 
2583
                                                  GLenum target,
 
2584
                                                  GLenum internalformat,
 
2585
                                                  GLenum pname,
 
2586
                                                  GLsizei bufSize,
 
2587
                                                  GLsizei *length,
 
2588
                                                  GLint *params,
 
2589
                                                  angle::ParamCapture *paramCapture);
 
2590
void CaptureGetVertexAttribIivRobustANGLE_length(const State &glState,
 
2591
                                                 bool isCallValid,
 
2592
                                                 GLuint index,
 
2593
                                                 GLenum pname,
 
2594
                                                 GLsizei bufSize,
 
2595
                                                 GLsizei *length,
 
2596
                                                 GLint *params,
 
2597
                                                 angle::ParamCapture *paramCapture);
 
2598
void CaptureGetVertexAttribIivRobustANGLE_params(const State &glState,
 
2599
                                                 bool isCallValid,
 
2600
                                                 GLuint index,
 
2601
                                                 GLenum pname,
 
2602
                                                 GLsizei bufSize,
 
2603
                                                 GLsizei *length,
 
2604
                                                 GLint *params,
 
2605
                                                 angle::ParamCapture *paramCapture);
 
2606
void CaptureGetVertexAttribIuivRobustANGLE_length(const State &glState,
 
2607
                                                  bool isCallValid,
 
2608
                                                  GLuint index,
 
2609
                                                  GLenum pname,
 
2610
                                                  GLsizei bufSize,
 
2611
                                                  GLsizei *length,
 
2612
                                                  GLuint *params,
 
2613
                                                  angle::ParamCapture *paramCapture);
 
2614
void CaptureGetVertexAttribIuivRobustANGLE_params(const State &glState,
 
2615
                                                  bool isCallValid,
 
2616
                                                  GLuint index,
 
2617
                                                  GLenum pname,
 
2618
                                                  GLsizei bufSize,
 
2619
                                                  GLsizei *length,
 
2620
                                                  GLuint *params,
 
2621
                                                  angle::ParamCapture *paramCapture);
 
2622
void CaptureGetUniformuivRobustANGLE_length(const State &glState,
 
2623
                                            bool isCallValid,
 
2624
                                            ShaderProgramID programPacked,
 
2625
                                            GLint location,
 
2626
                                            GLsizei bufSize,
 
2627
                                            GLsizei *length,
 
2628
                                            GLuint *params,
 
2629
                                            angle::ParamCapture *paramCapture);
 
2630
void CaptureGetUniformuivRobustANGLE_params(const State &glState,
 
2631
                                            bool isCallValid,
 
2632
                                            ShaderProgramID programPacked,
 
2633
                                            GLint location,
 
2634
                                            GLsizei bufSize,
 
2635
                                            GLsizei *length,
 
2636
                                            GLuint *params,
 
2637
                                            angle::ParamCapture *paramCapture);
 
2638
void CaptureGetActiveUniformBlockivRobustANGLE_length(const State &glState,
 
2639
                                                      bool isCallValid,
 
2640
                                                      ShaderProgramID programPacked,
 
2641
                                                      GLuint uniformBlockIndex,
 
2642
                                                      GLenum pname,
 
2643
                                                      GLsizei bufSize,
 
2644
                                                      GLsizei *length,
 
2645
                                                      GLint *params,
 
2646
                                                      angle::ParamCapture *paramCapture);
 
2647
void CaptureGetActiveUniformBlockivRobustANGLE_params(const State &glState,
 
2648
                                                      bool isCallValid,
 
2649
                                                      ShaderProgramID programPacked,
 
2650
                                                      GLuint uniformBlockIndex,
 
2651
                                                      GLenum pname,
 
2652
                                                      GLsizei bufSize,
 
2653
                                                      GLsizei *length,
 
2654
                                                      GLint *params,
 
2655
                                                      angle::ParamCapture *paramCapture);
 
2656
void CaptureGetInteger64vRobustANGLE_length(const State &glState,
 
2657
                                            bool isCallValid,
 
2658
                                            GLenum pname,
 
2659
                                            GLsizei bufSize,
 
2660
                                            GLsizei *length,
 
2661
                                            GLint64 *data,
 
2662
                                            angle::ParamCapture *paramCapture);
 
2663
void CaptureGetInteger64vRobustANGLE_data(const State &glState,
 
2664
                                          bool isCallValid,
 
2665
                                          GLenum pname,
 
2666
                                          GLsizei bufSize,
 
2667
                                          GLsizei *length,
 
2668
                                          GLint64 *data,
 
2669
                                          angle::ParamCapture *paramCapture);
 
2670
void CaptureGetInteger64i_vRobustANGLE_length(const State &glState,
 
2671
                                              bool isCallValid,
 
2672
                                              GLenum target,
 
2673
                                              GLuint index,
 
2674
                                              GLsizei bufSize,
 
2675
                                              GLsizei *length,
 
2676
                                              GLint64 *data,
 
2677
                                              angle::ParamCapture *paramCapture);
 
2678
void CaptureGetInteger64i_vRobustANGLE_data(const State &glState,
 
2679
                                            bool isCallValid,
 
2680
                                            GLenum target,
 
2681
                                            GLuint index,
 
2682
                                            GLsizei bufSize,
 
2683
                                            GLsizei *length,
 
2684
                                            GLint64 *data,
 
2685
                                            angle::ParamCapture *paramCapture);
 
2686
void CaptureGetBufferParameteri64vRobustANGLE_length(const State &glState,
 
2687
                                                     bool isCallValid,
 
2688
                                                     BufferBinding targetPacked,
 
2689
                                                     GLenum pname,
 
2690
                                                     GLsizei bufSize,
 
2691
                                                     GLsizei *length,
 
2692
                                                     GLint64 *params,
 
2693
                                                     angle::ParamCapture *paramCapture);
 
2694
void CaptureGetBufferParameteri64vRobustANGLE_params(const State &glState,
 
2695
                                                     bool isCallValid,
 
2696
                                                     BufferBinding targetPacked,
 
2697
                                                     GLenum pname,
 
2698
                                                     GLsizei bufSize,
 
2699
                                                     GLsizei *length,
 
2700
                                                     GLint64 *params,
 
2701
                                                     angle::ParamCapture *paramCapture);
 
2702
void CaptureSamplerParameterivRobustANGLE_param(const State &glState,
 
2703
                                                bool isCallValid,
 
2704
                                                SamplerID samplerPacked,
 
2705
                                                GLuint pname,
 
2706
                                                GLsizei bufSize,
 
2707
                                                const GLint *param,
 
2708
                                                angle::ParamCapture *paramCapture);
 
2709
void CaptureSamplerParameterfvRobustANGLE_param(const State &glState,
 
2710
                                                bool isCallValid,
 
2711
                                                SamplerID samplerPacked,
 
2712
                                                GLenum pname,
 
2713
                                                GLsizei bufSize,
 
2714
                                                const GLfloat *param,
 
2715
                                                angle::ParamCapture *paramCapture);
 
2716
void CaptureGetSamplerParameterivRobustANGLE_length(const State &glState,
 
2717
                                                    bool isCallValid,
 
2718
                                                    SamplerID samplerPacked,
 
2719
                                                    GLenum pname,
 
2720
                                                    GLsizei bufSize,
 
2721
                                                    GLsizei *length,
 
2722
                                                    GLint *params,
 
2723
                                                    angle::ParamCapture *paramCapture);
 
2724
void CaptureGetSamplerParameterivRobustANGLE_params(const State &glState,
 
2725
                                                    bool isCallValid,
 
2726
                                                    SamplerID samplerPacked,
 
2727
                                                    GLenum pname,
 
2728
                                                    GLsizei bufSize,
 
2729
                                                    GLsizei *length,
 
2730
                                                    GLint *params,
 
2731
                                                    angle::ParamCapture *paramCapture);
 
2732
void CaptureGetSamplerParameterfvRobustANGLE_length(const State &glState,
 
2733
                                                    bool isCallValid,
 
2734
                                                    SamplerID samplerPacked,
 
2735
                                                    GLenum pname,
 
2736
                                                    GLsizei bufSize,
 
2737
                                                    GLsizei *length,
 
2738
                                                    GLfloat *params,
 
2739
                                                    angle::ParamCapture *paramCapture);
 
2740
void CaptureGetSamplerParameterfvRobustANGLE_params(const State &glState,
 
2741
                                                    bool isCallValid,
 
2742
                                                    SamplerID samplerPacked,
 
2743
                                                    GLenum pname,
 
2744
                                                    GLsizei bufSize,
 
2745
                                                    GLsizei *length,
 
2746
                                                    GLfloat *params,
 
2747
                                                    angle::ParamCapture *paramCapture);
 
2748
void CaptureGetFramebufferParameterivRobustANGLE_length(const State &glState,
 
2749
                                                        bool isCallValid,
 
2750
                                                        GLenum target,
 
2751
                                                        GLenum pname,
 
2752
                                                        GLsizei bufSize,
 
2753
                                                        GLsizei *length,
 
2754
                                                        GLint *params,
 
2755
                                                        angle::ParamCapture *paramCapture);
 
2756
void CaptureGetFramebufferParameterivRobustANGLE_params(const State &glState,
 
2757
                                                        bool isCallValid,
 
2758
                                                        GLenum target,
 
2759
                                                        GLenum pname,
 
2760
                                                        GLsizei bufSize,
 
2761
                                                        GLsizei *length,
 
2762
                                                        GLint *params,
 
2763
                                                        angle::ParamCapture *paramCapture);
 
2764
void CaptureGetProgramInterfaceivRobustANGLE_length(const State &glState,
 
2765
                                                    bool isCallValid,
 
2766
                                                    ShaderProgramID programPacked,
 
2767
                                                    GLenum programInterface,
 
2768
                                                    GLenum pname,
 
2769
                                                    GLsizei bufSize,
 
2770
                                                    GLsizei *length,
 
2771
                                                    GLint *params,
 
2772
                                                    angle::ParamCapture *paramCapture);
 
2773
void CaptureGetProgramInterfaceivRobustANGLE_params(const State &glState,
 
2774
                                                    bool isCallValid,
 
2775
                                                    ShaderProgramID programPacked,
 
2776
                                                    GLenum programInterface,
 
2777
                                                    GLenum pname,
 
2778
                                                    GLsizei bufSize,
 
2779
                                                    GLsizei *length,
 
2780
                                                    GLint *params,
 
2781
                                                    angle::ParamCapture *paramCapture);
 
2782
void CaptureGetBooleani_vRobustANGLE_length(const State &glState,
 
2783
                                            bool isCallValid,
 
2784
                                            GLenum target,
 
2785
                                            GLuint index,
 
2786
                                            GLsizei bufSize,
 
2787
                                            GLsizei *length,
 
2788
                                            GLboolean *data,
 
2789
                                            angle::ParamCapture *paramCapture);
 
2790
void CaptureGetBooleani_vRobustANGLE_data(const State &glState,
 
2791
                                          bool isCallValid,
 
2792
                                          GLenum target,
 
2793
                                          GLuint index,
 
2794
                                          GLsizei bufSize,
 
2795
                                          GLsizei *length,
 
2796
                                          GLboolean *data,
 
2797
                                          angle::ParamCapture *paramCapture);
 
2798
void CaptureGetMultisamplefvRobustANGLE_length(const State &glState,
 
2799
                                               bool isCallValid,
 
2800
                                               GLenum pname,
 
2801
                                               GLuint index,
 
2802
                                               GLsizei bufSize,
 
2803
                                               GLsizei *length,
 
2804
                                               GLfloat *val,
 
2805
                                               angle::ParamCapture *paramCapture);
 
2806
void CaptureGetMultisamplefvRobustANGLE_val(const State &glState,
 
2807
                                            bool isCallValid,
 
2808
                                            GLenum pname,
 
2809
                                            GLuint index,
 
2810
                                            GLsizei bufSize,
 
2811
                                            GLsizei *length,
 
2812
                                            GLfloat *val,
 
2813
                                            angle::ParamCapture *paramCapture);
 
2814
void CaptureGetTexLevelParameterivRobustANGLE_length(const State &glState,
 
2815
                                                     bool isCallValid,
 
2816
                                                     TextureTarget targetPacked,
 
2817
                                                     GLint level,
 
2818
                                                     GLenum pname,
 
2819
                                                     GLsizei bufSize,
 
2820
                                                     GLsizei *length,
 
2821
                                                     GLint *params,
 
2822
                                                     angle::ParamCapture *paramCapture);
 
2823
void CaptureGetTexLevelParameterivRobustANGLE_params(const State &glState,
 
2824
                                                     bool isCallValid,
 
2825
                                                     TextureTarget targetPacked,
 
2826
                                                     GLint level,
 
2827
                                                     GLenum pname,
 
2828
                                                     GLsizei bufSize,
 
2829
                                                     GLsizei *length,
 
2830
                                                     GLint *params,
 
2831
                                                     angle::ParamCapture *paramCapture);
 
2832
void CaptureGetTexLevelParameterfvRobustANGLE_length(const State &glState,
 
2833
                                                     bool isCallValid,
 
2834
                                                     TextureTarget targetPacked,
 
2835
                                                     GLint level,
 
2836
                                                     GLenum pname,
 
2837
                                                     GLsizei bufSize,
 
2838
                                                     GLsizei *length,
 
2839
                                                     GLfloat *params,
 
2840
                                                     angle::ParamCapture *paramCapture);
 
2841
void CaptureGetTexLevelParameterfvRobustANGLE_params(const State &glState,
 
2842
                                                     bool isCallValid,
 
2843
                                                     TextureTarget targetPacked,
 
2844
                                                     GLint level,
 
2845
                                                     GLenum pname,
 
2846
                                                     GLsizei bufSize,
 
2847
                                                     GLsizei *length,
 
2848
                                                     GLfloat *params,
 
2849
                                                     angle::ParamCapture *paramCapture);
 
2850
void CaptureGetPointervRobustANGLERobustANGLE_length(const State &glState,
 
2851
                                                     bool isCallValid,
 
2852
                                                     GLenum pname,
 
2853
                                                     GLsizei bufSize,
 
2854
                                                     GLsizei *length,
 
2855
                                                     void **params,
 
2856
                                                     angle::ParamCapture *paramCapture);
 
2857
void CaptureGetPointervRobustANGLERobustANGLE_params(const State &glState,
 
2858
                                                     bool isCallValid,
 
2859
                                                     GLenum pname,
 
2860
                                                     GLsizei bufSize,
 
2861
                                                     GLsizei *length,
 
2862
                                                     void **params,
 
2863
                                                     angle::ParamCapture *paramCapture);
 
2864
void CaptureReadnPixelsRobustANGLE_length(const State &glState,
 
2865
                                          bool isCallValid,
 
2866
                                          GLint x,
 
2867
                                          GLint y,
 
2868
                                          GLsizei width,
 
2869
                                          GLsizei height,
 
2870
                                          GLenum format,
 
2871
                                          GLenum type,
 
2872
                                          GLsizei bufSize,
 
2873
                                          GLsizei *length,
 
2874
                                          GLsizei *columns,
 
2875
                                          GLsizei *rows,
 
2876
                                          void *data,
 
2877
                                          angle::ParamCapture *paramCapture);
 
2878
void CaptureReadnPixelsRobustANGLE_columns(const State &glState,
 
2879
                                           bool isCallValid,
 
2880
                                           GLint x,
 
2881
                                           GLint y,
 
2882
                                           GLsizei width,
 
2883
                                           GLsizei height,
 
2884
                                           GLenum format,
 
2885
                                           GLenum type,
 
2886
                                           GLsizei bufSize,
 
2887
                                           GLsizei *length,
 
2888
                                           GLsizei *columns,
 
2889
                                           GLsizei *rows,
 
2890
                                           void *data,
 
2891
                                           angle::ParamCapture *paramCapture);
 
2892
void CaptureReadnPixelsRobustANGLE_rows(const State &glState,
 
2893
                                        bool isCallValid,
 
2894
                                        GLint x,
 
2895
                                        GLint y,
 
2896
                                        GLsizei width,
 
2897
                                        GLsizei height,
 
2898
                                        GLenum format,
 
2899
                                        GLenum type,
 
2900
                                        GLsizei bufSize,
 
2901
                                        GLsizei *length,
 
2902
                                        GLsizei *columns,
 
2903
                                        GLsizei *rows,
 
2904
                                        void *data,
 
2905
                                        angle::ParamCapture *paramCapture);
 
2906
void CaptureReadnPixelsRobustANGLE_data(const State &glState,
 
2907
                                        bool isCallValid,
 
2908
                                        GLint x,
 
2909
                                        GLint y,
 
2910
                                        GLsizei width,
 
2911
                                        GLsizei height,
 
2912
                                        GLenum format,
 
2913
                                        GLenum type,
 
2914
                                        GLsizei bufSize,
 
2915
                                        GLsizei *length,
 
2916
                                        GLsizei *columns,
 
2917
                                        GLsizei *rows,
 
2918
                                        void *data,
 
2919
                                        angle::ParamCapture *paramCapture);
 
2920
void CaptureGetnUniformfvRobustANGLE_length(const State &glState,
 
2921
                                            bool isCallValid,
 
2922
                                            ShaderProgramID programPacked,
 
2923
                                            GLint location,
 
2924
                                            GLsizei bufSize,
 
2925
                                            GLsizei *length,
 
2926
                                            GLfloat *params,
 
2927
                                            angle::ParamCapture *paramCapture);
 
2928
void CaptureGetnUniformfvRobustANGLE_params(const State &glState,
 
2929
                                            bool isCallValid,
 
2930
                                            ShaderProgramID programPacked,
 
2931
                                            GLint location,
 
2932
                                            GLsizei bufSize,
 
2933
                                            GLsizei *length,
 
2934
                                            GLfloat *params,
 
2935
                                            angle::ParamCapture *paramCapture);
 
2936
void CaptureGetnUniformivRobustANGLE_length(const State &glState,
 
2937
                                            bool isCallValid,
 
2938
                                            ShaderProgramID programPacked,
 
2939
                                            GLint location,
 
2940
                                            GLsizei bufSize,
 
2941
                                            GLsizei *length,
 
2942
                                            GLint *params,
 
2943
                                            angle::ParamCapture *paramCapture);
 
2944
void CaptureGetnUniformivRobustANGLE_params(const State &glState,
 
2945
                                            bool isCallValid,
 
2946
                                            ShaderProgramID programPacked,
 
2947
                                            GLint location,
 
2948
                                            GLsizei bufSize,
 
2949
                                            GLsizei *length,
 
2950
                                            GLint *params,
 
2951
                                            angle::ParamCapture *paramCapture);
 
2952
void CaptureGetnUniformuivRobustANGLE_length(const State &glState,
 
2953
                                             bool isCallValid,
 
2954
                                             ShaderProgramID programPacked,
 
2955
                                             GLint location,
 
2956
                                             GLsizei bufSize,
 
2957
                                             GLsizei *length,
 
2958
                                             GLuint *params,
 
2959
                                             angle::ParamCapture *paramCapture);
 
2960
void CaptureGetnUniformuivRobustANGLE_params(const State &glState,
 
2961
                                             bool isCallValid,
 
2962
                                             ShaderProgramID programPacked,
 
2963
                                             GLint location,
 
2964
                                             GLsizei bufSize,
 
2965
                                             GLsizei *length,
 
2966
                                             GLuint *params,
 
2967
                                             angle::ParamCapture *paramCapture);
 
2968
void CaptureTexParameterIivRobustANGLE_params(const State &glState,
 
2969
                                              bool isCallValid,
 
2970
                                              TextureType targetPacked,
 
2971
                                              GLenum pname,
 
2972
                                              GLsizei bufSize,
 
2973
                                              const GLint *params,
 
2974
                                              angle::ParamCapture *paramCapture);
 
2975
void CaptureTexParameterIuivRobustANGLE_params(const State &glState,
 
2976
                                               bool isCallValid,
 
2977
                                               TextureType targetPacked,
 
2978
                                               GLenum pname,
 
2979
                                               GLsizei bufSize,
 
2980
                                               const GLuint *params,
 
2981
                                               angle::ParamCapture *paramCapture);
 
2982
void CaptureGetTexParameterIivRobustANGLE_length(const State &glState,
 
2983
                                                 bool isCallValid,
 
2984
                                                 TextureType targetPacked,
 
2985
                                                 GLenum pname,
 
2986
                                                 GLsizei bufSize,
 
2987
                                                 GLsizei *length,
 
2988
                                                 GLint *params,
 
2989
                                                 angle::ParamCapture *paramCapture);
 
2990
void CaptureGetTexParameterIivRobustANGLE_params(const State &glState,
 
2991
                                                 bool isCallValid,
 
2992
                                                 TextureType targetPacked,
 
2993
                                                 GLenum pname,
 
2994
                                                 GLsizei bufSize,
 
2995
                                                 GLsizei *length,
 
2996
                                                 GLint *params,
 
2997
                                                 angle::ParamCapture *paramCapture);
 
2998
void CaptureGetTexParameterIuivRobustANGLE_length(const State &glState,
 
2999
                                                  bool isCallValid,
 
3000
                                                  TextureType targetPacked,
 
3001
                                                  GLenum pname,
 
3002
                                                  GLsizei bufSize,
 
3003
                                                  GLsizei *length,
 
3004
                                                  GLuint *params,
 
3005
                                                  angle::ParamCapture *paramCapture);
 
3006
void CaptureGetTexParameterIuivRobustANGLE_params(const State &glState,
 
3007
                                                  bool isCallValid,
 
3008
                                                  TextureType targetPacked,
 
3009
                                                  GLenum pname,
 
3010
                                                  GLsizei bufSize,
 
3011
                                                  GLsizei *length,
 
3012
                                                  GLuint *params,
 
3013
                                                  angle::ParamCapture *paramCapture);
 
3014
void CaptureSamplerParameterIivRobustANGLE_param(const State &glState,
 
3015
                                                 bool isCallValid,
 
3016
                                                 SamplerID samplerPacked,
 
3017
                                                 GLenum pname,
 
3018
                                                 GLsizei bufSize,
 
3019
                                                 const GLint *param,
 
3020
                                                 angle::ParamCapture *paramCapture);
 
3021
void CaptureSamplerParameterIuivRobustANGLE_param(const State &glState,
 
3022
                                                  bool isCallValid,
 
3023
                                                  SamplerID samplerPacked,
 
3024
                                                  GLenum pname,
 
3025
                                                  GLsizei bufSize,
 
3026
                                                  const GLuint *param,
 
3027
                                                  angle::ParamCapture *paramCapture);
 
3028
void CaptureGetSamplerParameterIivRobustANGLE_length(const State &glState,
 
3029
                                                     bool isCallValid,
 
3030
                                                     SamplerID samplerPacked,
 
3031
                                                     GLenum pname,
 
3032
                                                     GLsizei bufSize,
 
3033
                                                     GLsizei *length,
 
3034
                                                     GLint *params,
 
3035
                                                     angle::ParamCapture *paramCapture);
 
3036
void CaptureGetSamplerParameterIivRobustANGLE_params(const State &glState,
 
3037
                                                     bool isCallValid,
 
3038
                                                     SamplerID samplerPacked,
 
3039
                                                     GLenum pname,
 
3040
                                                     GLsizei bufSize,
 
3041
                                                     GLsizei *length,
 
3042
                                                     GLint *params,
 
3043
                                                     angle::ParamCapture *paramCapture);
 
3044
void CaptureGetSamplerParameterIuivRobustANGLE_length(const State &glState,
 
3045
                                                      bool isCallValid,
 
3046
                                                      SamplerID samplerPacked,
 
3047
                                                      GLenum pname,
 
3048
                                                      GLsizei bufSize,
 
3049
                                                      GLsizei *length,
 
3050
                                                      GLuint *params,
 
3051
                                                      angle::ParamCapture *paramCapture);
 
3052
void CaptureGetSamplerParameterIuivRobustANGLE_params(const State &glState,
 
3053
                                                      bool isCallValid,
 
3054
                                                      SamplerID samplerPacked,
 
3055
                                                      GLenum pname,
 
3056
                                                      GLsizei bufSize,
 
3057
                                                      GLsizei *length,
 
3058
                                                      GLuint *params,
 
3059
                                                      angle::ParamCapture *paramCapture);
 
3060
void CaptureGetQueryObjectivRobustANGLE_length(const State &glState,
 
3061
                                               bool isCallValid,
 
3062
                                               QueryID idPacked,
 
3063
                                               GLenum pname,
 
3064
                                               GLsizei bufSize,
 
3065
                                               GLsizei *length,
 
3066
                                               GLint *params,
 
3067
                                               angle::ParamCapture *paramCapture);
 
3068
void CaptureGetQueryObjectivRobustANGLE_params(const State &glState,
 
3069
                                               bool isCallValid,
 
3070
                                               QueryID idPacked,
 
3071
                                               GLenum pname,
 
3072
                                               GLsizei bufSize,
 
3073
                                               GLsizei *length,
 
3074
                                               GLint *params,
 
3075
                                               angle::ParamCapture *paramCapture);
 
3076
void CaptureGetQueryObjecti64vRobustANGLE_length(const State &glState,
 
3077
                                                 bool isCallValid,
 
3078
                                                 QueryID idPacked,
 
3079
                                                 GLenum pname,
 
3080
                                                 GLsizei bufSize,
 
3081
                                                 GLsizei *length,
 
3082
                                                 GLint64 *params,
 
3083
                                                 angle::ParamCapture *paramCapture);
 
3084
void CaptureGetQueryObjecti64vRobustANGLE_params(const State &glState,
 
3085
                                                 bool isCallValid,
 
3086
                                                 QueryID idPacked,
 
3087
                                                 GLenum pname,
 
3088
                                                 GLsizei bufSize,
 
3089
                                                 GLsizei *length,
 
3090
                                                 GLint64 *params,
 
3091
                                                 angle::ParamCapture *paramCapture);
 
3092
void CaptureGetQueryObjectui64vRobustANGLE_length(const State &glState,
 
3093
                                                  bool isCallValid,
 
3094
                                                  QueryID idPacked,
 
3095
                                                  GLenum pname,
 
3096
                                                  GLsizei bufSize,
 
3097
                                                  GLsizei *length,
 
3098
                                                  GLuint64 *params,
 
3099
                                                  angle::ParamCapture *paramCapture);
 
3100
void CaptureGetQueryObjectui64vRobustANGLE_params(const State &glState,
 
3101
                                                  bool isCallValid,
 
3102
                                                  QueryID idPacked,
 
3103
                                                  GLenum pname,
 
3104
                                                  GLsizei bufSize,
 
3105
                                                  GLsizei *length,
 
3106
                                                  GLuint64 *params,
 
3107
                                                  angle::ParamCapture *paramCapture);
 
3108
void CaptureGetTexLevelParameterivANGLE_params(const State &glState,
 
3109
                                               bool isCallValid,
 
3110
                                               TextureTarget targetPacked,
 
3111
                                               GLint level,
 
3112
                                               GLenum pname,
 
3113
                                               GLint *params,
 
3114
                                               angle::ParamCapture *paramCapture);
 
3115
void CaptureGetTexLevelParameterfvANGLE_params(const State &glState,
 
3116
                                               bool isCallValid,
 
3117
                                               TextureTarget targetPacked,
 
3118
                                               GLint level,
 
3119
                                               GLenum pname,
 
3120
                                               GLfloat *params,
 
3121
                                               angle::ParamCapture *paramCapture);
 
3122
void CaptureGetMultisamplefvANGLE_val(const State &glState,
 
3123
                                      bool isCallValid,
 
3124
                                      GLenum pname,
 
3125
                                      GLuint index,
 
3126
                                      GLfloat *val,
 
3127
                                      angle::ParamCapture *paramCapture);
 
3128
void CaptureGetTranslatedShaderSourceANGLE_length(const State &glState,
 
3129
                                                  bool isCallValid,
 
3130
                                                  ShaderProgramID shaderPacked,
 
3131
                                                  GLsizei bufsize,
 
3132
                                                  GLsizei *length,
 
3133
                                                  GLchar *source,
 
3134
                                                  angle::ParamCapture *paramCapture);
 
3135
void CaptureGetTranslatedShaderSourceANGLE_source(const State &glState,
 
3136
                                                  bool isCallValid,
 
3137
                                                  ShaderProgramID shaderPacked,
 
3138
                                                  GLsizei bufsize,
 
3139
                                                  GLsizei *length,
 
3140
                                                  GLchar *source,
 
3141
                                                  angle::ParamCapture *paramCapture);
 
3142
void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
 
3143
                                             bool isCallValid,
 
3144
                                             ShaderProgramID programPacked,
 
3145
                                             GLint location,
 
3146
                                             const GLchar *name,
 
3147
                                             angle::ParamCapture *paramCapture);
 
3148
void CaptureMatrixLoadfCHROMIUM_matrix(const State &glState,
 
3149
                                       bool isCallValid,
 
3150
                                       GLenum matrixMode,
 
3151
                                       const GLfloat *matrix,
 
3152
                                       angle::ParamCapture *paramCapture);
 
3153
void CapturePathCommandsCHROMIUM_commands(const State &glState,
 
3154
                                          bool isCallValid,
 
3155
                                          PathID pathPacked,
 
3156
                                          GLsizei numCommands,
 
3157
                                          const GLubyte *commands,
 
3158
                                          GLsizei numCoords,
 
3159
                                          GLenum coordType,
 
3160
                                          const void *coords,
 
3161
                                          angle::ParamCapture *paramCapture);
 
3162
void CapturePathCommandsCHROMIUM_coords(const State &glState,
 
3163
                                        bool isCallValid,
 
3164
                                        PathID pathPacked,
 
3165
                                        GLsizei numCommands,
 
3166
                                        const GLubyte *commands,
 
3167
                                        GLsizei numCoords,
 
3168
                                        GLenum coordType,
 
3169
                                        const void *coords,
 
3170
                                        angle::ParamCapture *paramCapture);
 
3171
void CaptureGetPathParameterfvCHROMIUM_value(const State &glState,
 
3172
                                             bool isCallValid,
 
3173
                                             PathID pathPacked,
 
3174
                                             GLenum pname,
 
3175
                                             GLfloat *value,
 
3176
                                             angle::ParamCapture *paramCapture);
 
3177
void CaptureGetPathParameterivCHROMIUM_value(const State &glState,
 
3178
                                             bool isCallValid,
 
3179
                                             PathID pathPacked,
 
3180
                                             GLenum pname,
 
3181
                                             GLint *value,
 
3182
                                             angle::ParamCapture *paramCapture);
 
3183
void CaptureCoverFillPathInstancedCHROMIUM_paths(const State &glState,
 
3184
                                                 bool isCallValid,
 
3185
                                                 GLsizei numPath,
 
3186
                                                 GLenum pathNameType,
 
3187
                                                 const void *paths,
 
3188
                                                 PathID pathBasePacked,
 
3189
                                                 GLenum coverMode,
 
3190
                                                 GLenum transformType,
 
3191
                                                 const GLfloat *transformValues,
 
3192
                                                 angle::ParamCapture *paramCapture);
 
3193
void CaptureCoverFillPathInstancedCHROMIUM_transformValues(const State &glState,
 
3194
                                                           bool isCallValid,
 
3195
                                                           GLsizei numPath,
 
3196
                                                           GLenum pathNameType,
 
3197
                                                           const void *paths,
 
3198
                                                           PathID pathBasePacked,
 
3199
                                                           GLenum coverMode,
 
3200
                                                           GLenum transformType,
 
3201
                                                           const GLfloat *transformValues,
 
3202
                                                           angle::ParamCapture *paramCapture);
 
3203
void CaptureCoverStrokePathInstancedCHROMIUM_paths(const State &glState,
 
3204
                                                   bool isCallValid,
 
3205
                                                   GLsizei numPath,
 
3206
                                                   GLenum pathNameType,
 
3207
                                                   const void *paths,
 
3208
                                                   PathID pathBasePacked,
 
3209
                                                   GLenum coverMode,
 
3210
                                                   GLenum transformType,
 
3211
                                                   const GLfloat *transformValues,
 
3212
                                                   angle::ParamCapture *paramCapture);
 
3213
void CaptureCoverStrokePathInstancedCHROMIUM_transformValues(const State &glState,
 
3214
                                                             bool isCallValid,
 
3215
                                                             GLsizei numPath,
 
3216
                                                             GLenum pathNameType,
 
3217
                                                             const void *paths,
 
3218
                                                             PathID pathBasePacked,
 
3219
                                                             GLenum coverMode,
 
3220
                                                             GLenum transformType,
 
3221
                                                             const GLfloat *transformValues,
 
3222
                                                             angle::ParamCapture *paramCapture);
 
3223
void CaptureStencilStrokePathInstancedCHROMIUM_paths(const State &glState,
 
3224
                                                     bool isCallValid,
 
3225
                                                     GLsizei numPath,
 
3226
                                                     GLenum pathNameType,
 
3227
                                                     const void *paths,
 
3228
                                                     PathID pathBasePacked,
 
3229
                                                     GLint reference,
 
3230
                                                     GLuint mask,
 
3231
                                                     GLenum transformType,
 
3232
                                                     const GLfloat *transformValues,
 
3233
                                                     angle::ParamCapture *paramCapture);
 
3234
void CaptureStencilStrokePathInstancedCHROMIUM_transformValues(const State &glState,
 
3235
                                                               bool isCallValid,
 
3236
                                                               GLsizei numPath,
 
3237
                                                               GLenum pathNameType,
 
3238
                                                               const void *paths,
 
3239
                                                               PathID pathBasePacked,
 
3240
                                                               GLint reference,
 
3241
                                                               GLuint mask,
 
3242
                                                               GLenum transformType,
 
3243
                                                               const GLfloat *transformValues,
 
3244
                                                               angle::ParamCapture *paramCapture);
 
3245
void CaptureStencilFillPathInstancedCHROMIUM_paths(const State &glState,
 
3246
                                                   bool isCallValid,
 
3247
                                                   GLsizei numPaths,
 
3248
                                                   GLenum pathNameType,
 
3249
                                                   const void *paths,
 
3250
                                                   PathID pathBasePacked,
 
3251
                                                   GLenum fillMode,
 
3252
                                                   GLuint mask,
 
3253
                                                   GLenum transformType,
 
3254
                                                   const GLfloat *transformValues,
 
3255
                                                   angle::ParamCapture *paramCapture);
 
3256
void CaptureStencilFillPathInstancedCHROMIUM_transformValues(const State &glState,
 
3257
                                                             bool isCallValid,
 
3258
                                                             GLsizei numPaths,
 
3259
                                                             GLenum pathNameType,
 
3260
                                                             const void *paths,
 
3261
                                                             PathID pathBasePacked,
 
3262
                                                             GLenum fillMode,
 
3263
                                                             GLuint mask,
 
3264
                                                             GLenum transformType,
 
3265
                                                             const GLfloat *transformValues,
 
3266
                                                             angle::ParamCapture *paramCapture);
 
3267
void CaptureStencilThenCoverFillPathInstancedCHROMIUM_paths(const State &glState,
 
3268
                                                            bool isCallValid,
 
3269
                                                            GLsizei numPaths,
 
3270
                                                            GLenum pathNameType,
 
3271
                                                            const void *paths,
 
3272
                                                            PathID pathBasePacked,
 
3273
                                                            GLenum fillMode,
 
3274
                                                            GLuint mask,
 
3275
                                                            GLenum coverMode,
 
3276
                                                            GLenum transformType,
 
3277
                                                            const GLfloat *transformValues,
 
3278
                                                            angle::ParamCapture *paramCapture);
 
3279
void CaptureStencilThenCoverFillPathInstancedCHROMIUM_transformValues(
 
3280
    const State &glState,
 
3281
    bool isCallValid,
 
3282
    GLsizei numPaths,
 
3283
    GLenum pathNameType,
 
3284
    const void *paths,
 
3285
    PathID pathBasePacked,
 
3286
    GLenum fillMode,
 
3287
    GLuint mask,
 
3288
    GLenum coverMode,
 
3289
    GLenum transformType,
 
3290
    const GLfloat *transformValues,
 
3291
    angle::ParamCapture *paramCapture);
 
3292
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM_paths(const State &glState,
 
3293
                                                              bool isCallValid,
 
3294
                                                              GLsizei numPaths,
 
3295
                                                              GLenum pathNameType,
 
3296
                                                              const void *paths,
 
3297
                                                              PathID pathBasePacked,
 
3298
                                                              GLint reference,
 
3299
                                                              GLuint mask,
 
3300
                                                              GLenum coverMode,
 
3301
                                                              GLenum transformType,
 
3302
                                                              const GLfloat *transformValues,
 
3303
                                                              angle::ParamCapture *paramCapture);
 
3304
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM_transformValues(
 
3305
    const State &glState,
 
3306
    bool isCallValid,
 
3307
    GLsizei numPaths,
 
3308
    GLenum pathNameType,
 
3309
    const void *paths,
 
3310
    PathID pathBasePacked,
 
3311
    GLint reference,
 
3312
    GLuint mask,
 
3313
    GLenum coverMode,
 
3314
    GLenum transformType,
 
3315
    const GLfloat *transformValues,
 
3316
    angle::ParamCapture *paramCapture);
 
3317
void CaptureBindFragmentInputLocationCHROMIUM_name(const State &glState,
 
3318
                                                   bool isCallValid,
 
3319
                                                   ShaderProgramID programsPacked,
 
3320
                                                   GLint location,
 
3321
                                                   const GLchar *name,
 
3322
                                                   angle::ParamCapture *paramCapture);
 
3323
void CaptureProgramPathFragmentInputGenCHROMIUM_coeffs(const State &glState,
 
3324
                                                       bool isCallValid,
 
3325
                                                       ShaderProgramID programPacked,
 
3326
                                                       GLint location,
 
3327
                                                       GLenum genMode,
 
3328
                                                       GLint components,
 
3329
                                                       const GLfloat *coeffs,
 
3330
                                                       angle::ParamCapture *paramCapture);
 
3331
void CaptureBindFragDataLocationEXT_name(const State &glState,
 
3332
                                         bool isCallValid,
 
3333
                                         ShaderProgramID programPacked,
 
3334
                                         GLuint color,
 
3335
                                         const GLchar *name,
 
3336
                                         angle::ParamCapture *paramCapture);
 
3337
void CaptureBindFragDataLocationIndexedEXT_name(const State &glState,
 
3338
                                                bool isCallValid,
 
3339
                                                ShaderProgramID programPacked,
 
3340
                                                GLuint colorNumber,
 
3341
                                                GLuint index,
 
3342
                                                const GLchar *name,
 
3343
                                                angle::ParamCapture *paramCapture);
 
3344
void CaptureGetFragDataIndexEXT_name(const State &glState,
 
3345
                                     bool isCallValid,
 
3346
                                     ShaderProgramID programPacked,
 
3347
                                     const GLchar *name,
 
3348
                                     angle::ParamCapture *paramCapture);
 
3349
void CaptureGetProgramResourceLocationIndexEXT_name(const State &glState,
 
3350
                                                    bool isCallValid,
 
3351
                                                    ShaderProgramID programPacked,
 
3352
                                                    GLenum programInterface,
 
3353
                                                    const GLchar *name,
 
3354
                                                    angle::ParamCapture *paramCapture);
 
3355
void CaptureInsertEventMarkerEXT_marker(const State &glState,
 
3356
                                        bool isCallValid,
 
3357
                                        GLsizei length,
 
3358
                                        const GLchar *marker,
 
3359
                                        angle::ParamCapture *paramCapture);
 
3360
void CapturePushGroupMarkerEXT_marker(const State &glState,
 
3361
                                      bool isCallValid,
 
3362
                                      GLsizei length,
 
3363
                                      const GLchar *marker,
 
3364
                                      angle::ParamCapture *paramCapture);
 
3365
void CaptureDiscardFramebufferEXT_attachments(const State &glState,
 
3366
                                              bool isCallValid,
 
3367
                                              GLenum target,
 
3368
                                              GLsizei numAttachments,
 
3369
                                              const GLenum *attachments,
 
3370
                                              angle::ParamCapture *paramCapture);
 
3371
void CaptureDeleteQueriesEXT_idsPacked(const State &glState,
 
3372
                                       bool isCallValid,
 
3373
                                       GLsizei n,
 
3374
                                       const QueryID *idsPacked,
 
3375
                                       angle::ParamCapture *paramCapture);
 
3376
void CaptureGenQueriesEXT_idsPacked(const State &glState,
 
3377
                                    bool isCallValid,
 
3378
                                    GLsizei n,
 
3379
                                    QueryID *idsPacked,
 
3380
                                    angle::ParamCapture *paramCapture);
 
3381
void CaptureGetQueryObjecti64vEXT_params(const State &glState,
 
3382
                                         bool isCallValid,
 
3383
                                         QueryID idPacked,
 
3384
                                         GLenum pname,
 
3385
                                         GLint64 *params,
 
3386
                                         angle::ParamCapture *paramCapture);
 
3387
void CaptureGetQueryObjectivEXT_params(const State &glState,
 
3388
                                       bool isCallValid,
 
3389
                                       QueryID idPacked,
 
3390
                                       GLenum pname,
 
3391
                                       GLint *params,
 
3392
                                       angle::ParamCapture *paramCapture);
 
3393
void CaptureGetQueryObjectui64vEXT_params(const State &glState,
 
3394
                                          bool isCallValid,
 
3395
                                          QueryID idPacked,
 
3396
                                          GLenum pname,
 
3397
                                          GLuint64 *params,
 
3398
                                          angle::ParamCapture *paramCapture);
 
3399
void CaptureGetQueryObjectuivEXT_params(const State &glState,
 
3400
                                        bool isCallValid,
 
3401
                                        QueryID idPacked,
 
3402
                                        GLenum pname,
 
3403
                                        GLuint *params,
 
3404
                                        angle::ParamCapture *paramCapture);
 
3405
void CaptureGetQueryivEXT_params(const State &glState,
 
3406
                                 bool isCallValid,
 
3407
                                 QueryType targetPacked,
 
3408
                                 GLenum pname,
 
3409
                                 GLint *params,
 
3410
                                 angle::ParamCapture *paramCapture);
 
3411
void CaptureDrawBuffersEXT_bufs(const State &glState,
 
3412
                                bool isCallValid,
 
3413
                                GLsizei n,
 
3414
                                const GLenum *bufs,
 
3415
                                angle::ParamCapture *paramCapture);
 
3416
void CaptureDrawElementsBaseVertexEXT_indices(const State &glState,
 
3417
                                              bool isCallValid,
 
3418
                                              PrimitiveMode modePacked,
 
3419
                                              GLsizei count,
 
3420
                                              DrawElementsType typePacked,
 
3421
                                              const void *indices,
 
3422
                                              GLint basevertex,
 
3423
                                              angle::ParamCapture *paramCapture);
 
3424
void CaptureDrawElementsInstancedBaseVertexEXT_indices(const State &glState,
 
3425
                                                       bool isCallValid,
 
3426
                                                       PrimitiveMode modePacked,
 
3427
                                                       GLsizei count,
 
3428
                                                       DrawElementsType typePacked,
 
3429
                                                       const void *indices,
 
3430
                                                       GLsizei instancecount,
 
3431
                                                       GLint basevertex,
 
3432
                                                       angle::ParamCapture *paramCapture);
 
3433
void CaptureDrawRangeElementsBaseVertexEXT_indices(const State &glState,
 
3434
                                                   bool isCallValid,
 
3435
                                                   PrimitiveMode modePacked,
 
3436
                                                   GLuint start,
 
3437
                                                   GLuint end,
 
3438
                                                   GLsizei count,
 
3439
                                                   DrawElementsType typePacked,
 
3440
                                                   const void *indices,
 
3441
                                                   GLint basevertex,
 
3442
                                                   angle::ParamCapture *paramCapture);
 
3443
void CaptureMultiDrawElementsBaseVertexEXT_count(const State &glState,
 
3444
                                                 bool isCallValid,
 
3445
                                                 PrimitiveMode modePacked,
 
3446
                                                 const GLsizei *count,
 
3447
                                                 DrawElementsType typePacked,
 
3448
                                                 const void *const *indices,
 
3449
                                                 GLsizei primcount,
 
3450
                                                 const GLint *basevertex,
 
3451
                                                 angle::ParamCapture *paramCapture);
 
3452
void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState,
 
3453
                                                   bool isCallValid,
 
3454
                                                   PrimitiveMode modePacked,
 
3455
                                                   const GLsizei *count,
 
3456
                                                   DrawElementsType typePacked,
 
3457
                                                   const void *const *indices,
 
3458
                                                   GLsizei primcount,
 
3459
                                                   const GLint *basevertex,
 
3460
                                                   angle::ParamCapture *paramCapture);
 
3461
void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState,
 
3462
                                                      bool isCallValid,
 
3463
                                                      PrimitiveMode modePacked,
 
3464
                                                      const GLsizei *count,
 
3465
                                                      DrawElementsType typePacked,
 
3466
                                                      const void *const *indices,
 
3467
                                                      GLsizei primcount,
 
3468
                                                      const GLint *basevertex,
 
3469
                                                      angle::ParamCapture *paramCapture);
 
3470
void CaptureDrawElementsInstancedEXT_indices(const State &glState,
 
3471
                                             bool isCallValid,
 
3472
                                             PrimitiveMode modePacked,
 
3473
                                             GLsizei count,
 
3474
                                             DrawElementsType typePacked,
 
3475
                                             const void *indices,
 
3476
                                             GLsizei primcount,
 
3477
                                             angle::ParamCapture *paramCapture);
 
3478
void CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
 
3479
                                                       bool isCallValid,
 
3480
                                                       GLsizei n,
 
3481
                                                       MemoryObjectID *memoryObjectsPacked,
 
3482
                                                       angle::ParamCapture *paramCapture);
 
3483
void CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
 
3484
                                                       bool isCallValid,
 
3485
                                                       GLsizei n,
 
3486
                                                       const MemoryObjectID *memoryObjectsPacked,
 
3487
                                                       angle::ParamCapture *paramCapture);
 
3488
void CaptureGetMemoryObjectParameterivEXT_params(const State &glState,
 
3489
                                                 bool isCallValid,
 
3490
                                                 MemoryObjectID memoryObjectPacked,
 
3491
                                                 GLenum pname,
 
3492
                                                 GLint *params,
 
3493
                                                 angle::ParamCapture *paramCapture);
 
3494
void CaptureGetUnsignedBytevEXT_data(const State &glState,
 
3495
                                     bool isCallValid,
 
3496
                                     GLenum pname,
 
3497
                                     GLubyte *data,
 
3498
                                     angle::ParamCapture *paramCapture);
 
3499
void CaptureGetUnsignedBytei_vEXT_data(const State &glState,
 
3500
                                       bool isCallValid,
 
3501
                                       GLenum target,
 
3502
                                       GLuint index,
 
3503
                                       GLubyte *data,
 
3504
                                       angle::ParamCapture *paramCapture);
 
3505
void CaptureMemoryObjectParameterivEXT_params(const State &glState,
 
3506
                                              bool isCallValid,
 
3507
                                              MemoryObjectID memoryObjectPacked,
 
3508
                                              GLenum pname,
 
3509
                                              const GLint *params,
 
3510
                                              angle::ParamCapture *paramCapture);
 
3511
void CaptureGetnUniformfvEXT_params(const State &glState,
 
3512
                                    bool isCallValid,
 
3513
                                    ShaderProgramID programPacked,
 
3514
                                    GLint location,
 
3515
                                    GLsizei bufSize,
 
3516
                                    GLfloat *params,
 
3517
                                    angle::ParamCapture *paramCapture);
 
3518
void CaptureGetnUniformivEXT_params(const State &glState,
 
3519
                                    bool isCallValid,
 
3520
                                    ShaderProgramID programPacked,
 
3521
                                    GLint location,
 
3522
                                    GLsizei bufSize,
 
3523
                                    GLint *params,
 
3524
                                    angle::ParamCapture *paramCapture);
 
3525
void CaptureReadnPixelsEXT_data(const State &glState,
 
3526
                                bool isCallValid,
 
3527
                                GLint x,
 
3528
                                GLint y,
 
3529
                                GLsizei width,
 
3530
                                GLsizei height,
 
3531
                                GLenum format,
 
3532
                                GLenum type,
 
3533
                                GLsizei bufSize,
 
3534
                                void *data,
 
3535
                                angle::ParamCapture *paramCapture);
 
3536
void CaptureDeleteSemaphoresEXT_semaphoresPacked(const State &glState,
 
3537
                                                 bool isCallValid,
 
3538
                                                 GLsizei n,
 
3539
                                                 const SemaphoreID *semaphoresPacked,
 
3540
                                                 angle::ParamCapture *paramCapture);
 
3541
void CaptureGenSemaphoresEXT_semaphoresPacked(const State &glState,
 
3542
                                              bool isCallValid,
 
3543
                                              GLsizei n,
 
3544
                                              SemaphoreID *semaphoresPacked,
 
3545
                                              angle::ParamCapture *paramCapture);
 
3546
void CaptureGetSemaphoreParameterui64vEXT_params(const State &glState,
 
3547
                                                 bool isCallValid,
 
3548
                                                 SemaphoreID semaphorePacked,
 
3549
                                                 GLenum pname,
 
3550
                                                 GLuint64 *params,
 
3551
                                                 angle::ParamCapture *paramCapture);
 
3552
void CaptureSemaphoreParameterui64vEXT_params(const State &glState,
 
3553
                                              bool isCallValid,
 
3554
                                              SemaphoreID semaphorePacked,
 
3555
                                              GLenum pname,
 
3556
                                              const GLuint64 *params,
 
3557
                                              angle::ParamCapture *paramCapture);
 
3558
void CaptureSignalSemaphoreEXT_buffersPacked(const State &glState,
 
3559
                                             bool isCallValid,
 
3560
                                             SemaphoreID semaphorePacked,
 
3561
                                             GLuint numBufferBarriers,
 
3562
                                             const BufferID *buffersPacked,
 
3563
                                             GLuint numTextureBarriers,
 
3564
                                             const TextureID *texturesPacked,
 
3565
                                             const GLenum *dstLayouts,
 
3566
                                             angle::ParamCapture *paramCapture);
 
3567
void CaptureSignalSemaphoreEXT_texturesPacked(const State &glState,
 
3568
                                              bool isCallValid,
 
3569
                                              SemaphoreID semaphorePacked,
 
3570
                                              GLuint numBufferBarriers,
 
3571
                                              const BufferID *buffersPacked,
 
3572
                                              GLuint numTextureBarriers,
 
3573
                                              const TextureID *texturesPacked,
 
3574
                                              const GLenum *dstLayouts,
 
3575
                                              angle::ParamCapture *paramCapture);
 
3576
void CaptureSignalSemaphoreEXT_dstLayouts(const State &glState,
 
3577
                                          bool isCallValid,
 
3578
                                          SemaphoreID semaphorePacked,
 
3579
                                          GLuint numBufferBarriers,
 
3580
                                          const BufferID *buffersPacked,
 
3581
                                          GLuint numTextureBarriers,
 
3582
                                          const TextureID *texturesPacked,
 
3583
                                          const GLenum *dstLayouts,
 
3584
                                          angle::ParamCapture *paramCapture);
 
3585
void CaptureWaitSemaphoreEXT_buffersPacked(const State &glState,
 
3586
                                           bool isCallValid,
 
3587
                                           SemaphoreID semaphorePacked,
 
3588
                                           GLuint numBufferBarriers,
 
3589
                                           const BufferID *buffersPacked,
 
3590
                                           GLuint numTextureBarriers,
 
3591
                                           const TextureID *texturesPacked,
 
3592
                                           const GLenum *srcLayouts,
 
3593
                                           angle::ParamCapture *paramCapture);
 
3594
void CaptureWaitSemaphoreEXT_texturesPacked(const State &glState,
 
3595
                                            bool isCallValid,
 
3596
                                            SemaphoreID semaphorePacked,
 
3597
                                            GLuint numBufferBarriers,
 
3598
                                            const BufferID *buffersPacked,
 
3599
                                            GLuint numTextureBarriers,
 
3600
                                            const TextureID *texturesPacked,
 
3601
                                            const GLenum *srcLayouts,
 
3602
                                            angle::ParamCapture *paramCapture);
 
3603
void CaptureWaitSemaphoreEXT_srcLayouts(const State &glState,
 
3604
                                        bool isCallValid,
 
3605
                                        SemaphoreID semaphorePacked,
 
3606
                                        GLuint numBufferBarriers,
 
3607
                                        const BufferID *buffersPacked,
 
3608
                                        GLuint numTextureBarriers,
 
3609
                                        const TextureID *texturesPacked,
 
3610
                                        const GLenum *srcLayouts,
 
3611
                                        angle::ParamCapture *paramCapture);
 
3612
void CaptureDebugMessageCallbackKHR_userParam(const State &glState,
 
3613
                                              bool isCallValid,
 
3614
                                              GLDEBUGPROCKHR callback,
 
3615
                                              const void *userParam,
 
3616
                                              angle::ParamCapture *paramCapture);
 
3617
void CaptureDebugMessageControlKHR_ids(const State &glState,
 
3618
                                       bool isCallValid,
 
3619
                                       GLenum source,
 
3620
                                       GLenum type,
 
3621
                                       GLenum severity,
 
3622
                                       GLsizei count,
 
3623
                                       const GLuint *ids,
 
3624
                                       GLboolean enabled,
 
3625
                                       angle::ParamCapture *paramCapture);
 
3626
void CaptureDebugMessageInsertKHR_buf(const State &glState,
 
3627
                                      bool isCallValid,
 
3628
                                      GLenum source,
 
3629
                                      GLenum type,
 
3630
                                      GLuint id,
 
3631
                                      GLenum severity,
 
3632
                                      GLsizei length,
 
3633
                                      const GLchar *buf,
 
3634
                                      angle::ParamCapture *paramCapture);
 
3635
void CaptureGetDebugMessageLogKHR_sources(const State &glState,
 
3636
                                          bool isCallValid,
 
3637
                                          GLuint count,
 
3638
                                          GLsizei bufSize,
 
3639
                                          GLenum *sources,
 
3640
                                          GLenum *types,
 
3641
                                          GLuint *ids,
 
3642
                                          GLenum *severities,
 
3643
                                          GLsizei *lengths,
 
3644
                                          GLchar *messageLog,
 
3645
                                          angle::ParamCapture *paramCapture);
 
3646
void CaptureGetDebugMessageLogKHR_types(const State &glState,
 
3647
                                        bool isCallValid,
 
3648
                                        GLuint count,
 
3649
                                        GLsizei bufSize,
 
3650
                                        GLenum *sources,
 
3651
                                        GLenum *types,
 
3652
                                        GLuint *ids,
 
3653
                                        GLenum *severities,
 
3654
                                        GLsizei *lengths,
 
3655
                                        GLchar *messageLog,
 
3656
                                        angle::ParamCapture *paramCapture);
 
3657
void CaptureGetDebugMessageLogKHR_ids(const State &glState,
 
3658
                                      bool isCallValid,
 
3659
                                      GLuint count,
 
3660
                                      GLsizei bufSize,
 
3661
                                      GLenum *sources,
 
3662
                                      GLenum *types,
 
3663
                                      GLuint *ids,
 
3664
                                      GLenum *severities,
 
3665
                                      GLsizei *lengths,
 
3666
                                      GLchar *messageLog,
 
3667
                                      angle::ParamCapture *paramCapture);
 
3668
void CaptureGetDebugMessageLogKHR_severities(const State &glState,
 
3669
                                             bool isCallValid,
 
3670
                                             GLuint count,
 
3671
                                             GLsizei bufSize,
 
3672
                                             GLenum *sources,
 
3673
                                             GLenum *types,
 
3674
                                             GLuint *ids,
 
3675
                                             GLenum *severities,
 
3676
                                             GLsizei *lengths,
 
3677
                                             GLchar *messageLog,
 
3678
                                             angle::ParamCapture *paramCapture);
 
3679
void CaptureGetDebugMessageLogKHR_lengths(const State &glState,
 
3680
                                          bool isCallValid,
 
3681
                                          GLuint count,
 
3682
                                          GLsizei bufSize,
 
3683
                                          GLenum *sources,
 
3684
                                          GLenum *types,
 
3685
                                          GLuint *ids,
 
3686
                                          GLenum *severities,
 
3687
                                          GLsizei *lengths,
 
3688
                                          GLchar *messageLog,
 
3689
                                          angle::ParamCapture *paramCapture);
 
3690
void CaptureGetDebugMessageLogKHR_messageLog(const State &glState,
 
3691
                                             bool isCallValid,
 
3692
                                             GLuint count,
 
3693
                                             GLsizei bufSize,
 
3694
                                             GLenum *sources,
 
3695
                                             GLenum *types,
 
3696
                                             GLuint *ids,
 
3697
                                             GLenum *severities,
 
3698
                                             GLsizei *lengths,
 
3699
                                             GLchar *messageLog,
 
3700
                                             angle::ParamCapture *paramCapture);
 
3701
void CaptureGetObjectLabelKHR_length(const State &glState,
 
3702
                                     bool isCallValid,
 
3703
                                     GLenum identifier,
 
3704
                                     GLuint name,
 
3705
                                     GLsizei bufSize,
 
3706
                                     GLsizei *length,
 
3707
                                     GLchar *label,
 
3708
                                     angle::ParamCapture *paramCapture);
 
3709
void CaptureGetObjectLabelKHR_label(const State &glState,
 
3710
                                    bool isCallValid,
 
3711
                                    GLenum identifier,
 
3712
                                    GLuint name,
 
3713
                                    GLsizei bufSize,
 
3714
                                    GLsizei *length,
 
3715
                                    GLchar *label,
 
3716
                                    angle::ParamCapture *paramCapture);
 
3717
void CaptureGetObjectPtrLabelKHR_ptr(const State &glState,
 
3718
                                     bool isCallValid,
 
3719
                                     const void *ptr,
 
3720
                                     GLsizei bufSize,
 
3721
                                     GLsizei *length,
 
3722
                                     GLchar *label,
 
3723
                                     angle::ParamCapture *paramCapture);
 
3724
void CaptureGetObjectPtrLabelKHR_length(const State &glState,
 
3725
                                        bool isCallValid,
 
3726
                                        const void *ptr,
 
3727
                                        GLsizei bufSize,
 
3728
                                        GLsizei *length,
 
3729
                                        GLchar *label,
 
3730
                                        angle::ParamCapture *paramCapture);
 
3731
void CaptureGetObjectPtrLabelKHR_label(const State &glState,
 
3732
                                       bool isCallValid,
 
3733
                                       const void *ptr,
 
3734
                                       GLsizei bufSize,
 
3735
                                       GLsizei *length,
 
3736
                                       GLchar *label,
 
3737
                                       angle::ParamCapture *paramCapture);
 
3738
void CaptureGetPointervKHR_params(const State &glState,
 
3739
                                  bool isCallValid,
 
3740
                                  GLenum pname,
 
3741
                                  void **params,
 
3742
                                  angle::ParamCapture *paramCapture);
 
3743
void CaptureObjectLabelKHR_label(const State &glState,
 
3744
                                 bool isCallValid,
 
3745
                                 GLenum identifier,
 
3746
                                 GLuint name,
 
3747
                                 GLsizei length,
 
3748
                                 const GLchar *label,
 
3749
                                 angle::ParamCapture *paramCapture);
 
3750
void CaptureObjectPtrLabelKHR_ptr(const State &glState,
 
3751
                                  bool isCallValid,
 
3752
                                  const void *ptr,
 
3753
                                  GLsizei length,
 
3754
                                  const GLchar *label,
 
3755
                                  angle::ParamCapture *paramCapture);
 
3756
void CaptureObjectPtrLabelKHR_label(const State &glState,
 
3757
                                    bool isCallValid,
 
3758
                                    const void *ptr,
 
3759
                                    GLsizei length,
 
3760
                                    const GLchar *label,
 
3761
                                    angle::ParamCapture *paramCapture);
 
3762
void CapturePushDebugGroupKHR_message(const State &glState,
 
3763
                                      bool isCallValid,
 
3764
                                      GLenum source,
 
3765
                                      GLuint id,
 
3766
                                      GLsizei length,
 
3767
                                      const GLchar *message,
 
3768
                                      angle::ParamCapture *paramCapture);
 
3769
void CaptureDeleteFencesNV_fencesPacked(const State &glState,
 
3770
                                        bool isCallValid,
 
3771
                                        GLsizei n,
 
3772
                                        const FenceNVID *fencesPacked,
 
3773
                                        angle::ParamCapture *paramCapture);
 
3774
void CaptureGenFencesNV_fencesPacked(const State &glState,
 
3775
                                     bool isCallValid,
 
3776
                                     GLsizei n,
 
3777
                                     FenceNVID *fencesPacked,
 
3778
                                     angle::ParamCapture *paramCapture);
 
3779
void CaptureGetFenceivNV_params(const State &glState,
 
3780
                                bool isCallValid,
 
3781
                                FenceNVID fencePacked,
 
3782
                                GLenum pname,
 
3783
                                GLint *params,
 
3784
                                angle::ParamCapture *paramCapture);
 
3785
void CaptureDrawElementsBaseVertexOES_indices(const State &glState,
 
3786
                                              bool isCallValid,
 
3787
                                              PrimitiveMode modePacked,
 
3788
                                              GLsizei count,
 
3789
                                              DrawElementsType typePacked,
 
3790
                                              const void *indices,
 
3791
                                              GLint basevertex,
 
3792
                                              angle::ParamCapture *paramCapture);
 
3793
void CaptureDrawElementsInstancedBaseVertexOES_indices(const State &glState,
 
3794
                                                       bool isCallValid,
 
3795
                                                       PrimitiveMode modePacked,
 
3796
                                                       GLsizei count,
 
3797
                                                       DrawElementsType typePacked,
 
3798
                                                       const void *indices,
 
3799
                                                       GLsizei instancecount,
 
3800
                                                       GLint basevertex,
 
3801
                                                       angle::ParamCapture *paramCapture);
 
3802
void CaptureDrawRangeElementsBaseVertexOES_indices(const State &glState,
 
3803
                                                   bool isCallValid,
 
3804
                                                   PrimitiveMode modePacked,
 
3805
                                                   GLuint start,
 
3806
                                                   GLuint end,
 
3807
                                                   GLsizei count,
 
3808
                                                   DrawElementsType typePacked,
 
3809
                                                   const void *indices,
 
3810
                                                   GLint basevertex,
 
3811
                                                   angle::ParamCapture *paramCapture);
 
3812
void CaptureDrawTexfvOES_coords(const State &glState,
 
3813
                                bool isCallValid,
 
3814
                                const GLfloat *coords,
 
3815
                                angle::ParamCapture *paramCapture);
 
3816
void CaptureDrawTexivOES_coords(const State &glState,
 
3817
                                bool isCallValid,
 
3818
                                const GLint *coords,
 
3819
                                angle::ParamCapture *paramCapture);
 
3820
void CaptureDrawTexsvOES_coords(const State &glState,
 
3821
                                bool isCallValid,
 
3822
                                const GLshort *coords,
 
3823
                                angle::ParamCapture *paramCapture);
 
3824
void CaptureDrawTexxvOES_coords(const State &glState,
 
3825
                                bool isCallValid,
 
3826
                                const GLfixed *coords,
 
3827
                                angle::ParamCapture *paramCapture);
 
3828
void CaptureDeleteFramebuffersOES_framebuffersPacked(const State &glState,
 
3829
                                                     bool isCallValid,
 
3830
                                                     GLsizei n,
 
3831
                                                     const FramebufferID *framebuffersPacked,
 
3832
                                                     angle::ParamCapture *paramCapture);
 
3833
void CaptureDeleteRenderbuffersOES_renderbuffersPacked(const State &glState,
 
3834
                                                       bool isCallValid,
 
3835
                                                       GLsizei n,
 
3836
                                                       const RenderbufferID *renderbuffersPacked,
 
3837
                                                       angle::ParamCapture *paramCapture);
 
3838
void CaptureGenFramebuffersOES_framebuffersPacked(const State &glState,
 
3839
                                                  bool isCallValid,
 
3840
                                                  GLsizei n,
 
3841
                                                  FramebufferID *framebuffersPacked,
 
3842
                                                  angle::ParamCapture *paramCapture);
 
3843
void CaptureGenRenderbuffersOES_renderbuffersPacked(const State &glState,
 
3844
                                                    bool isCallValid,
 
3845
                                                    GLsizei n,
 
3846
                                                    RenderbufferID *renderbuffersPacked,
 
3847
                                                    angle::ParamCapture *paramCapture);
 
3848
void CaptureGetFramebufferAttachmentParameterivOES_params(const State &glState,
 
3849
                                                          bool isCallValid,
 
3850
                                                          GLenum target,
 
3851
                                                          GLenum attachment,
 
3852
                                                          GLenum pname,
 
3853
                                                          GLint *params,
 
3854
                                                          angle::ParamCapture *paramCapture);
 
3855
void CaptureGetRenderbufferParameterivOES_params(const State &glState,
 
3856
                                                 bool isCallValid,
 
3857
                                                 GLenum target,
 
3858
                                                 GLenum pname,
 
3859
                                                 GLint *params,
 
3860
                                                 angle::ParamCapture *paramCapture);
 
3861
void CaptureGetProgramBinaryOES_length(const State &glState,
 
3862
                                       bool isCallValid,
 
3863
                                       ShaderProgramID programPacked,
 
3864
                                       GLsizei bufSize,
 
3865
                                       GLsizei *length,
 
3866
                                       GLenum *binaryFormat,
 
3867
                                       void *binary,
 
3868
                                       angle::ParamCapture *paramCapture);
 
3869
void CaptureGetProgramBinaryOES_binaryFormat(const State &glState,
 
3870
                                             bool isCallValid,
 
3871
                                             ShaderProgramID programPacked,
 
3872
                                             GLsizei bufSize,
 
3873
                                             GLsizei *length,
 
3874
                                             GLenum *binaryFormat,
 
3875
                                             void *binary,
 
3876
                                             angle::ParamCapture *paramCapture);
 
3877
void CaptureGetProgramBinaryOES_binary(const State &glState,
 
3878
                                       bool isCallValid,
 
3879
                                       ShaderProgramID programPacked,
 
3880
                                       GLsizei bufSize,
 
3881
                                       GLsizei *length,
 
3882
                                       GLenum *binaryFormat,
 
3883
                                       void *binary,
 
3884
                                       angle::ParamCapture *paramCapture);
 
3885
void CaptureProgramBinaryOES_binary(const State &glState,
 
3886
                                    bool isCallValid,
 
3887
                                    ShaderProgramID programPacked,
 
3888
                                    GLenum binaryFormat,
 
3889
                                    const void *binary,
 
3890
                                    GLint length,
 
3891
                                    angle::ParamCapture *paramCapture);
 
3892
void CaptureGetBufferPointervOES_params(const State &glState,
 
3893
                                        bool isCallValid,
 
3894
                                        BufferBinding targetPacked,
 
3895
                                        GLenum pname,
 
3896
                                        void **params,
 
3897
                                        angle::ParamCapture *paramCapture);
 
3898
void CaptureMatrixIndexPointerOES_pointer(const State &glState,
 
3899
                                          bool isCallValid,
 
3900
                                          GLint size,
 
3901
                                          GLenum type,
 
3902
                                          GLsizei stride,
 
3903
                                          const void *pointer,
 
3904
                                          angle::ParamCapture *paramCapture);
 
3905
void CaptureWeightPointerOES_pointer(const State &glState,
 
3906
                                     bool isCallValid,
 
3907
                                     GLint size,
 
3908
                                     GLenum type,
 
3909
                                     GLsizei stride,
 
3910
                                     const void *pointer,
 
3911
                                     angle::ParamCapture *paramCapture);
 
3912
void CapturePointSizePointerOES_pointer(const State &glState,
 
3913
                                        bool isCallValid,
 
3914
                                        VertexAttribType typePacked,
 
3915
                                        GLsizei stride,
 
3916
                                        const void *pointer,
 
3917
                                        angle::ParamCapture *paramCapture);
 
3918
void CaptureQueryMatrixxOES_mantissa(const State &glState,
 
3919
                                     bool isCallValid,
 
3920
                                     GLfixed *mantissa,
 
3921
                                     GLint *exponent,
 
3922
                                     angle::ParamCapture *paramCapture);
 
3923
void CaptureQueryMatrixxOES_exponent(const State &glState,
 
3924
                                     bool isCallValid,
 
3925
                                     GLfixed *mantissa,
 
3926
                                     GLint *exponent,
 
3927
                                     angle::ParamCapture *paramCapture);
 
3928
void CaptureCompressedTexImage3DOES_data(const State &glState,
 
3929
                                         bool isCallValid,
 
3930
                                         TextureTarget targetPacked,
 
3931
                                         GLint level,
 
3932
                                         GLenum internalformat,
 
3933
                                         GLsizei width,
 
3934
                                         GLsizei height,
 
3935
                                         GLsizei depth,
 
3936
                                         GLint border,
 
3937
                                         GLsizei imageSize,
 
3938
                                         const void *data,
 
3939
                                         angle::ParamCapture *paramCapture);
 
3940
void CaptureCompressedTexSubImage3DOES_data(const State &glState,
 
3941
                                            bool isCallValid,
 
3942
                                            TextureTarget targetPacked,
 
3943
                                            GLint level,
 
3944
                                            GLint xoffset,
 
3945
                                            GLint yoffset,
 
3946
                                            GLint zoffset,
 
3947
                                            GLsizei width,
 
3948
                                            GLsizei height,
 
3949
                                            GLsizei depth,
 
3950
                                            GLenum format,
 
3951
                                            GLsizei imageSize,
 
3952
                                            const void *data,
 
3953
                                            angle::ParamCapture *paramCapture);
 
3954
void CaptureTexImage3DOES_pixels(const State &glState,
 
3955
                                 bool isCallValid,
 
3956
                                 TextureTarget targetPacked,
 
3957
                                 GLint level,
 
3958
                                 GLenum internalformat,
 
3959
                                 GLsizei width,
 
3960
                                 GLsizei height,
 
3961
                                 GLsizei depth,
 
3962
                                 GLint border,
 
3963
                                 GLenum format,
 
3964
                                 GLenum type,
 
3965
                                 const void *pixels,
 
3966
                                 angle::ParamCapture *paramCapture);
 
3967
void CaptureTexSubImage3DOES_pixels(const State &glState,
 
3968
                                    bool isCallValid,
 
3969
                                    TextureTarget targetPacked,
 
3970
                                    GLint level,
 
3971
                                    GLint xoffset,
 
3972
                                    GLint yoffset,
 
3973
                                    GLint zoffset,
 
3974
                                    GLsizei width,
 
3975
                                    GLsizei height,
 
3976
                                    GLsizei depth,
 
3977
                                    GLenum format,
 
3978
                                    GLenum type,
 
3979
                                    const void *pixels,
 
3980
                                    angle::ParamCapture *paramCapture);
 
3981
void CaptureGetSamplerParameterIivOES_params(const State &glState,
 
3982
                                             bool isCallValid,
 
3983
                                             SamplerID samplerPacked,
 
3984
                                             GLenum pname,
 
3985
                                             GLint *params,
 
3986
                                             angle::ParamCapture *paramCapture);
 
3987
void CaptureGetSamplerParameterIuivOES_params(const State &glState,
 
3988
                                              bool isCallValid,
 
3989
                                              SamplerID samplerPacked,
 
3990
                                              GLenum pname,
 
3991
                                              GLuint *params,
 
3992
                                              angle::ParamCapture *paramCapture);
 
3993
void CaptureGetTexParameterIivOES_params(const State &glState,
 
3994
                                         bool isCallValid,
 
3995
                                         TextureType targetPacked,
 
3996
                                         GLenum pname,
 
3997
                                         GLint *params,
 
3998
                                         angle::ParamCapture *paramCapture);
 
3999
void CaptureGetTexParameterIuivOES_params(const State &glState,
 
4000
                                          bool isCallValid,
 
4001
                                          TextureType targetPacked,
 
4002
                                          GLenum pname,
 
4003
                                          GLuint *params,
 
4004
                                          angle::ParamCapture *paramCapture);
 
4005
void CaptureSamplerParameterIivOES_param(const State &glState,
 
4006
                                         bool isCallValid,
 
4007
                                         SamplerID samplerPacked,
 
4008
                                         GLenum pname,
 
4009
                                         const GLint *param,
 
4010
                                         angle::ParamCapture *paramCapture);
 
4011
void CaptureSamplerParameterIuivOES_param(const State &glState,
 
4012
                                          bool isCallValid,
 
4013
                                          SamplerID samplerPacked,
 
4014
                                          GLenum pname,
 
4015
                                          const GLuint *param,
 
4016
                                          angle::ParamCapture *paramCapture);
 
4017
void CaptureTexParameterIivOES_params(const State &glState,
 
4018
                                      bool isCallValid,
 
4019
                                      TextureType targetPacked,
 
4020
                                      GLenum pname,
 
4021
                                      const GLint *params,
 
4022
                                      angle::ParamCapture *paramCapture);
 
4023
void CaptureTexParameterIuivOES_params(const State &glState,
 
4024
                                       bool isCallValid,
 
4025
                                       TextureType targetPacked,
 
4026
                                       GLenum pname,
 
4027
                                       const GLuint *params,
 
4028
                                       angle::ParamCapture *paramCapture);
 
4029
void CaptureGetTexGenfvOES_params(const State &glState,
 
4030
                                  bool isCallValid,
 
4031
                                  GLenum coord,
 
4032
                                  GLenum pname,
 
4033
                                  GLfloat *params,
 
4034
                                  angle::ParamCapture *paramCapture);
 
4035
void CaptureGetTexGenivOES_params(const State &glState,
 
4036
                                  bool isCallValid,
 
4037
                                  GLenum coord,
 
4038
                                  GLenum pname,
 
4039
                                  GLint *params,
 
4040
                                  angle::ParamCapture *paramCapture);
 
4041
void CaptureGetTexGenxvOES_params(const State &glState,
 
4042
                                  bool isCallValid,
 
4043
                                  GLenum coord,
 
4044
                                  GLenum pname,
 
4045
                                  GLfixed *params,
 
4046
                                  angle::ParamCapture *paramCapture);
 
4047
void CaptureTexGenfvOES_params(const State &glState,
 
4048
                               bool isCallValid,
 
4049
                               GLenum coord,
 
4050
                               GLenum pname,
 
4051
                               const GLfloat *params,
 
4052
                               angle::ParamCapture *paramCapture);
 
4053
void CaptureTexGenivOES_params(const State &glState,
 
4054
                               bool isCallValid,
 
4055
                               GLenum coord,
 
4056
                               GLenum pname,
 
4057
                               const GLint *params,
 
4058
                               angle::ParamCapture *paramCapture);
 
4059
void CaptureTexGenxvOES_params(const State &glState,
 
4060
                               bool isCallValid,
 
4061
                               GLenum coord,
 
4062
                               GLenum pname,
 
4063
                               const GLfixed *params,
 
4064
                               angle::ParamCapture *paramCapture);
 
4065
void CaptureDeleteVertexArraysOES_arraysPacked(const State &glState,
 
4066
                                               bool isCallValid,
 
4067
                                               GLsizei n,
 
4068
                                               const VertexArrayID *arraysPacked,
 
4069
                                               angle::ParamCapture *paramCapture);
 
4070
void CaptureGenVertexArraysOES_arraysPacked(const State &glState,
 
4071
                                            bool isCallValid,
 
4072
                                            GLsizei n,
 
4073
                                            VertexArrayID *arraysPacked,
 
4074
                                            angle::ParamCapture *paramCapture);
 
4075
}  // namespace gl
 
4076
 
 
4077
#endif  // LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_