• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // capture_gl_4_autogen.h:
9 //   Capture functions for the OpenGL ES Desktop GL 4.x entry points.
10 
11 #ifndef LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
12 #define LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
13 
14 #include "common/PackedEnums.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 
17 namespace gl
18 {
19 
20 // Method Captures
21 
22 // GL 4.0
23 angle::CallCapture CaptureBeginQueryIndexed(const State &glState,
24                                             bool isCallValid,
25                                             GLenum target,
26                                             GLuint index,
27                                             QueryID idPacked);
28 angle::CallCapture CaptureDrawTransformFeedback(const State &glState,
29                                                 bool isCallValid,
30                                                 GLenum mode,
31                                                 TransformFeedbackID idPacked);
32 angle::CallCapture CaptureDrawTransformFeedbackStream(const State &glState,
33                                                       bool isCallValid,
34                                                       GLenum mode,
35                                                       TransformFeedbackID idPacked,
36                                                       GLuint stream);
37 angle::CallCapture CaptureEndQueryIndexed(const State &glState,
38                                           bool isCallValid,
39                                           GLenum target,
40                                           GLuint index);
41 angle::CallCapture CaptureGetActiveSubroutineName(const State &glState,
42                                                   bool isCallValid,
43                                                   ShaderProgramID programPacked,
44                                                   GLenum shadertype,
45                                                   GLuint index,
46                                                   GLsizei bufSize,
47                                                   GLsizei *length,
48                                                   GLchar *name);
49 angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState,
50                                                          bool isCallValid,
51                                                          ShaderProgramID programPacked,
52                                                          GLenum shadertype,
53                                                          GLuint index,
54                                                          GLsizei bufSize,
55                                                          GLsizei *length,
56                                                          GLchar *name);
57 angle::CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState,
58                                                        bool isCallValid,
59                                                        ShaderProgramID programPacked,
60                                                        GLenum shadertype,
61                                                        GLuint index,
62                                                        GLenum pname,
63                                                        GLint *values);
64 angle::CallCapture CaptureGetProgramStageiv(const State &glState,
65                                             bool isCallValid,
66                                             ShaderProgramID programPacked,
67                                             GLenum shadertype,
68                                             GLenum pname,
69                                             GLint *values);
70 angle::CallCapture CaptureGetQueryIndexediv(const State &glState,
71                                             bool isCallValid,
72                                             GLenum target,
73                                             GLuint index,
74                                             GLenum pname,
75                                             GLint *params);
76 angle::CallCapture CaptureGetSubroutineIndex(const State &glState,
77                                              bool isCallValid,
78                                              ShaderProgramID programPacked,
79                                              GLenum shadertype,
80                                              const GLchar *name,
81                                              GLuint returnValue);
82 angle::CallCapture CaptureGetSubroutineUniformLocation(const State &glState,
83                                                        bool isCallValid,
84                                                        ShaderProgramID programPacked,
85                                                        GLenum shadertype,
86                                                        const GLchar *name,
87                                                        GLint returnValue);
88 angle::CallCapture CaptureGetUniformSubroutineuiv(const State &glState,
89                                                   bool isCallValid,
90                                                   GLenum shadertype,
91                                                   GLint location,
92                                                   GLuint *params);
93 angle::CallCapture CaptureGetUniformdv(const State &glState,
94                                        bool isCallValid,
95                                        ShaderProgramID programPacked,
96                                        UniformLocation locationPacked,
97                                        GLdouble *params);
98 angle::CallCapture CapturePatchParameterfv(const State &glState,
99                                            bool isCallValid,
100                                            GLenum pname,
101                                            const GLfloat *values);
102 angle::CallCapture CaptureUniform1d(const State &glState,
103                                     bool isCallValid,
104                                     UniformLocation locationPacked,
105                                     GLdouble x);
106 angle::CallCapture CaptureUniform1dv(const State &glState,
107                                      bool isCallValid,
108                                      UniformLocation locationPacked,
109                                      GLsizei count,
110                                      const GLdouble *value);
111 angle::CallCapture CaptureUniform2d(const State &glState,
112                                     bool isCallValid,
113                                     UniformLocation locationPacked,
114                                     GLdouble x,
115                                     GLdouble y);
116 angle::CallCapture CaptureUniform2dv(const State &glState,
117                                      bool isCallValid,
118                                      UniformLocation locationPacked,
119                                      GLsizei count,
120                                      const GLdouble *value);
121 angle::CallCapture CaptureUniform3d(const State &glState,
122                                     bool isCallValid,
123                                     UniformLocation locationPacked,
124                                     GLdouble x,
125                                     GLdouble y,
126                                     GLdouble z);
127 angle::CallCapture CaptureUniform3dv(const State &glState,
128                                      bool isCallValid,
129                                      UniformLocation locationPacked,
130                                      GLsizei count,
131                                      const GLdouble *value);
132 angle::CallCapture CaptureUniform4d(const State &glState,
133                                     bool isCallValid,
134                                     UniformLocation locationPacked,
135                                     GLdouble x,
136                                     GLdouble y,
137                                     GLdouble z,
138                                     GLdouble w);
139 angle::CallCapture CaptureUniform4dv(const State &glState,
140                                      bool isCallValid,
141                                      UniformLocation locationPacked,
142                                      GLsizei count,
143                                      const GLdouble *value);
144 angle::CallCapture CaptureUniformMatrix2dv(const State &glState,
145                                            bool isCallValid,
146                                            UniformLocation locationPacked,
147                                            GLsizei count,
148                                            GLboolean transpose,
149                                            const GLdouble *value);
150 angle::CallCapture CaptureUniformMatrix2x3dv(const State &glState,
151                                              bool isCallValid,
152                                              UniformLocation locationPacked,
153                                              GLsizei count,
154                                              GLboolean transpose,
155                                              const GLdouble *value);
156 angle::CallCapture CaptureUniformMatrix2x4dv(const State &glState,
157                                              bool isCallValid,
158                                              UniformLocation locationPacked,
159                                              GLsizei count,
160                                              GLboolean transpose,
161                                              const GLdouble *value);
162 angle::CallCapture CaptureUniformMatrix3dv(const State &glState,
163                                            bool isCallValid,
164                                            UniformLocation locationPacked,
165                                            GLsizei count,
166                                            GLboolean transpose,
167                                            const GLdouble *value);
168 angle::CallCapture CaptureUniformMatrix3x2dv(const State &glState,
169                                              bool isCallValid,
170                                              UniformLocation locationPacked,
171                                              GLsizei count,
172                                              GLboolean transpose,
173                                              const GLdouble *value);
174 angle::CallCapture CaptureUniformMatrix3x4dv(const State &glState,
175                                              bool isCallValid,
176                                              UniformLocation locationPacked,
177                                              GLsizei count,
178                                              GLboolean transpose,
179                                              const GLdouble *value);
180 angle::CallCapture CaptureUniformMatrix4dv(const State &glState,
181                                            bool isCallValid,
182                                            UniformLocation locationPacked,
183                                            GLsizei count,
184                                            GLboolean transpose,
185                                            const GLdouble *value);
186 angle::CallCapture CaptureUniformMatrix4x2dv(const State &glState,
187                                              bool isCallValid,
188                                              UniformLocation locationPacked,
189                                              GLsizei count,
190                                              GLboolean transpose,
191                                              const GLdouble *value);
192 angle::CallCapture CaptureUniformMatrix4x3dv(const State &glState,
193                                              bool isCallValid,
194                                              UniformLocation locationPacked,
195                                              GLsizei count,
196                                              GLboolean transpose,
197                                              const GLdouble *value);
198 angle::CallCapture CaptureUniformSubroutinesuiv(const State &glState,
199                                                 bool isCallValid,
200                                                 GLenum shadertype,
201                                                 GLsizei count,
202                                                 const GLuint *indices);
203 
204 // GL 4.1
205 angle::CallCapture CaptureDepthRangeArrayv(const State &glState,
206                                            bool isCallValid,
207                                            GLuint first,
208                                            GLsizei count,
209                                            const GLdouble *v);
210 angle::CallCapture CaptureDepthRangeIndexed(const State &glState,
211                                             bool isCallValid,
212                                             GLuint index,
213                                             GLdouble n,
214                                             GLdouble f);
215 angle::CallCapture CaptureGetDoublei_v(const State &glState,
216                                        bool isCallValid,
217                                        GLenum target,
218                                        GLuint index,
219                                        GLdouble *data);
220 angle::CallCapture CaptureGetFloati_v(const State &glState,
221                                       bool isCallValid,
222                                       GLenum target,
223                                       GLuint index,
224                                       GLfloat *data);
225 angle::CallCapture CaptureGetVertexAttribLdv(const State &glState,
226                                              bool isCallValid,
227                                              GLuint index,
228                                              GLenum pname,
229                                              GLdouble *params);
230 angle::CallCapture CaptureProgramUniform1d(const State &glState,
231                                            bool isCallValid,
232                                            ShaderProgramID programPacked,
233                                            UniformLocation locationPacked,
234                                            GLdouble v0);
235 angle::CallCapture CaptureProgramUniform1dv(const State &glState,
236                                             bool isCallValid,
237                                             ShaderProgramID programPacked,
238                                             UniformLocation locationPacked,
239                                             GLsizei count,
240                                             const GLdouble *value);
241 angle::CallCapture CaptureProgramUniform2d(const State &glState,
242                                            bool isCallValid,
243                                            ShaderProgramID programPacked,
244                                            UniformLocation locationPacked,
245                                            GLdouble v0,
246                                            GLdouble v1);
247 angle::CallCapture CaptureProgramUniform2dv(const State &glState,
248                                             bool isCallValid,
249                                             ShaderProgramID programPacked,
250                                             UniformLocation locationPacked,
251                                             GLsizei count,
252                                             const GLdouble *value);
253 angle::CallCapture CaptureProgramUniform3d(const State &glState,
254                                            bool isCallValid,
255                                            ShaderProgramID programPacked,
256                                            UniformLocation locationPacked,
257                                            GLdouble v0,
258                                            GLdouble v1,
259                                            GLdouble v2);
260 angle::CallCapture CaptureProgramUniform3dv(const State &glState,
261                                             bool isCallValid,
262                                             ShaderProgramID programPacked,
263                                             UniformLocation locationPacked,
264                                             GLsizei count,
265                                             const GLdouble *value);
266 angle::CallCapture CaptureProgramUniform4d(const State &glState,
267                                            bool isCallValid,
268                                            ShaderProgramID programPacked,
269                                            UniformLocation locationPacked,
270                                            GLdouble v0,
271                                            GLdouble v1,
272                                            GLdouble v2,
273                                            GLdouble v3);
274 angle::CallCapture CaptureProgramUniform4dv(const State &glState,
275                                             bool isCallValid,
276                                             ShaderProgramID programPacked,
277                                             UniformLocation locationPacked,
278                                             GLsizei count,
279                                             const GLdouble *value);
280 angle::CallCapture CaptureProgramUniformMatrix2dv(const State &glState,
281                                                   bool isCallValid,
282                                                   ShaderProgramID programPacked,
283                                                   UniformLocation locationPacked,
284                                                   GLsizei count,
285                                                   GLboolean transpose,
286                                                   const GLdouble *value);
287 angle::CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState,
288                                                     bool isCallValid,
289                                                     ShaderProgramID programPacked,
290                                                     UniformLocation locationPacked,
291                                                     GLsizei count,
292                                                     GLboolean transpose,
293                                                     const GLdouble *value);
294 angle::CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState,
295                                                     bool isCallValid,
296                                                     ShaderProgramID programPacked,
297                                                     UniformLocation locationPacked,
298                                                     GLsizei count,
299                                                     GLboolean transpose,
300                                                     const GLdouble *value);
301 angle::CallCapture CaptureProgramUniformMatrix3dv(const State &glState,
302                                                   bool isCallValid,
303                                                   ShaderProgramID programPacked,
304                                                   UniformLocation locationPacked,
305                                                   GLsizei count,
306                                                   GLboolean transpose,
307                                                   const GLdouble *value);
308 angle::CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState,
309                                                     bool isCallValid,
310                                                     ShaderProgramID programPacked,
311                                                     UniformLocation locationPacked,
312                                                     GLsizei count,
313                                                     GLboolean transpose,
314                                                     const GLdouble *value);
315 angle::CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState,
316                                                     bool isCallValid,
317                                                     ShaderProgramID programPacked,
318                                                     UniformLocation locationPacked,
319                                                     GLsizei count,
320                                                     GLboolean transpose,
321                                                     const GLdouble *value);
322 angle::CallCapture CaptureProgramUniformMatrix4dv(const State &glState,
323                                                   bool isCallValid,
324                                                   ShaderProgramID programPacked,
325                                                   UniformLocation locationPacked,
326                                                   GLsizei count,
327                                                   GLboolean transpose,
328                                                   const GLdouble *value);
329 angle::CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState,
330                                                     bool isCallValid,
331                                                     ShaderProgramID programPacked,
332                                                     UniformLocation locationPacked,
333                                                     GLsizei count,
334                                                     GLboolean transpose,
335                                                     const GLdouble *value);
336 angle::CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState,
337                                                     bool isCallValid,
338                                                     ShaderProgramID programPacked,
339                                                     UniformLocation locationPacked,
340                                                     GLsizei count,
341                                                     GLboolean transpose,
342                                                     const GLdouble *value);
343 angle::CallCapture CaptureScissorArrayv(const State &glState,
344                                         bool isCallValid,
345                                         GLuint first,
346                                         GLsizei count,
347                                         const GLint *v);
348 angle::CallCapture CaptureScissorIndexed(const State &glState,
349                                          bool isCallValid,
350                                          GLuint index,
351                                          GLint left,
352                                          GLint bottom,
353                                          GLsizei width,
354                                          GLsizei height);
355 angle::CallCapture CaptureScissorIndexedv(const State &glState,
356                                           bool isCallValid,
357                                           GLuint index,
358                                           const GLint *v);
359 angle::CallCapture CaptureVertexAttribL1d(const State &glState,
360                                           bool isCallValid,
361                                           GLuint index,
362                                           GLdouble x);
363 angle::CallCapture CaptureVertexAttribL1dv(const State &glState,
364                                            bool isCallValid,
365                                            GLuint index,
366                                            const GLdouble *v);
367 angle::CallCapture CaptureVertexAttribL2d(const State &glState,
368                                           bool isCallValid,
369                                           GLuint index,
370                                           GLdouble x,
371                                           GLdouble y);
372 angle::CallCapture CaptureVertexAttribL2dv(const State &glState,
373                                            bool isCallValid,
374                                            GLuint index,
375                                            const GLdouble *v);
376 angle::CallCapture CaptureVertexAttribL3d(const State &glState,
377                                           bool isCallValid,
378                                           GLuint index,
379                                           GLdouble x,
380                                           GLdouble y,
381                                           GLdouble z);
382 angle::CallCapture CaptureVertexAttribL3dv(const State &glState,
383                                            bool isCallValid,
384                                            GLuint index,
385                                            const GLdouble *v);
386 angle::CallCapture CaptureVertexAttribL4d(const State &glState,
387                                           bool isCallValid,
388                                           GLuint index,
389                                           GLdouble x,
390                                           GLdouble y,
391                                           GLdouble z,
392                                           GLdouble w);
393 angle::CallCapture CaptureVertexAttribL4dv(const State &glState,
394                                            bool isCallValid,
395                                            GLuint index,
396                                            const GLdouble *v);
397 angle::CallCapture CaptureVertexAttribLPointer(const State &glState,
398                                                bool isCallValid,
399                                                GLuint index,
400                                                GLint size,
401                                                GLenum type,
402                                                GLsizei stride,
403                                                const void *pointer);
404 angle::CallCapture CaptureViewportArrayv(const State &glState,
405                                          bool isCallValid,
406                                          GLuint first,
407                                          GLsizei count,
408                                          const GLfloat *v);
409 angle::CallCapture CaptureViewportIndexedf(const State &glState,
410                                            bool isCallValid,
411                                            GLuint index,
412                                            GLfloat x,
413                                            GLfloat y,
414                                            GLfloat w,
415                                            GLfloat h);
416 angle::CallCapture CaptureViewportIndexedfv(const State &glState,
417                                             bool isCallValid,
418                                             GLuint index,
419                                             const GLfloat *v);
420 
421 // GL 4.2
422 angle::CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
423                                                           bool isCallValid,
424                                                           PrimitiveMode modePacked,
425                                                           GLint first,
426                                                           GLsizei count,
427                                                           GLsizei instancecount,
428                                                           GLuint baseinstance);
429 angle::CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState,
430                                                             bool isCallValid,
431                                                             PrimitiveMode modePacked,
432                                                             GLsizei count,
433                                                             DrawElementsType typePacked,
434                                                             const void *indices,
435                                                             GLsizei instancecount,
436                                                             GLuint baseinstance);
437 angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState,
438                                                                       bool isCallValid,
439                                                                       PrimitiveMode modePacked,
440                                                                       GLsizei count,
441                                                                       DrawElementsType typePacked,
442                                                                       const void *indices,
443                                                                       GLsizei instancecount,
444                                                                       GLint basevertex,
445                                                                       GLuint baseinstance);
446 angle::CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState,
447                                                          bool isCallValid,
448                                                          GLenum mode,
449                                                          TransformFeedbackID idPacked,
450                                                          GLsizei instancecount);
451 angle::CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState,
452                                                                bool isCallValid,
453                                                                GLenum mode,
454                                                                TransformFeedbackID idPacked,
455                                                                GLuint stream,
456                                                                GLsizei instancecount);
457 angle::CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState,
458                                                          bool isCallValid,
459                                                          ShaderProgramID programPacked,
460                                                          GLuint bufferIndex,
461                                                          GLenum pname,
462                                                          GLint *params);
463 angle::CallCapture CaptureTexStorage1D(const State &glState,
464                                        bool isCallValid,
465                                        GLenum target,
466                                        GLsizei levels,
467                                        GLenum internalformat,
468                                        GLsizei width);
469 
470 // GL 4.3
471 angle::CallCapture CaptureClearBufferData(const State &glState,
472                                           bool isCallValid,
473                                           GLenum target,
474                                           GLenum internalformat,
475                                           GLenum format,
476                                           GLenum type,
477                                           const void *data);
478 angle::CallCapture CaptureClearBufferSubData(const State &glState,
479                                              bool isCallValid,
480                                              GLenum target,
481                                              GLenum internalformat,
482                                              GLintptr offset,
483                                              GLsizeiptr size,
484                                              GLenum format,
485                                              GLenum type,
486                                              const void *data);
487 angle::CallCapture CaptureGetInternalformati64v(const State &glState,
488                                                 bool isCallValid,
489                                                 GLenum target,
490                                                 GLenum internalformat,
491                                                 GLenum pname,
492                                                 GLsizei count,
493                                                 GLint64 *params);
494 angle::CallCapture CaptureGetProgramResourceLocationIndex(const State &glState,
495                                                           bool isCallValid,
496                                                           ShaderProgramID programPacked,
497                                                           GLenum programInterface,
498                                                           const GLchar *name,
499                                                           GLint returnValue);
500 angle::CallCapture CaptureInvalidateBufferData(const State &glState,
501                                                bool isCallValid,
502                                                BufferID bufferPacked);
503 angle::CallCapture CaptureInvalidateBufferSubData(const State &glState,
504                                                   bool isCallValid,
505                                                   BufferID bufferPacked,
506                                                   GLintptr offset,
507                                                   GLsizeiptr length);
508 angle::CallCapture CaptureInvalidateTexImage(const State &glState,
509                                              bool isCallValid,
510                                              TextureID texturePacked,
511                                              GLint level);
512 angle::CallCapture CaptureInvalidateTexSubImage(const State &glState,
513                                                 bool isCallValid,
514                                                 TextureID texturePacked,
515                                                 GLint level,
516                                                 GLint xoffset,
517                                                 GLint yoffset,
518                                                 GLint zoffset,
519                                                 GLsizei width,
520                                                 GLsizei height,
521                                                 GLsizei depth);
522 angle::CallCapture CaptureMultiDrawArraysIndirect(const State &glState,
523                                                   bool isCallValid,
524                                                   PrimitiveMode modePacked,
525                                                   const void *indirect,
526                                                   GLsizei drawcount,
527                                                   GLsizei stride);
528 angle::CallCapture CaptureMultiDrawElementsIndirect(const State &glState,
529                                                     bool isCallValid,
530                                                     PrimitiveMode modePacked,
531                                                     DrawElementsType typePacked,
532                                                     const void *indirect,
533                                                     GLsizei drawcount,
534                                                     GLsizei stride);
535 angle::CallCapture CaptureShaderStorageBlockBinding(const State &glState,
536                                                     bool isCallValid,
537                                                     ShaderProgramID programPacked,
538                                                     GLuint storageBlockIndex,
539                                                     GLuint storageBlockBinding);
540 angle::CallCapture CaptureTextureView(const State &glState,
541                                       bool isCallValid,
542                                       TextureID texturePacked,
543                                       GLenum target,
544                                       GLuint origtexture,
545                                       GLenum internalformat,
546                                       GLuint minlevel,
547                                       GLuint numlevels,
548                                       GLuint minlayer,
549                                       GLuint numlayers);
550 angle::CallCapture CaptureVertexAttribLFormat(const State &glState,
551                                               bool isCallValid,
552                                               GLuint attribindex,
553                                               GLint size,
554                                               GLenum type,
555                                               GLuint relativeoffset);
556 
557 // GL 4.4
558 angle::CallCapture CaptureBindBuffersBase(const State &glState,
559                                           bool isCallValid,
560                                           GLenum target,
561                                           GLuint first,
562                                           GLsizei count,
563                                           const BufferID *buffersPacked);
564 angle::CallCapture CaptureBindBuffersRange(const State &glState,
565                                            bool isCallValid,
566                                            GLenum target,
567                                            GLuint first,
568                                            GLsizei count,
569                                            const BufferID *buffersPacked,
570                                            const GLintptr *offsets,
571                                            const GLsizeiptr *sizes);
572 angle::CallCapture CaptureBindImageTextures(const State &glState,
573                                             bool isCallValid,
574                                             GLuint first,
575                                             GLsizei count,
576                                             const GLuint *textures);
577 angle::CallCapture CaptureBindSamplers(const State &glState,
578                                        bool isCallValid,
579                                        GLuint first,
580                                        GLsizei count,
581                                        const GLuint *samplers);
582 angle::CallCapture CaptureBindTextures(const State &glState,
583                                        bool isCallValid,
584                                        GLuint first,
585                                        GLsizei count,
586                                        const GLuint *textures);
587 angle::CallCapture CaptureBindVertexBuffers(const State &glState,
588                                             bool isCallValid,
589                                             GLuint first,
590                                             GLsizei count,
591                                             const BufferID *buffersPacked,
592                                             const GLintptr *offsets,
593                                             const GLsizei *strides);
594 angle::CallCapture CaptureBufferStorage(const State &glState,
595                                         bool isCallValid,
596                                         BufferBinding targetPacked,
597                                         GLsizeiptr size,
598                                         const void *data,
599                                         GLbitfield flags);
600 angle::CallCapture CaptureClearTexImage(const State &glState,
601                                         bool isCallValid,
602                                         TextureID texturePacked,
603                                         GLint level,
604                                         GLenum format,
605                                         GLenum type,
606                                         const void *data);
607 angle::CallCapture CaptureClearTexSubImage(const State &glState,
608                                            bool isCallValid,
609                                            TextureID texturePacked,
610                                            GLint level,
611                                            GLint xoffset,
612                                            GLint yoffset,
613                                            GLint zoffset,
614                                            GLsizei width,
615                                            GLsizei height,
616                                            GLsizei depth,
617                                            GLenum format,
618                                            GLenum type,
619                                            const void *data);
620 
621 // GL 4.5
622 angle::CallCapture CaptureBindTextureUnit(const State &glState,
623                                           bool isCallValid,
624                                           GLuint unit,
625                                           TextureID texturePacked);
626 angle::CallCapture CaptureBlitNamedFramebuffer(const State &glState,
627                                                bool isCallValid,
628                                                GLuint readFramebuffer,
629                                                GLuint drawFramebuffer,
630                                                GLint srcX0,
631                                                GLint srcY0,
632                                                GLint srcX1,
633                                                GLint srcY1,
634                                                GLint dstX0,
635                                                GLint dstY0,
636                                                GLint dstX1,
637                                                GLint dstY1,
638                                                GLbitfield mask,
639                                                GLenum filter);
640 angle::CallCapture CaptureCheckNamedFramebufferStatus(const State &glState,
641                                                       bool isCallValid,
642                                                       FramebufferID framebufferPacked,
643                                                       GLenum target,
644                                                       GLenum returnValue);
645 angle::CallCapture CaptureClearNamedBufferData(const State &glState,
646                                                bool isCallValid,
647                                                BufferID bufferPacked,
648                                                GLenum internalformat,
649                                                GLenum format,
650                                                GLenum type,
651                                                const void *data);
652 angle::CallCapture CaptureClearNamedBufferSubData(const State &glState,
653                                                   bool isCallValid,
654                                                   BufferID bufferPacked,
655                                                   GLenum internalformat,
656                                                   GLintptr offset,
657                                                   GLsizeiptr size,
658                                                   GLenum format,
659                                                   GLenum type,
660                                                   const void *data);
661 angle::CallCapture CaptureClearNamedFramebufferfi(const State &glState,
662                                                   bool isCallValid,
663                                                   FramebufferID framebufferPacked,
664                                                   GLenum buffer,
665                                                   GLint drawbuffer,
666                                                   GLfloat depth,
667                                                   GLint stencil);
668 angle::CallCapture CaptureClearNamedFramebufferfv(const State &glState,
669                                                   bool isCallValid,
670                                                   FramebufferID framebufferPacked,
671                                                   GLenum buffer,
672                                                   GLint drawbuffer,
673                                                   const GLfloat *value);
674 angle::CallCapture CaptureClearNamedFramebufferiv(const State &glState,
675                                                   bool isCallValid,
676                                                   FramebufferID framebufferPacked,
677                                                   GLenum buffer,
678                                                   GLint drawbuffer,
679                                                   const GLint *value);
680 angle::CallCapture CaptureClearNamedFramebufferuiv(const State &glState,
681                                                    bool isCallValid,
682                                                    FramebufferID framebufferPacked,
683                                                    GLenum buffer,
684                                                    GLint drawbuffer,
685                                                    const GLuint *value);
686 angle::CallCapture CaptureClipControl(const State &glState,
687                                       bool isCallValid,
688                                       ClipOrigin originPacked,
689                                       ClipDepthMode depthPacked);
690 angle::CallCapture CaptureCompressedTextureSubImage1D(const State &glState,
691                                                       bool isCallValid,
692                                                       TextureID texturePacked,
693                                                       GLint level,
694                                                       GLint xoffset,
695                                                       GLsizei width,
696                                                       GLenum format,
697                                                       GLsizei imageSize,
698                                                       const void *data);
699 angle::CallCapture CaptureCompressedTextureSubImage2D(const State &glState,
700                                                       bool isCallValid,
701                                                       TextureID texturePacked,
702                                                       GLint level,
703                                                       GLint xoffset,
704                                                       GLint yoffset,
705                                                       GLsizei width,
706                                                       GLsizei height,
707                                                       GLenum format,
708                                                       GLsizei imageSize,
709                                                       const void *data);
710 angle::CallCapture CaptureCompressedTextureSubImage3D(const State &glState,
711                                                       bool isCallValid,
712                                                       TextureID texturePacked,
713                                                       GLint level,
714                                                       GLint xoffset,
715                                                       GLint yoffset,
716                                                       GLint zoffset,
717                                                       GLsizei width,
718                                                       GLsizei height,
719                                                       GLsizei depth,
720                                                       GLenum format,
721                                                       GLsizei imageSize,
722                                                       const void *data);
723 angle::CallCapture CaptureCopyNamedBufferSubData(const State &glState,
724                                                  bool isCallValid,
725                                                  GLuint readBuffer,
726                                                  GLuint writeBuffer,
727                                                  GLintptr readOffset,
728                                                  GLintptr writeOffset,
729                                                  GLsizeiptr size);
730 angle::CallCapture CaptureCopyTextureSubImage1D(const State &glState,
731                                                 bool isCallValid,
732                                                 TextureID texturePacked,
733                                                 GLint level,
734                                                 GLint xoffset,
735                                                 GLint x,
736                                                 GLint y,
737                                                 GLsizei width);
738 angle::CallCapture CaptureCopyTextureSubImage2D(const State &glState,
739                                                 bool isCallValid,
740                                                 TextureID texturePacked,
741                                                 GLint level,
742                                                 GLint xoffset,
743                                                 GLint yoffset,
744                                                 GLint x,
745                                                 GLint y,
746                                                 GLsizei width,
747                                                 GLsizei height);
748 angle::CallCapture CaptureCopyTextureSubImage3D(const State &glState,
749                                                 bool isCallValid,
750                                                 TextureID texturePacked,
751                                                 GLint level,
752                                                 GLint xoffset,
753                                                 GLint yoffset,
754                                                 GLint zoffset,
755                                                 GLint x,
756                                                 GLint y,
757                                                 GLsizei width,
758                                                 GLsizei height);
759 angle::CallCapture CaptureCreateBuffers(const State &glState,
760                                         bool isCallValid,
761                                         GLsizei n,
762                                         BufferID *buffersPacked);
763 angle::CallCapture CaptureCreateFramebuffers(const State &glState,
764                                              bool isCallValid,
765                                              GLsizei n,
766                                              GLuint *framebuffers);
767 angle::CallCapture CaptureCreateProgramPipelines(const State &glState,
768                                                  bool isCallValid,
769                                                  GLsizei n,
770                                                  GLuint *pipelines);
771 angle::CallCapture CaptureCreateQueries(const State &glState,
772                                         bool isCallValid,
773                                         GLenum target,
774                                         GLsizei n,
775                                         GLuint *ids);
776 angle::CallCapture CaptureCreateRenderbuffers(const State &glState,
777                                               bool isCallValid,
778                                               GLsizei n,
779                                               RenderbufferID *renderbuffersPacked);
780 angle::CallCapture CaptureCreateSamplers(const State &glState,
781                                          bool isCallValid,
782                                          GLsizei n,
783                                          GLuint *samplers);
784 angle::CallCapture CaptureCreateTextures(const State &glState,
785                                          bool isCallValid,
786                                          GLenum target,
787                                          GLsizei n,
788                                          GLuint *textures);
789 angle::CallCapture CaptureCreateTransformFeedbacks(const State &glState,
790                                                    bool isCallValid,
791                                                    GLsizei n,
792                                                    GLuint *ids);
793 angle::CallCapture CaptureCreateVertexArrays(const State &glState,
794                                              bool isCallValid,
795                                              GLsizei n,
796                                              VertexArrayID *arraysPacked);
797 angle::CallCapture CaptureDisableVertexArrayAttrib(const State &glState,
798                                                    bool isCallValid,
799                                                    VertexArrayID vaobjPacked,
800                                                    GLuint index);
801 angle::CallCapture CaptureEnableVertexArrayAttrib(const State &glState,
802                                                   bool isCallValid,
803                                                   VertexArrayID vaobjPacked,
804                                                   GLuint index);
805 angle::CallCapture CaptureFlushMappedNamedBufferRange(const State &glState,
806                                                       bool isCallValid,
807                                                       BufferID bufferPacked,
808                                                       GLintptr offset,
809                                                       GLsizeiptr length);
810 angle::CallCapture CaptureGenerateTextureMipmap(const State &glState,
811                                                 bool isCallValid,
812                                                 TextureID texturePacked);
813 angle::CallCapture CaptureGetCompressedTextureImage(const State &glState,
814                                                     bool isCallValid,
815                                                     TextureID texturePacked,
816                                                     GLint level,
817                                                     GLsizei bufSize,
818                                                     void *pixels);
819 angle::CallCapture CaptureGetCompressedTextureSubImage(const State &glState,
820                                                        bool isCallValid,
821                                                        TextureID texturePacked,
822                                                        GLint level,
823                                                        GLint xoffset,
824                                                        GLint yoffset,
825                                                        GLint zoffset,
826                                                        GLsizei width,
827                                                        GLsizei height,
828                                                        GLsizei depth,
829                                                        GLsizei bufSize,
830                                                        void *pixels);
831 angle::CallCapture CaptureGetNamedBufferParameteri64v(const State &glState,
832                                                       bool isCallValid,
833                                                       BufferID bufferPacked,
834                                                       GLenum pname,
835                                                       GLint64 *params);
836 angle::CallCapture CaptureGetNamedBufferParameteriv(const State &glState,
837                                                     bool isCallValid,
838                                                     BufferID bufferPacked,
839                                                     GLenum pname,
840                                                     GLint *params);
841 angle::CallCapture CaptureGetNamedBufferPointerv(const State &glState,
842                                                  bool isCallValid,
843                                                  BufferID bufferPacked,
844                                                  GLenum pname,
845                                                  void **params);
846 angle::CallCapture CaptureGetNamedBufferSubData(const State &glState,
847                                                 bool isCallValid,
848                                                 BufferID bufferPacked,
849                                                 GLintptr offset,
850                                                 GLsizeiptr size,
851                                                 void *data);
852 angle::CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState,
853                                                                    bool isCallValid,
854                                                                    FramebufferID framebufferPacked,
855                                                                    GLenum attachment,
856                                                                    GLenum pname,
857                                                                    GLint *params);
858 angle::CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState,
859                                                          bool isCallValid,
860                                                          FramebufferID framebufferPacked,
861                                                          GLenum pname,
862                                                          GLint *param);
863 angle::CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState,
864                                                           bool isCallValid,
865                                                           RenderbufferID renderbufferPacked,
866                                                           GLenum pname,
867                                                           GLint *params);
868 angle::CallCapture CaptureGetQueryBufferObjecti64v(const State &glState,
869                                                    bool isCallValid,
870                                                    GLuint id,
871                                                    BufferID bufferPacked,
872                                                    GLenum pname,
873                                                    GLintptr offset);
874 angle::CallCapture CaptureGetQueryBufferObjectiv(const State &glState,
875                                                  bool isCallValid,
876                                                  GLuint id,
877                                                  BufferID bufferPacked,
878                                                  GLenum pname,
879                                                  GLintptr offset);
880 angle::CallCapture CaptureGetQueryBufferObjectui64v(const State &glState,
881                                                     bool isCallValid,
882                                                     GLuint id,
883                                                     BufferID bufferPacked,
884                                                     GLenum pname,
885                                                     GLintptr offset);
886 angle::CallCapture CaptureGetQueryBufferObjectuiv(const State &glState,
887                                                   bool isCallValid,
888                                                   GLuint id,
889                                                   BufferID bufferPacked,
890                                                   GLenum pname,
891                                                   GLintptr offset);
892 angle::CallCapture CaptureGetTextureImage(const State &glState,
893                                           bool isCallValid,
894                                           TextureID texturePacked,
895                                           GLint level,
896                                           GLenum format,
897                                           GLenum type,
898                                           GLsizei bufSize,
899                                           void *pixels);
900 angle::CallCapture CaptureGetTextureLevelParameterfv(const State &glState,
901                                                      bool isCallValid,
902                                                      TextureID texturePacked,
903                                                      GLint level,
904                                                      GLenum pname,
905                                                      GLfloat *params);
906 angle::CallCapture CaptureGetTextureLevelParameteriv(const State &glState,
907                                                      bool isCallValid,
908                                                      TextureID texturePacked,
909                                                      GLint level,
910                                                      GLenum pname,
911                                                      GLint *params);
912 angle::CallCapture CaptureGetTextureParameterIiv(const State &glState,
913                                                  bool isCallValid,
914                                                  TextureID texturePacked,
915                                                  GLenum pname,
916                                                  GLint *params);
917 angle::CallCapture CaptureGetTextureParameterIuiv(const State &glState,
918                                                   bool isCallValid,
919                                                   TextureID texturePacked,
920                                                   GLenum pname,
921                                                   GLuint *params);
922 angle::CallCapture CaptureGetTextureParameterfv(const State &glState,
923                                                 bool isCallValid,
924                                                 TextureID texturePacked,
925                                                 GLenum pname,
926                                                 GLfloat *params);
927 angle::CallCapture CaptureGetTextureParameteriv(const State &glState,
928                                                 bool isCallValid,
929                                                 TextureID texturePacked,
930                                                 GLenum pname,
931                                                 GLint *params);
932 angle::CallCapture CaptureGetTextureSubImage(const State &glState,
933                                              bool isCallValid,
934                                              TextureID texturePacked,
935                                              GLint level,
936                                              GLint xoffset,
937                                              GLint yoffset,
938                                              GLint zoffset,
939                                              GLsizei width,
940                                              GLsizei height,
941                                              GLsizei depth,
942                                              GLenum format,
943                                              GLenum type,
944                                              GLsizei bufSize,
945                                              void *pixels);
946 angle::CallCapture CaptureGetTransformFeedbacki64_v(const State &glState,
947                                                     bool isCallValid,
948                                                     GLuint xfb,
949                                                     GLenum pname,
950                                                     GLuint index,
951                                                     GLint64 *param);
952 angle::CallCapture CaptureGetTransformFeedbacki_v(const State &glState,
953                                                   bool isCallValid,
954                                                   GLuint xfb,
955                                                   GLenum pname,
956                                                   GLuint index,
957                                                   GLint *param);
958 angle::CallCapture CaptureGetTransformFeedbackiv(const State &glState,
959                                                  bool isCallValid,
960                                                  GLuint xfb,
961                                                  GLenum pname,
962                                                  GLint *param);
963 angle::CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState,
964                                                     bool isCallValid,
965                                                     VertexArrayID vaobjPacked,
966                                                     GLuint index,
967                                                     GLenum pname,
968                                                     GLint64 *param);
969 angle::CallCapture CaptureGetVertexArrayIndexediv(const State &glState,
970                                                   bool isCallValid,
971                                                   VertexArrayID vaobjPacked,
972                                                   GLuint index,
973                                                   GLenum pname,
974                                                   GLint *param);
975 angle::CallCapture CaptureGetVertexArrayiv(const State &glState,
976                                            bool isCallValid,
977                                            VertexArrayID vaobjPacked,
978                                            GLenum pname,
979                                            GLint *param);
980 angle::CallCapture CaptureGetnColorTable(const State &glState,
981                                          bool isCallValid,
982                                          GLenum target,
983                                          GLenum format,
984                                          GLenum type,
985                                          GLsizei bufSize,
986                                          void *table);
987 angle::CallCapture CaptureGetnCompressedTexImage(const State &glState,
988                                                  bool isCallValid,
989                                                  GLenum target,
990                                                  GLint lod,
991                                                  GLsizei bufSize,
992                                                  void *pixels);
993 angle::CallCapture CaptureGetnConvolutionFilter(const State &glState,
994                                                 bool isCallValid,
995                                                 GLenum target,
996                                                 GLenum format,
997                                                 GLenum type,
998                                                 GLsizei bufSize,
999                                                 void *image);
1000 angle::CallCapture CaptureGetnHistogram(const State &glState,
1001                                         bool isCallValid,
1002                                         GLenum target,
1003                                         GLboolean reset,
1004                                         GLenum format,
1005                                         GLenum type,
1006                                         GLsizei bufSize,
1007                                         void *values);
1008 angle::CallCapture CaptureGetnMapdv(const State &glState,
1009                                     bool isCallValid,
1010                                     GLenum target,
1011                                     GLenum query,
1012                                     GLsizei bufSize,
1013                                     GLdouble *v);
1014 angle::CallCapture CaptureGetnMapfv(const State &glState,
1015                                     bool isCallValid,
1016                                     GLenum target,
1017                                     GLenum query,
1018                                     GLsizei bufSize,
1019                                     GLfloat *v);
1020 angle::CallCapture CaptureGetnMapiv(const State &glState,
1021                                     bool isCallValid,
1022                                     GLenum target,
1023                                     GLenum query,
1024                                     GLsizei bufSize,
1025                                     GLint *v);
1026 angle::CallCapture CaptureGetnMinmax(const State &glState,
1027                                      bool isCallValid,
1028                                      GLenum target,
1029                                      GLboolean reset,
1030                                      GLenum format,
1031                                      GLenum type,
1032                                      GLsizei bufSize,
1033                                      void *values);
1034 angle::CallCapture CaptureGetnPixelMapfv(const State &glState,
1035                                          bool isCallValid,
1036                                          GLenum map,
1037                                          GLsizei bufSize,
1038                                          GLfloat *values);
1039 angle::CallCapture CaptureGetnPixelMapuiv(const State &glState,
1040                                           bool isCallValid,
1041                                           GLenum map,
1042                                           GLsizei bufSize,
1043                                           GLuint *values);
1044 angle::CallCapture CaptureGetnPixelMapusv(const State &glState,
1045                                           bool isCallValid,
1046                                           GLenum map,
1047                                           GLsizei bufSize,
1048                                           GLushort *values);
1049 angle::CallCapture CaptureGetnPolygonStipple(const State &glState,
1050                                              bool isCallValid,
1051                                              GLsizei bufSize,
1052                                              GLubyte *pattern);
1053 angle::CallCapture CaptureGetnSeparableFilter(const State &glState,
1054                                               bool isCallValid,
1055                                               GLenum target,
1056                                               GLenum format,
1057                                               GLenum type,
1058                                               GLsizei rowBufSize,
1059                                               void *row,
1060                                               GLsizei columnBufSize,
1061                                               void *column,
1062                                               void *span);
1063 angle::CallCapture CaptureGetnTexImage(const State &glState,
1064                                        bool isCallValid,
1065                                        GLenum target,
1066                                        GLint level,
1067                                        GLenum format,
1068                                        GLenum type,
1069                                        GLsizei bufSize,
1070                                        void *pixels);
1071 angle::CallCapture CaptureGetnUniformdv(const State &glState,
1072                                         bool isCallValid,
1073                                         ShaderProgramID programPacked,
1074                                         UniformLocation locationPacked,
1075                                         GLsizei bufSize,
1076                                         GLdouble *params);
1077 angle::CallCapture CaptureInvalidateNamedFramebufferData(const State &glState,
1078                                                          bool isCallValid,
1079                                                          FramebufferID framebufferPacked,
1080                                                          GLsizei numAttachments,
1081                                                          const GLenum *attachments);
1082 angle::CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState,
1083                                                             bool isCallValid,
1084                                                             FramebufferID framebufferPacked,
1085                                                             GLsizei numAttachments,
1086                                                             const GLenum *attachments,
1087                                                             GLint x,
1088                                                             GLint y,
1089                                                             GLsizei width,
1090                                                             GLsizei height);
1091 angle::CallCapture CaptureMapNamedBuffer(const State &glState,
1092                                          bool isCallValid,
1093                                          BufferID bufferPacked,
1094                                          GLenum access,
1095                                          void *returnValue);
1096 angle::CallCapture CaptureMapNamedBufferRange(const State &glState,
1097                                               bool isCallValid,
1098                                               BufferID bufferPacked,
1099                                               GLintptr offset,
1100                                               GLsizeiptr length,
1101                                               GLbitfield access,
1102                                               void *returnValue);
1103 angle::CallCapture CaptureNamedBufferData(const State &glState,
1104                                           bool isCallValid,
1105                                           BufferID bufferPacked,
1106                                           GLsizeiptr size,
1107                                           const void *data,
1108                                           GLenum usage);
1109 angle::CallCapture CaptureNamedBufferStorage(const State &glState,
1110                                              bool isCallValid,
1111                                              BufferID bufferPacked,
1112                                              GLsizeiptr size,
1113                                              const void *data,
1114                                              GLbitfield flags);
1115 angle::CallCapture CaptureNamedBufferSubData(const State &glState,
1116                                              bool isCallValid,
1117                                              BufferID bufferPacked,
1118                                              GLintptr offset,
1119                                              GLsizeiptr size,
1120                                              const void *data);
1121 angle::CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState,
1122                                                      bool isCallValid,
1123                                                      FramebufferID framebufferPacked,
1124                                                      GLenum buf);
1125 angle::CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState,
1126                                                       bool isCallValid,
1127                                                       FramebufferID framebufferPacked,
1128                                                       GLsizei n,
1129                                                       const GLenum *bufs);
1130 angle::CallCapture CaptureNamedFramebufferParameteri(const State &glState,
1131                                                      bool isCallValid,
1132                                                      FramebufferID framebufferPacked,
1133                                                      GLenum pname,
1134                                                      GLint param);
1135 angle::CallCapture CaptureNamedFramebufferReadBuffer(const State &glState,
1136                                                      bool isCallValid,
1137                                                      FramebufferID framebufferPacked,
1138                                                      GLenum src);
1139 angle::CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState,
1140                                                        bool isCallValid,
1141                                                        FramebufferID framebufferPacked,
1142                                                        GLenum attachment,
1143                                                        GLenum renderbuffertarget,
1144                                                        RenderbufferID renderbufferPacked);
1145 angle::CallCapture CaptureNamedFramebufferTexture(const State &glState,
1146                                                   bool isCallValid,
1147                                                   FramebufferID framebufferPacked,
1148                                                   GLenum attachment,
1149                                                   TextureID texturePacked,
1150                                                   GLint level);
1151 angle::CallCapture CaptureNamedFramebufferTextureLayer(const State &glState,
1152                                                        bool isCallValid,
1153                                                        FramebufferID framebufferPacked,
1154                                                        GLenum attachment,
1155                                                        TextureID texturePacked,
1156                                                        GLint level,
1157                                                        GLint layer);
1158 angle::CallCapture CaptureNamedRenderbufferStorage(const State &glState,
1159                                                    bool isCallValid,
1160                                                    RenderbufferID renderbufferPacked,
1161                                                    GLenum internalformat,
1162                                                    GLsizei width,
1163                                                    GLsizei height);
1164 angle::CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState,
1165                                                               bool isCallValid,
1166                                                               RenderbufferID renderbufferPacked,
1167                                                               GLsizei samples,
1168                                                               GLenum internalformat,
1169                                                               GLsizei width,
1170                                                               GLsizei height);
1171 angle::CallCapture CaptureTextureBarrier(const State &glState, bool isCallValid);
1172 angle::CallCapture CaptureTextureBuffer(const State &glState,
1173                                         bool isCallValid,
1174                                         TextureID texturePacked,
1175                                         GLenum internalformat,
1176                                         BufferID bufferPacked);
1177 angle::CallCapture CaptureTextureBufferRange(const State &glState,
1178                                              bool isCallValid,
1179                                              TextureID texturePacked,
1180                                              GLenum internalformat,
1181                                              BufferID bufferPacked,
1182                                              GLintptr offset,
1183                                              GLsizeiptr size);
1184 angle::CallCapture CaptureTextureParameterIiv(const State &glState,
1185                                               bool isCallValid,
1186                                               TextureID texturePacked,
1187                                               GLenum pname,
1188                                               const GLint *params);
1189 angle::CallCapture CaptureTextureParameterIuiv(const State &glState,
1190                                                bool isCallValid,
1191                                                TextureID texturePacked,
1192                                                GLenum pname,
1193                                                const GLuint *params);
1194 angle::CallCapture CaptureTextureParameterf(const State &glState,
1195                                             bool isCallValid,
1196                                             TextureID texturePacked,
1197                                             GLenum pname,
1198                                             GLfloat param);
1199 angle::CallCapture CaptureTextureParameterfv(const State &glState,
1200                                              bool isCallValid,
1201                                              TextureID texturePacked,
1202                                              GLenum pname,
1203                                              const GLfloat *param);
1204 angle::CallCapture CaptureTextureParameteri(const State &glState,
1205                                             bool isCallValid,
1206                                             TextureID texturePacked,
1207                                             GLenum pname,
1208                                             GLint param);
1209 angle::CallCapture CaptureTextureParameteriv(const State &glState,
1210                                              bool isCallValid,
1211                                              TextureID texturePacked,
1212                                              GLenum pname,
1213                                              const GLint *param);
1214 angle::CallCapture CaptureTextureStorage1D(const State &glState,
1215                                            bool isCallValid,
1216                                            TextureID texturePacked,
1217                                            GLsizei levels,
1218                                            GLenum internalformat,
1219                                            GLsizei width);
1220 angle::CallCapture CaptureTextureStorage2D(const State &glState,
1221                                            bool isCallValid,
1222                                            TextureID texturePacked,
1223                                            GLsizei levels,
1224                                            GLenum internalformat,
1225                                            GLsizei width,
1226                                            GLsizei height);
1227 angle::CallCapture CaptureTextureStorage2DMultisample(const State &glState,
1228                                                       bool isCallValid,
1229                                                       TextureID texturePacked,
1230                                                       GLsizei samples,
1231                                                       GLenum internalformat,
1232                                                       GLsizei width,
1233                                                       GLsizei height,
1234                                                       GLboolean fixedsamplelocations);
1235 angle::CallCapture CaptureTextureStorage3D(const State &glState,
1236                                            bool isCallValid,
1237                                            TextureID texturePacked,
1238                                            GLsizei levels,
1239                                            GLenum internalformat,
1240                                            GLsizei width,
1241                                            GLsizei height,
1242                                            GLsizei depth);
1243 angle::CallCapture CaptureTextureStorage3DMultisample(const State &glState,
1244                                                       bool isCallValid,
1245                                                       TextureID texturePacked,
1246                                                       GLsizei samples,
1247                                                       GLenum internalformat,
1248                                                       GLsizei width,
1249                                                       GLsizei height,
1250                                                       GLsizei depth,
1251                                                       GLboolean fixedsamplelocations);
1252 angle::CallCapture CaptureTextureSubImage1D(const State &glState,
1253                                             bool isCallValid,
1254                                             TextureID texturePacked,
1255                                             GLint level,
1256                                             GLint xoffset,
1257                                             GLsizei width,
1258                                             GLenum format,
1259                                             GLenum type,
1260                                             const void *pixels);
1261 angle::CallCapture CaptureTextureSubImage2D(const State &glState,
1262                                             bool isCallValid,
1263                                             TextureID texturePacked,
1264                                             GLint level,
1265                                             GLint xoffset,
1266                                             GLint yoffset,
1267                                             GLsizei width,
1268                                             GLsizei height,
1269                                             GLenum format,
1270                                             GLenum type,
1271                                             const void *pixels);
1272 angle::CallCapture CaptureTextureSubImage3D(const State &glState,
1273                                             bool isCallValid,
1274                                             TextureID texturePacked,
1275                                             GLint level,
1276                                             GLint xoffset,
1277                                             GLint yoffset,
1278                                             GLint zoffset,
1279                                             GLsizei width,
1280                                             GLsizei height,
1281                                             GLsizei depth,
1282                                             GLenum format,
1283                                             GLenum type,
1284                                             const void *pixels);
1285 angle::CallCapture CaptureTransformFeedbackBufferBase(const State &glState,
1286                                                       bool isCallValid,
1287                                                       GLuint xfb,
1288                                                       GLuint index,
1289                                                       BufferID bufferPacked);
1290 angle::CallCapture CaptureTransformFeedbackBufferRange(const State &glState,
1291                                                        bool isCallValid,
1292                                                        GLuint xfb,
1293                                                        GLuint index,
1294                                                        BufferID bufferPacked,
1295                                                        GLintptr offset,
1296                                                        GLsizeiptr size);
1297 angle::CallCapture CaptureUnmapNamedBuffer(const State &glState,
1298                                            bool isCallValid,
1299                                            BufferID bufferPacked,
1300                                            GLboolean returnValue);
1301 angle::CallCapture CaptureVertexArrayAttribBinding(const State &glState,
1302                                                    bool isCallValid,
1303                                                    VertexArrayID vaobjPacked,
1304                                                    GLuint attribindex,
1305                                                    GLuint bindingindex);
1306 angle::CallCapture CaptureVertexArrayAttribFormat(const State &glState,
1307                                                   bool isCallValid,
1308                                                   VertexArrayID vaobjPacked,
1309                                                   GLuint attribindex,
1310                                                   GLint size,
1311                                                   GLenum type,
1312                                                   GLboolean normalized,
1313                                                   GLuint relativeoffset);
1314 angle::CallCapture CaptureVertexArrayAttribIFormat(const State &glState,
1315                                                    bool isCallValid,
1316                                                    VertexArrayID vaobjPacked,
1317                                                    GLuint attribindex,
1318                                                    GLint size,
1319                                                    GLenum type,
1320                                                    GLuint relativeoffset);
1321 angle::CallCapture CaptureVertexArrayAttribLFormat(const State &glState,
1322                                                    bool isCallValid,
1323                                                    VertexArrayID vaobjPacked,
1324                                                    GLuint attribindex,
1325                                                    GLint size,
1326                                                    GLenum type,
1327                                                    GLuint relativeoffset);
1328 angle::CallCapture CaptureVertexArrayBindingDivisor(const State &glState,
1329                                                     bool isCallValid,
1330                                                     VertexArrayID vaobjPacked,
1331                                                     GLuint bindingindex,
1332                                                     GLuint divisor);
1333 angle::CallCapture CaptureVertexArrayElementBuffer(const State &glState,
1334                                                    bool isCallValid,
1335                                                    VertexArrayID vaobjPacked,
1336                                                    BufferID bufferPacked);
1337 angle::CallCapture CaptureVertexArrayVertexBuffer(const State &glState,
1338                                                   bool isCallValid,
1339                                                   VertexArrayID vaobjPacked,
1340                                                   GLuint bindingindex,
1341                                                   BufferID bufferPacked,
1342                                                   GLintptr offset,
1343                                                   GLsizei stride);
1344 angle::CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
1345                                                    bool isCallValid,
1346                                                    VertexArrayID vaobjPacked,
1347                                                    GLuint first,
1348                                                    GLsizei count,
1349                                                    const BufferID *buffersPacked,
1350                                                    const GLintptr *offsets,
1351                                                    const GLsizei *strides);
1352 
1353 // GL 4.6
1354 angle::CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
1355                                                        bool isCallValid,
1356                                                        GLenum mode,
1357                                                        const void *indirect,
1358                                                        GLintptr drawcount,
1359                                                        GLsizei maxdrawcount,
1360                                                        GLsizei stride);
1361 angle::CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState,
1362                                                          bool isCallValid,
1363                                                          GLenum mode,
1364                                                          GLenum type,
1365                                                          const void *indirect,
1366                                                          GLintptr drawcount,
1367                                                          GLsizei maxdrawcount,
1368                                                          GLsizei stride);
1369 angle::CallCapture CapturePolygonOffsetClamp(const State &glState,
1370                                              bool isCallValid,
1371                                              GLfloat factor,
1372                                              GLfloat units,
1373                                              GLfloat clamp);
1374 angle::CallCapture CaptureSpecializeShader(const State &glState,
1375                                            bool isCallValid,
1376                                            GLuint shader,
1377                                            const GLchar *pEntryPoint,
1378                                            GLuint numSpecializationConstants,
1379                                            const GLuint *pConstantIndex,
1380                                            const GLuint *pConstantValue);
1381 
1382 // Parameter Captures
1383 
1384 // GL 4.0
1385 void CaptureGetActiveSubroutineName_length(const State &glState,
1386                                            bool isCallValid,
1387                                            ShaderProgramID programPacked,
1388                                            GLenum shadertype,
1389                                            GLuint index,
1390                                            GLsizei bufSize,
1391                                            GLsizei *length,
1392                                            GLchar *name,
1393                                            angle::ParamCapture *paramCapture);
1394 void CaptureGetActiveSubroutineName_name(const State &glState,
1395                                          bool isCallValid,
1396                                          ShaderProgramID programPacked,
1397                                          GLenum shadertype,
1398                                          GLuint index,
1399                                          GLsizei bufSize,
1400                                          GLsizei *length,
1401                                          GLchar *name,
1402                                          angle::ParamCapture *paramCapture);
1403 void CaptureGetActiveSubroutineUniformName_length(const State &glState,
1404                                                   bool isCallValid,
1405                                                   ShaderProgramID programPacked,
1406                                                   GLenum shadertype,
1407                                                   GLuint index,
1408                                                   GLsizei bufSize,
1409                                                   GLsizei *length,
1410                                                   GLchar *name,
1411                                                   angle::ParamCapture *paramCapture);
1412 void CaptureGetActiveSubroutineUniformName_name(const State &glState,
1413                                                 bool isCallValid,
1414                                                 ShaderProgramID programPacked,
1415                                                 GLenum shadertype,
1416                                                 GLuint index,
1417                                                 GLsizei bufSize,
1418                                                 GLsizei *length,
1419                                                 GLchar *name,
1420                                                 angle::ParamCapture *paramCapture);
1421 void CaptureGetActiveSubroutineUniformiv_values(const State &glState,
1422                                                 bool isCallValid,
1423                                                 ShaderProgramID programPacked,
1424                                                 GLenum shadertype,
1425                                                 GLuint index,
1426                                                 GLenum pname,
1427                                                 GLint *values,
1428                                                 angle::ParamCapture *paramCapture);
1429 void CaptureGetProgramStageiv_values(const State &glState,
1430                                      bool isCallValid,
1431                                      ShaderProgramID programPacked,
1432                                      GLenum shadertype,
1433                                      GLenum pname,
1434                                      GLint *values,
1435                                      angle::ParamCapture *paramCapture);
1436 void CaptureGetQueryIndexediv_params(const State &glState,
1437                                      bool isCallValid,
1438                                      GLenum target,
1439                                      GLuint index,
1440                                      GLenum pname,
1441                                      GLint *params,
1442                                      angle::ParamCapture *paramCapture);
1443 void CaptureGetSubroutineIndex_name(const State &glState,
1444                                     bool isCallValid,
1445                                     ShaderProgramID programPacked,
1446                                     GLenum shadertype,
1447                                     const GLchar *name,
1448                                     angle::ParamCapture *paramCapture);
1449 void CaptureGetSubroutineUniformLocation_name(const State &glState,
1450                                               bool isCallValid,
1451                                               ShaderProgramID programPacked,
1452                                               GLenum shadertype,
1453                                               const GLchar *name,
1454                                               angle::ParamCapture *paramCapture);
1455 void CaptureGetUniformSubroutineuiv_params(const State &glState,
1456                                            bool isCallValid,
1457                                            GLenum shadertype,
1458                                            GLint location,
1459                                            GLuint *params,
1460                                            angle::ParamCapture *paramCapture);
1461 void CaptureGetUniformdv_params(const State &glState,
1462                                 bool isCallValid,
1463                                 ShaderProgramID programPacked,
1464                                 UniformLocation locationPacked,
1465                                 GLdouble *params,
1466                                 angle::ParamCapture *paramCapture);
1467 void CapturePatchParameterfv_values(const State &glState,
1468                                     bool isCallValid,
1469                                     GLenum pname,
1470                                     const GLfloat *values,
1471                                     angle::ParamCapture *paramCapture);
1472 void CaptureUniform1dv_value(const State &glState,
1473                              bool isCallValid,
1474                              UniformLocation locationPacked,
1475                              GLsizei count,
1476                              const GLdouble *value,
1477                              angle::ParamCapture *paramCapture);
1478 void CaptureUniform2dv_value(const State &glState,
1479                              bool isCallValid,
1480                              UniformLocation locationPacked,
1481                              GLsizei count,
1482                              const GLdouble *value,
1483                              angle::ParamCapture *paramCapture);
1484 void CaptureUniform3dv_value(const State &glState,
1485                              bool isCallValid,
1486                              UniformLocation locationPacked,
1487                              GLsizei count,
1488                              const GLdouble *value,
1489                              angle::ParamCapture *paramCapture);
1490 void CaptureUniform4dv_value(const State &glState,
1491                              bool isCallValid,
1492                              UniformLocation locationPacked,
1493                              GLsizei count,
1494                              const GLdouble *value,
1495                              angle::ParamCapture *paramCapture);
1496 void CaptureUniformMatrix2dv_value(const State &glState,
1497                                    bool isCallValid,
1498                                    UniformLocation locationPacked,
1499                                    GLsizei count,
1500                                    GLboolean transpose,
1501                                    const GLdouble *value,
1502                                    angle::ParamCapture *paramCapture);
1503 void CaptureUniformMatrix2x3dv_value(const State &glState,
1504                                      bool isCallValid,
1505                                      UniformLocation locationPacked,
1506                                      GLsizei count,
1507                                      GLboolean transpose,
1508                                      const GLdouble *value,
1509                                      angle::ParamCapture *paramCapture);
1510 void CaptureUniformMatrix2x4dv_value(const State &glState,
1511                                      bool isCallValid,
1512                                      UniformLocation locationPacked,
1513                                      GLsizei count,
1514                                      GLboolean transpose,
1515                                      const GLdouble *value,
1516                                      angle::ParamCapture *paramCapture);
1517 void CaptureUniformMatrix3dv_value(const State &glState,
1518                                    bool isCallValid,
1519                                    UniformLocation locationPacked,
1520                                    GLsizei count,
1521                                    GLboolean transpose,
1522                                    const GLdouble *value,
1523                                    angle::ParamCapture *paramCapture);
1524 void CaptureUniformMatrix3x2dv_value(const State &glState,
1525                                      bool isCallValid,
1526                                      UniformLocation locationPacked,
1527                                      GLsizei count,
1528                                      GLboolean transpose,
1529                                      const GLdouble *value,
1530                                      angle::ParamCapture *paramCapture);
1531 void CaptureUniformMatrix3x4dv_value(const State &glState,
1532                                      bool isCallValid,
1533                                      UniformLocation locationPacked,
1534                                      GLsizei count,
1535                                      GLboolean transpose,
1536                                      const GLdouble *value,
1537                                      angle::ParamCapture *paramCapture);
1538 void CaptureUniformMatrix4dv_value(const State &glState,
1539                                    bool isCallValid,
1540                                    UniformLocation locationPacked,
1541                                    GLsizei count,
1542                                    GLboolean transpose,
1543                                    const GLdouble *value,
1544                                    angle::ParamCapture *paramCapture);
1545 void CaptureUniformMatrix4x2dv_value(const State &glState,
1546                                      bool isCallValid,
1547                                      UniformLocation locationPacked,
1548                                      GLsizei count,
1549                                      GLboolean transpose,
1550                                      const GLdouble *value,
1551                                      angle::ParamCapture *paramCapture);
1552 void CaptureUniformMatrix4x3dv_value(const State &glState,
1553                                      bool isCallValid,
1554                                      UniformLocation locationPacked,
1555                                      GLsizei count,
1556                                      GLboolean transpose,
1557                                      const GLdouble *value,
1558                                      angle::ParamCapture *paramCapture);
1559 void CaptureUniformSubroutinesuiv_indices(const State &glState,
1560                                           bool isCallValid,
1561                                           GLenum shadertype,
1562                                           GLsizei count,
1563                                           const GLuint *indices,
1564                                           angle::ParamCapture *paramCapture);
1565 
1566 // GL 4.1
1567 void CaptureDepthRangeArrayv_v(const State &glState,
1568                                bool isCallValid,
1569                                GLuint first,
1570                                GLsizei count,
1571                                const GLdouble *v,
1572                                angle::ParamCapture *paramCapture);
1573 void CaptureGetDoublei_v_data(const State &glState,
1574                               bool isCallValid,
1575                               GLenum target,
1576                               GLuint index,
1577                               GLdouble *data,
1578                               angle::ParamCapture *paramCapture);
1579 void CaptureGetFloati_v_data(const State &glState,
1580                              bool isCallValid,
1581                              GLenum target,
1582                              GLuint index,
1583                              GLfloat *data,
1584                              angle::ParamCapture *paramCapture);
1585 void CaptureGetVertexAttribLdv_params(const State &glState,
1586                                       bool isCallValid,
1587                                       GLuint index,
1588                                       GLenum pname,
1589                                       GLdouble *params,
1590                                       angle::ParamCapture *paramCapture);
1591 void CaptureProgramUniform1dv_value(const State &glState,
1592                                     bool isCallValid,
1593                                     ShaderProgramID programPacked,
1594                                     UniformLocation locationPacked,
1595                                     GLsizei count,
1596                                     const GLdouble *value,
1597                                     angle::ParamCapture *paramCapture);
1598 void CaptureProgramUniform2dv_value(const State &glState,
1599                                     bool isCallValid,
1600                                     ShaderProgramID programPacked,
1601                                     UniformLocation locationPacked,
1602                                     GLsizei count,
1603                                     const GLdouble *value,
1604                                     angle::ParamCapture *paramCapture);
1605 void CaptureProgramUniform3dv_value(const State &glState,
1606                                     bool isCallValid,
1607                                     ShaderProgramID programPacked,
1608                                     UniformLocation locationPacked,
1609                                     GLsizei count,
1610                                     const GLdouble *value,
1611                                     angle::ParamCapture *paramCapture);
1612 void CaptureProgramUniform4dv_value(const State &glState,
1613                                     bool isCallValid,
1614                                     ShaderProgramID programPacked,
1615                                     UniformLocation locationPacked,
1616                                     GLsizei count,
1617                                     const GLdouble *value,
1618                                     angle::ParamCapture *paramCapture);
1619 void CaptureProgramUniformMatrix2dv_value(const State &glState,
1620                                           bool isCallValid,
1621                                           ShaderProgramID programPacked,
1622                                           UniformLocation locationPacked,
1623                                           GLsizei count,
1624                                           GLboolean transpose,
1625                                           const GLdouble *value,
1626                                           angle::ParamCapture *paramCapture);
1627 void CaptureProgramUniformMatrix2x3dv_value(const State &glState,
1628                                             bool isCallValid,
1629                                             ShaderProgramID programPacked,
1630                                             UniformLocation locationPacked,
1631                                             GLsizei count,
1632                                             GLboolean transpose,
1633                                             const GLdouble *value,
1634                                             angle::ParamCapture *paramCapture);
1635 void CaptureProgramUniformMatrix2x4dv_value(const State &glState,
1636                                             bool isCallValid,
1637                                             ShaderProgramID programPacked,
1638                                             UniformLocation locationPacked,
1639                                             GLsizei count,
1640                                             GLboolean transpose,
1641                                             const GLdouble *value,
1642                                             angle::ParamCapture *paramCapture);
1643 void CaptureProgramUniformMatrix3dv_value(const State &glState,
1644                                           bool isCallValid,
1645                                           ShaderProgramID programPacked,
1646                                           UniformLocation locationPacked,
1647                                           GLsizei count,
1648                                           GLboolean transpose,
1649                                           const GLdouble *value,
1650                                           angle::ParamCapture *paramCapture);
1651 void CaptureProgramUniformMatrix3x2dv_value(const State &glState,
1652                                             bool isCallValid,
1653                                             ShaderProgramID programPacked,
1654                                             UniformLocation locationPacked,
1655                                             GLsizei count,
1656                                             GLboolean transpose,
1657                                             const GLdouble *value,
1658                                             angle::ParamCapture *paramCapture);
1659 void CaptureProgramUniformMatrix3x4dv_value(const State &glState,
1660                                             bool isCallValid,
1661                                             ShaderProgramID programPacked,
1662                                             UniformLocation locationPacked,
1663                                             GLsizei count,
1664                                             GLboolean transpose,
1665                                             const GLdouble *value,
1666                                             angle::ParamCapture *paramCapture);
1667 void CaptureProgramUniformMatrix4dv_value(const State &glState,
1668                                           bool isCallValid,
1669                                           ShaderProgramID programPacked,
1670                                           UniformLocation locationPacked,
1671                                           GLsizei count,
1672                                           GLboolean transpose,
1673                                           const GLdouble *value,
1674                                           angle::ParamCapture *paramCapture);
1675 void CaptureProgramUniformMatrix4x2dv_value(const State &glState,
1676                                             bool isCallValid,
1677                                             ShaderProgramID programPacked,
1678                                             UniformLocation locationPacked,
1679                                             GLsizei count,
1680                                             GLboolean transpose,
1681                                             const GLdouble *value,
1682                                             angle::ParamCapture *paramCapture);
1683 void CaptureProgramUniformMatrix4x3dv_value(const State &glState,
1684                                             bool isCallValid,
1685                                             ShaderProgramID programPacked,
1686                                             UniformLocation locationPacked,
1687                                             GLsizei count,
1688                                             GLboolean transpose,
1689                                             const GLdouble *value,
1690                                             angle::ParamCapture *paramCapture);
1691 void CaptureScissorArrayv_v(const State &glState,
1692                             bool isCallValid,
1693                             GLuint first,
1694                             GLsizei count,
1695                             const GLint *v,
1696                             angle::ParamCapture *paramCapture);
1697 void CaptureScissorIndexedv_v(const State &glState,
1698                               bool isCallValid,
1699                               GLuint index,
1700                               const GLint *v,
1701                               angle::ParamCapture *paramCapture);
1702 void CaptureVertexAttribL1dv_v(const State &glState,
1703                                bool isCallValid,
1704                                GLuint index,
1705                                const GLdouble *v,
1706                                angle::ParamCapture *paramCapture);
1707 void CaptureVertexAttribL2dv_v(const State &glState,
1708                                bool isCallValid,
1709                                GLuint index,
1710                                const GLdouble *v,
1711                                angle::ParamCapture *paramCapture);
1712 void CaptureVertexAttribL3dv_v(const State &glState,
1713                                bool isCallValid,
1714                                GLuint index,
1715                                const GLdouble *v,
1716                                angle::ParamCapture *paramCapture);
1717 void CaptureVertexAttribL4dv_v(const State &glState,
1718                                bool isCallValid,
1719                                GLuint index,
1720                                const GLdouble *v,
1721                                angle::ParamCapture *paramCapture);
1722 void CaptureVertexAttribLPointer_pointer(const State &glState,
1723                                          bool isCallValid,
1724                                          GLuint index,
1725                                          GLint size,
1726                                          GLenum type,
1727                                          GLsizei stride,
1728                                          const void *pointer,
1729                                          angle::ParamCapture *paramCapture);
1730 void CaptureViewportArrayv_v(const State &glState,
1731                              bool isCallValid,
1732                              GLuint first,
1733                              GLsizei count,
1734                              const GLfloat *v,
1735                              angle::ParamCapture *paramCapture);
1736 void CaptureViewportIndexedfv_v(const State &glState,
1737                                 bool isCallValid,
1738                                 GLuint index,
1739                                 const GLfloat *v,
1740                                 angle::ParamCapture *paramCapture);
1741 
1742 // GL 4.2
1743 void CaptureDrawElementsInstancedBaseInstance_indices(const State &glState,
1744                                                       bool isCallValid,
1745                                                       PrimitiveMode modePacked,
1746                                                       GLsizei count,
1747                                                       DrawElementsType typePacked,
1748                                                       const void *indices,
1749                                                       GLsizei instancecount,
1750                                                       GLuint baseinstance,
1751                                                       angle::ParamCapture *paramCapture);
1752 void CaptureDrawElementsInstancedBaseVertexBaseInstance_indices(const State &glState,
1753                                                                 bool isCallValid,
1754                                                                 PrimitiveMode modePacked,
1755                                                                 GLsizei count,
1756                                                                 DrawElementsType typePacked,
1757                                                                 const void *indices,
1758                                                                 GLsizei instancecount,
1759                                                                 GLint basevertex,
1760                                                                 GLuint baseinstance,
1761                                                                 angle::ParamCapture *paramCapture);
1762 void CaptureGetActiveAtomicCounterBufferiv_params(const State &glState,
1763                                                   bool isCallValid,
1764                                                   ShaderProgramID programPacked,
1765                                                   GLuint bufferIndex,
1766                                                   GLenum pname,
1767                                                   GLint *params,
1768                                                   angle::ParamCapture *paramCapture);
1769 
1770 // GL 4.3
1771 void CaptureClearBufferData_data(const State &glState,
1772                                  bool isCallValid,
1773                                  GLenum target,
1774                                  GLenum internalformat,
1775                                  GLenum format,
1776                                  GLenum type,
1777                                  const void *data,
1778                                  angle::ParamCapture *paramCapture);
1779 void CaptureClearBufferSubData_data(const State &glState,
1780                                     bool isCallValid,
1781                                     GLenum target,
1782                                     GLenum internalformat,
1783                                     GLintptr offset,
1784                                     GLsizeiptr size,
1785                                     GLenum format,
1786                                     GLenum type,
1787                                     const void *data,
1788                                     angle::ParamCapture *paramCapture);
1789 void CaptureGetInternalformati64v_params(const State &glState,
1790                                          bool isCallValid,
1791                                          GLenum target,
1792                                          GLenum internalformat,
1793                                          GLenum pname,
1794                                          GLsizei count,
1795                                          GLint64 *params,
1796                                          angle::ParamCapture *paramCapture);
1797 void CaptureGetProgramResourceLocationIndex_name(const State &glState,
1798                                                  bool isCallValid,
1799                                                  ShaderProgramID programPacked,
1800                                                  GLenum programInterface,
1801                                                  const GLchar *name,
1802                                                  angle::ParamCapture *paramCapture);
1803 void CaptureMultiDrawArraysIndirect_indirect(const State &glState,
1804                                              bool isCallValid,
1805                                              PrimitiveMode modePacked,
1806                                              const void *indirect,
1807                                              GLsizei drawcount,
1808                                              GLsizei stride,
1809                                              angle::ParamCapture *paramCapture);
1810 void CaptureMultiDrawElementsIndirect_indirect(const State &glState,
1811                                                bool isCallValid,
1812                                                PrimitiveMode modePacked,
1813                                                DrawElementsType typePacked,
1814                                                const void *indirect,
1815                                                GLsizei drawcount,
1816                                                GLsizei stride,
1817                                                angle::ParamCapture *paramCapture);
1818 
1819 // GL 4.4
1820 void CaptureBindBuffersBase_buffersPacked(const State &glState,
1821                                           bool isCallValid,
1822                                           GLenum target,
1823                                           GLuint first,
1824                                           GLsizei count,
1825                                           const BufferID *buffersPacked,
1826                                           angle::ParamCapture *paramCapture);
1827 void CaptureBindBuffersRange_buffersPacked(const State &glState,
1828                                            bool isCallValid,
1829                                            GLenum target,
1830                                            GLuint first,
1831                                            GLsizei count,
1832                                            const BufferID *buffersPacked,
1833                                            const GLintptr *offsets,
1834                                            const GLsizeiptr *sizes,
1835                                            angle::ParamCapture *paramCapture);
1836 void CaptureBindBuffersRange_offsets(const State &glState,
1837                                      bool isCallValid,
1838                                      GLenum target,
1839                                      GLuint first,
1840                                      GLsizei count,
1841                                      const BufferID *buffersPacked,
1842                                      const GLintptr *offsets,
1843                                      const GLsizeiptr *sizes,
1844                                      angle::ParamCapture *paramCapture);
1845 void CaptureBindBuffersRange_sizes(const State &glState,
1846                                    bool isCallValid,
1847                                    GLenum target,
1848                                    GLuint first,
1849                                    GLsizei count,
1850                                    const BufferID *buffersPacked,
1851                                    const GLintptr *offsets,
1852                                    const GLsizeiptr *sizes,
1853                                    angle::ParamCapture *paramCapture);
1854 void CaptureBindImageTextures_textures(const State &glState,
1855                                        bool isCallValid,
1856                                        GLuint first,
1857                                        GLsizei count,
1858                                        const GLuint *textures,
1859                                        angle::ParamCapture *paramCapture);
1860 void CaptureBindSamplers_samplers(const State &glState,
1861                                   bool isCallValid,
1862                                   GLuint first,
1863                                   GLsizei count,
1864                                   const GLuint *samplers,
1865                                   angle::ParamCapture *paramCapture);
1866 void CaptureBindTextures_textures(const State &glState,
1867                                   bool isCallValid,
1868                                   GLuint first,
1869                                   GLsizei count,
1870                                   const GLuint *textures,
1871                                   angle::ParamCapture *paramCapture);
1872 void CaptureBindVertexBuffers_buffersPacked(const State &glState,
1873                                             bool isCallValid,
1874                                             GLuint first,
1875                                             GLsizei count,
1876                                             const BufferID *buffersPacked,
1877                                             const GLintptr *offsets,
1878                                             const GLsizei *strides,
1879                                             angle::ParamCapture *paramCapture);
1880 void CaptureBindVertexBuffers_offsets(const State &glState,
1881                                       bool isCallValid,
1882                                       GLuint first,
1883                                       GLsizei count,
1884                                       const BufferID *buffersPacked,
1885                                       const GLintptr *offsets,
1886                                       const GLsizei *strides,
1887                                       angle::ParamCapture *paramCapture);
1888 void CaptureBindVertexBuffers_strides(const State &glState,
1889                                       bool isCallValid,
1890                                       GLuint first,
1891                                       GLsizei count,
1892                                       const BufferID *buffersPacked,
1893                                       const GLintptr *offsets,
1894                                       const GLsizei *strides,
1895                                       angle::ParamCapture *paramCapture);
1896 void CaptureBufferStorage_data(const State &glState,
1897                                bool isCallValid,
1898                                BufferBinding targetPacked,
1899                                GLsizeiptr size,
1900                                const void *data,
1901                                GLbitfield flags,
1902                                angle::ParamCapture *paramCapture);
1903 void CaptureClearTexImage_data(const State &glState,
1904                                bool isCallValid,
1905                                TextureID texturePacked,
1906                                GLint level,
1907                                GLenum format,
1908                                GLenum type,
1909                                const void *data,
1910                                angle::ParamCapture *paramCapture);
1911 void CaptureClearTexSubImage_data(const State &glState,
1912                                   bool isCallValid,
1913                                   TextureID texturePacked,
1914                                   GLint level,
1915                                   GLint xoffset,
1916                                   GLint yoffset,
1917                                   GLint zoffset,
1918                                   GLsizei width,
1919                                   GLsizei height,
1920                                   GLsizei depth,
1921                                   GLenum format,
1922                                   GLenum type,
1923                                   const void *data,
1924                                   angle::ParamCapture *paramCapture);
1925 
1926 // GL 4.5
1927 void CaptureClearNamedBufferData_data(const State &glState,
1928                                       bool isCallValid,
1929                                       BufferID bufferPacked,
1930                                       GLenum internalformat,
1931                                       GLenum format,
1932                                       GLenum type,
1933                                       const void *data,
1934                                       angle::ParamCapture *paramCapture);
1935 void CaptureClearNamedBufferSubData_data(const State &glState,
1936                                          bool isCallValid,
1937                                          BufferID bufferPacked,
1938                                          GLenum internalformat,
1939                                          GLintptr offset,
1940                                          GLsizeiptr size,
1941                                          GLenum format,
1942                                          GLenum type,
1943                                          const void *data,
1944                                          angle::ParamCapture *paramCapture);
1945 void CaptureClearNamedFramebufferfv_value(const State &glState,
1946                                           bool isCallValid,
1947                                           FramebufferID framebufferPacked,
1948                                           GLenum buffer,
1949                                           GLint drawbuffer,
1950                                           const GLfloat *value,
1951                                           angle::ParamCapture *paramCapture);
1952 void CaptureClearNamedFramebufferiv_value(const State &glState,
1953                                           bool isCallValid,
1954                                           FramebufferID framebufferPacked,
1955                                           GLenum buffer,
1956                                           GLint drawbuffer,
1957                                           const GLint *value,
1958                                           angle::ParamCapture *paramCapture);
1959 void CaptureClearNamedFramebufferuiv_value(const State &glState,
1960                                            bool isCallValid,
1961                                            FramebufferID framebufferPacked,
1962                                            GLenum buffer,
1963                                            GLint drawbuffer,
1964                                            const GLuint *value,
1965                                            angle::ParamCapture *paramCapture);
1966 void CaptureCompressedTextureSubImage1D_data(const State &glState,
1967                                              bool isCallValid,
1968                                              TextureID texturePacked,
1969                                              GLint level,
1970                                              GLint xoffset,
1971                                              GLsizei width,
1972                                              GLenum format,
1973                                              GLsizei imageSize,
1974                                              const void *data,
1975                                              angle::ParamCapture *paramCapture);
1976 void CaptureCompressedTextureSubImage2D_data(const State &glState,
1977                                              bool isCallValid,
1978                                              TextureID texturePacked,
1979                                              GLint level,
1980                                              GLint xoffset,
1981                                              GLint yoffset,
1982                                              GLsizei width,
1983                                              GLsizei height,
1984                                              GLenum format,
1985                                              GLsizei imageSize,
1986                                              const void *data,
1987                                              angle::ParamCapture *paramCapture);
1988 void CaptureCompressedTextureSubImage3D_data(const State &glState,
1989                                              bool isCallValid,
1990                                              TextureID texturePacked,
1991                                              GLint level,
1992                                              GLint xoffset,
1993                                              GLint yoffset,
1994                                              GLint zoffset,
1995                                              GLsizei width,
1996                                              GLsizei height,
1997                                              GLsizei depth,
1998                                              GLenum format,
1999                                              GLsizei imageSize,
2000                                              const void *data,
2001                                              angle::ParamCapture *paramCapture);
2002 void CaptureCreateBuffers_buffersPacked(const State &glState,
2003                                         bool isCallValid,
2004                                         GLsizei n,
2005                                         BufferID *buffersPacked,
2006                                         angle::ParamCapture *paramCapture);
2007 void CaptureCreateFramebuffers_framebuffers(const State &glState,
2008                                             bool isCallValid,
2009                                             GLsizei n,
2010                                             GLuint *framebuffers,
2011                                             angle::ParamCapture *paramCapture);
2012 void CaptureCreateProgramPipelines_pipelines(const State &glState,
2013                                              bool isCallValid,
2014                                              GLsizei n,
2015                                              GLuint *pipelines,
2016                                              angle::ParamCapture *paramCapture);
2017 void CaptureCreateQueries_ids(const State &glState,
2018                               bool isCallValid,
2019                               GLenum target,
2020                               GLsizei n,
2021                               GLuint *ids,
2022                               angle::ParamCapture *paramCapture);
2023 void CaptureCreateRenderbuffers_renderbuffersPacked(const State &glState,
2024                                                     bool isCallValid,
2025                                                     GLsizei n,
2026                                                     RenderbufferID *renderbuffersPacked,
2027                                                     angle::ParamCapture *paramCapture);
2028 void CaptureCreateSamplers_samplers(const State &glState,
2029                                     bool isCallValid,
2030                                     GLsizei n,
2031                                     GLuint *samplers,
2032                                     angle::ParamCapture *paramCapture);
2033 void CaptureCreateTextures_textures(const State &glState,
2034                                     bool isCallValid,
2035                                     GLenum target,
2036                                     GLsizei n,
2037                                     GLuint *textures,
2038                                     angle::ParamCapture *paramCapture);
2039 void CaptureCreateTransformFeedbacks_ids(const State &glState,
2040                                          bool isCallValid,
2041                                          GLsizei n,
2042                                          GLuint *ids,
2043                                          angle::ParamCapture *paramCapture);
2044 void CaptureCreateVertexArrays_arraysPacked(const State &glState,
2045                                             bool isCallValid,
2046                                             GLsizei n,
2047                                             VertexArrayID *arraysPacked,
2048                                             angle::ParamCapture *paramCapture);
2049 void CaptureGetCompressedTextureImage_pixels(const State &glState,
2050                                              bool isCallValid,
2051                                              TextureID texturePacked,
2052                                              GLint level,
2053                                              GLsizei bufSize,
2054                                              void *pixels,
2055                                              angle::ParamCapture *paramCapture);
2056 void CaptureGetCompressedTextureSubImage_pixels(const State &glState,
2057                                                 bool isCallValid,
2058                                                 TextureID texturePacked,
2059                                                 GLint level,
2060                                                 GLint xoffset,
2061                                                 GLint yoffset,
2062                                                 GLint zoffset,
2063                                                 GLsizei width,
2064                                                 GLsizei height,
2065                                                 GLsizei depth,
2066                                                 GLsizei bufSize,
2067                                                 void *pixels,
2068                                                 angle::ParamCapture *paramCapture);
2069 void CaptureGetNamedBufferParameteri64v_params(const State &glState,
2070                                                bool isCallValid,
2071                                                BufferID bufferPacked,
2072                                                GLenum pname,
2073                                                GLint64 *params,
2074                                                angle::ParamCapture *paramCapture);
2075 void CaptureGetNamedBufferParameteriv_params(const State &glState,
2076                                              bool isCallValid,
2077                                              BufferID bufferPacked,
2078                                              GLenum pname,
2079                                              GLint *params,
2080                                              angle::ParamCapture *paramCapture);
2081 void CaptureGetNamedBufferPointerv_params(const State &glState,
2082                                           bool isCallValid,
2083                                           BufferID bufferPacked,
2084                                           GLenum pname,
2085                                           void **params,
2086                                           angle::ParamCapture *paramCapture);
2087 void CaptureGetNamedBufferSubData_data(const State &glState,
2088                                        bool isCallValid,
2089                                        BufferID bufferPacked,
2090                                        GLintptr offset,
2091                                        GLsizeiptr size,
2092                                        void *data,
2093                                        angle::ParamCapture *paramCapture);
2094 void CaptureGetNamedFramebufferAttachmentParameteriv_params(const State &glState,
2095                                                             bool isCallValid,
2096                                                             FramebufferID framebufferPacked,
2097                                                             GLenum attachment,
2098                                                             GLenum pname,
2099                                                             GLint *params,
2100                                                             angle::ParamCapture *paramCapture);
2101 void CaptureGetNamedFramebufferParameteriv_param(const State &glState,
2102                                                  bool isCallValid,
2103                                                  FramebufferID framebufferPacked,
2104                                                  GLenum pname,
2105                                                  GLint *param,
2106                                                  angle::ParamCapture *paramCapture);
2107 void CaptureGetNamedRenderbufferParameteriv_params(const State &glState,
2108                                                    bool isCallValid,
2109                                                    RenderbufferID renderbufferPacked,
2110                                                    GLenum pname,
2111                                                    GLint *params,
2112                                                    angle::ParamCapture *paramCapture);
2113 void CaptureGetTextureImage_pixels(const State &glState,
2114                                    bool isCallValid,
2115                                    TextureID texturePacked,
2116                                    GLint level,
2117                                    GLenum format,
2118                                    GLenum type,
2119                                    GLsizei bufSize,
2120                                    void *pixels,
2121                                    angle::ParamCapture *paramCapture);
2122 void CaptureGetTextureLevelParameterfv_params(const State &glState,
2123                                               bool isCallValid,
2124                                               TextureID texturePacked,
2125                                               GLint level,
2126                                               GLenum pname,
2127                                               GLfloat *params,
2128                                               angle::ParamCapture *paramCapture);
2129 void CaptureGetTextureLevelParameteriv_params(const State &glState,
2130                                               bool isCallValid,
2131                                               TextureID texturePacked,
2132                                               GLint level,
2133                                               GLenum pname,
2134                                               GLint *params,
2135                                               angle::ParamCapture *paramCapture);
2136 void CaptureGetTextureParameterIiv_params(const State &glState,
2137                                           bool isCallValid,
2138                                           TextureID texturePacked,
2139                                           GLenum pname,
2140                                           GLint *params,
2141                                           angle::ParamCapture *paramCapture);
2142 void CaptureGetTextureParameterIuiv_params(const State &glState,
2143                                            bool isCallValid,
2144                                            TextureID texturePacked,
2145                                            GLenum pname,
2146                                            GLuint *params,
2147                                            angle::ParamCapture *paramCapture);
2148 void CaptureGetTextureParameterfv_params(const State &glState,
2149                                          bool isCallValid,
2150                                          TextureID texturePacked,
2151                                          GLenum pname,
2152                                          GLfloat *params,
2153                                          angle::ParamCapture *paramCapture);
2154 void CaptureGetTextureParameteriv_params(const State &glState,
2155                                          bool isCallValid,
2156                                          TextureID texturePacked,
2157                                          GLenum pname,
2158                                          GLint *params,
2159                                          angle::ParamCapture *paramCapture);
2160 void CaptureGetTextureSubImage_pixels(const State &glState,
2161                                       bool isCallValid,
2162                                       TextureID texturePacked,
2163                                       GLint level,
2164                                       GLint xoffset,
2165                                       GLint yoffset,
2166                                       GLint zoffset,
2167                                       GLsizei width,
2168                                       GLsizei height,
2169                                       GLsizei depth,
2170                                       GLenum format,
2171                                       GLenum type,
2172                                       GLsizei bufSize,
2173                                       void *pixels,
2174                                       angle::ParamCapture *paramCapture);
2175 void CaptureGetTransformFeedbacki64_v_param(const State &glState,
2176                                             bool isCallValid,
2177                                             GLuint xfb,
2178                                             GLenum pname,
2179                                             GLuint index,
2180                                             GLint64 *param,
2181                                             angle::ParamCapture *paramCapture);
2182 void CaptureGetTransformFeedbacki_v_param(const State &glState,
2183                                           bool isCallValid,
2184                                           GLuint xfb,
2185                                           GLenum pname,
2186                                           GLuint index,
2187                                           GLint *param,
2188                                           angle::ParamCapture *paramCapture);
2189 void CaptureGetTransformFeedbackiv_param(const State &glState,
2190                                          bool isCallValid,
2191                                          GLuint xfb,
2192                                          GLenum pname,
2193                                          GLint *param,
2194                                          angle::ParamCapture *paramCapture);
2195 void CaptureGetVertexArrayIndexed64iv_param(const State &glState,
2196                                             bool isCallValid,
2197                                             VertexArrayID vaobjPacked,
2198                                             GLuint index,
2199                                             GLenum pname,
2200                                             GLint64 *param,
2201                                             angle::ParamCapture *paramCapture);
2202 void CaptureGetVertexArrayIndexediv_param(const State &glState,
2203                                           bool isCallValid,
2204                                           VertexArrayID vaobjPacked,
2205                                           GLuint index,
2206                                           GLenum pname,
2207                                           GLint *param,
2208                                           angle::ParamCapture *paramCapture);
2209 void CaptureGetVertexArrayiv_param(const State &glState,
2210                                    bool isCallValid,
2211                                    VertexArrayID vaobjPacked,
2212                                    GLenum pname,
2213                                    GLint *param,
2214                                    angle::ParamCapture *paramCapture);
2215 void CaptureGetnColorTable_table(const State &glState,
2216                                  bool isCallValid,
2217                                  GLenum target,
2218                                  GLenum format,
2219                                  GLenum type,
2220                                  GLsizei bufSize,
2221                                  void *table,
2222                                  angle::ParamCapture *paramCapture);
2223 void CaptureGetnCompressedTexImage_pixels(const State &glState,
2224                                           bool isCallValid,
2225                                           GLenum target,
2226                                           GLint lod,
2227                                           GLsizei bufSize,
2228                                           void *pixels,
2229                                           angle::ParamCapture *paramCapture);
2230 void CaptureGetnConvolutionFilter_image(const State &glState,
2231                                         bool isCallValid,
2232                                         GLenum target,
2233                                         GLenum format,
2234                                         GLenum type,
2235                                         GLsizei bufSize,
2236                                         void *image,
2237                                         angle::ParamCapture *paramCapture);
2238 void CaptureGetnHistogram_values(const State &glState,
2239                                  bool isCallValid,
2240                                  GLenum target,
2241                                  GLboolean reset,
2242                                  GLenum format,
2243                                  GLenum type,
2244                                  GLsizei bufSize,
2245                                  void *values,
2246                                  angle::ParamCapture *paramCapture);
2247 void CaptureGetnMapdv_v(const State &glState,
2248                         bool isCallValid,
2249                         GLenum target,
2250                         GLenum query,
2251                         GLsizei bufSize,
2252                         GLdouble *v,
2253                         angle::ParamCapture *paramCapture);
2254 void CaptureGetnMapfv_v(const State &glState,
2255                         bool isCallValid,
2256                         GLenum target,
2257                         GLenum query,
2258                         GLsizei bufSize,
2259                         GLfloat *v,
2260                         angle::ParamCapture *paramCapture);
2261 void CaptureGetnMapiv_v(const State &glState,
2262                         bool isCallValid,
2263                         GLenum target,
2264                         GLenum query,
2265                         GLsizei bufSize,
2266                         GLint *v,
2267                         angle::ParamCapture *paramCapture);
2268 void CaptureGetnMinmax_values(const State &glState,
2269                               bool isCallValid,
2270                               GLenum target,
2271                               GLboolean reset,
2272                               GLenum format,
2273                               GLenum type,
2274                               GLsizei bufSize,
2275                               void *values,
2276                               angle::ParamCapture *paramCapture);
2277 void CaptureGetnPixelMapfv_values(const State &glState,
2278                                   bool isCallValid,
2279                                   GLenum map,
2280                                   GLsizei bufSize,
2281                                   GLfloat *values,
2282                                   angle::ParamCapture *paramCapture);
2283 void CaptureGetnPixelMapuiv_values(const State &glState,
2284                                    bool isCallValid,
2285                                    GLenum map,
2286                                    GLsizei bufSize,
2287                                    GLuint *values,
2288                                    angle::ParamCapture *paramCapture);
2289 void CaptureGetnPixelMapusv_values(const State &glState,
2290                                    bool isCallValid,
2291                                    GLenum map,
2292                                    GLsizei bufSize,
2293                                    GLushort *values,
2294                                    angle::ParamCapture *paramCapture);
2295 void CaptureGetnPolygonStipple_pattern(const State &glState,
2296                                        bool isCallValid,
2297                                        GLsizei bufSize,
2298                                        GLubyte *pattern,
2299                                        angle::ParamCapture *paramCapture);
2300 void CaptureGetnSeparableFilter_row(const State &glState,
2301                                     bool isCallValid,
2302                                     GLenum target,
2303                                     GLenum format,
2304                                     GLenum type,
2305                                     GLsizei rowBufSize,
2306                                     void *row,
2307                                     GLsizei columnBufSize,
2308                                     void *column,
2309                                     void *span,
2310                                     angle::ParamCapture *paramCapture);
2311 void CaptureGetnSeparableFilter_column(const State &glState,
2312                                        bool isCallValid,
2313                                        GLenum target,
2314                                        GLenum format,
2315                                        GLenum type,
2316                                        GLsizei rowBufSize,
2317                                        void *row,
2318                                        GLsizei columnBufSize,
2319                                        void *column,
2320                                        void *span,
2321                                        angle::ParamCapture *paramCapture);
2322 void CaptureGetnSeparableFilter_span(const State &glState,
2323                                      bool isCallValid,
2324                                      GLenum target,
2325                                      GLenum format,
2326                                      GLenum type,
2327                                      GLsizei rowBufSize,
2328                                      void *row,
2329                                      GLsizei columnBufSize,
2330                                      void *column,
2331                                      void *span,
2332                                      angle::ParamCapture *paramCapture);
2333 void CaptureGetnTexImage_pixels(const State &glState,
2334                                 bool isCallValid,
2335                                 GLenum target,
2336                                 GLint level,
2337                                 GLenum format,
2338                                 GLenum type,
2339                                 GLsizei bufSize,
2340                                 void *pixels,
2341                                 angle::ParamCapture *paramCapture);
2342 void CaptureGetnUniformdv_params(const State &glState,
2343                                  bool isCallValid,
2344                                  ShaderProgramID programPacked,
2345                                  UniformLocation locationPacked,
2346                                  GLsizei bufSize,
2347                                  GLdouble *params,
2348                                  angle::ParamCapture *paramCapture);
2349 void CaptureInvalidateNamedFramebufferData_attachments(const State &glState,
2350                                                        bool isCallValid,
2351                                                        FramebufferID framebufferPacked,
2352                                                        GLsizei numAttachments,
2353                                                        const GLenum *attachments,
2354                                                        angle::ParamCapture *paramCapture);
2355 void CaptureInvalidateNamedFramebufferSubData_attachments(const State &glState,
2356                                                           bool isCallValid,
2357                                                           FramebufferID framebufferPacked,
2358                                                           GLsizei numAttachments,
2359                                                           const GLenum *attachments,
2360                                                           GLint x,
2361                                                           GLint y,
2362                                                           GLsizei width,
2363                                                           GLsizei height,
2364                                                           angle::ParamCapture *paramCapture);
2365 void CaptureNamedBufferData_data(const State &glState,
2366                                  bool isCallValid,
2367                                  BufferID bufferPacked,
2368                                  GLsizeiptr size,
2369                                  const void *data,
2370                                  GLenum usage,
2371                                  angle::ParamCapture *paramCapture);
2372 void CaptureNamedBufferStorage_data(const State &glState,
2373                                     bool isCallValid,
2374                                     BufferID bufferPacked,
2375                                     GLsizeiptr size,
2376                                     const void *data,
2377                                     GLbitfield flags,
2378                                     angle::ParamCapture *paramCapture);
2379 void CaptureNamedBufferSubData_data(const State &glState,
2380                                     bool isCallValid,
2381                                     BufferID bufferPacked,
2382                                     GLintptr offset,
2383                                     GLsizeiptr size,
2384                                     const void *data,
2385                                     angle::ParamCapture *paramCapture);
2386 void CaptureNamedFramebufferDrawBuffers_bufs(const State &glState,
2387                                              bool isCallValid,
2388                                              FramebufferID framebufferPacked,
2389                                              GLsizei n,
2390                                              const GLenum *bufs,
2391                                              angle::ParamCapture *paramCapture);
2392 void CaptureTextureParameterIiv_params(const State &glState,
2393                                        bool isCallValid,
2394                                        TextureID texturePacked,
2395                                        GLenum pname,
2396                                        const GLint *params,
2397                                        angle::ParamCapture *paramCapture);
2398 void CaptureTextureParameterIuiv_params(const State &glState,
2399                                         bool isCallValid,
2400                                         TextureID texturePacked,
2401                                         GLenum pname,
2402                                         const GLuint *params,
2403                                         angle::ParamCapture *paramCapture);
2404 void CaptureTextureParameterfv_param(const State &glState,
2405                                      bool isCallValid,
2406                                      TextureID texturePacked,
2407                                      GLenum pname,
2408                                      const GLfloat *param,
2409                                      angle::ParamCapture *paramCapture);
2410 void CaptureTextureParameteriv_param(const State &glState,
2411                                      bool isCallValid,
2412                                      TextureID texturePacked,
2413                                      GLenum pname,
2414                                      const GLint *param,
2415                                      angle::ParamCapture *paramCapture);
2416 void CaptureTextureSubImage1D_pixels(const State &glState,
2417                                      bool isCallValid,
2418                                      TextureID texturePacked,
2419                                      GLint level,
2420                                      GLint xoffset,
2421                                      GLsizei width,
2422                                      GLenum format,
2423                                      GLenum type,
2424                                      const void *pixels,
2425                                      angle::ParamCapture *paramCapture);
2426 void CaptureTextureSubImage2D_pixels(const State &glState,
2427                                      bool isCallValid,
2428                                      TextureID texturePacked,
2429                                      GLint level,
2430                                      GLint xoffset,
2431                                      GLint yoffset,
2432                                      GLsizei width,
2433                                      GLsizei height,
2434                                      GLenum format,
2435                                      GLenum type,
2436                                      const void *pixels,
2437                                      angle::ParamCapture *paramCapture);
2438 void CaptureTextureSubImage3D_pixels(const State &glState,
2439                                      bool isCallValid,
2440                                      TextureID texturePacked,
2441                                      GLint level,
2442                                      GLint xoffset,
2443                                      GLint yoffset,
2444                                      GLint zoffset,
2445                                      GLsizei width,
2446                                      GLsizei height,
2447                                      GLsizei depth,
2448                                      GLenum format,
2449                                      GLenum type,
2450                                      const void *pixels,
2451                                      angle::ParamCapture *paramCapture);
2452 void CaptureVertexArrayVertexBuffers_buffersPacked(const State &glState,
2453                                                    bool isCallValid,
2454                                                    VertexArrayID vaobjPacked,
2455                                                    GLuint first,
2456                                                    GLsizei count,
2457                                                    const BufferID *buffersPacked,
2458                                                    const GLintptr *offsets,
2459                                                    const GLsizei *strides,
2460                                                    angle::ParamCapture *paramCapture);
2461 void CaptureVertexArrayVertexBuffers_offsets(const State &glState,
2462                                              bool isCallValid,
2463                                              VertexArrayID vaobjPacked,
2464                                              GLuint first,
2465                                              GLsizei count,
2466                                              const BufferID *buffersPacked,
2467                                              const GLintptr *offsets,
2468                                              const GLsizei *strides,
2469                                              angle::ParamCapture *paramCapture);
2470 void CaptureVertexArrayVertexBuffers_strides(const State &glState,
2471                                              bool isCallValid,
2472                                              VertexArrayID vaobjPacked,
2473                                              GLuint first,
2474                                              GLsizei count,
2475                                              const BufferID *buffersPacked,
2476                                              const GLintptr *offsets,
2477                                              const GLsizei *strides,
2478                                              angle::ParamCapture *paramCapture);
2479 
2480 // GL 4.6
2481 void CaptureMultiDrawArraysIndirectCount_indirect(const State &glState,
2482                                                   bool isCallValid,
2483                                                   GLenum mode,
2484                                                   const void *indirect,
2485                                                   GLintptr drawcount,
2486                                                   GLsizei maxdrawcount,
2487                                                   GLsizei stride,
2488                                                   angle::ParamCapture *paramCapture);
2489 void CaptureMultiDrawElementsIndirectCount_indirect(const State &glState,
2490                                                     bool isCallValid,
2491                                                     GLenum mode,
2492                                                     GLenum type,
2493                                                     const void *indirect,
2494                                                     GLintptr drawcount,
2495                                                     GLsizei maxdrawcount,
2496                                                     GLsizei stride,
2497                                                     angle::ParamCapture *paramCapture);
2498 void CaptureSpecializeShader_pEntryPoint(const State &glState,
2499                                          bool isCallValid,
2500                                          GLuint shader,
2501                                          const GLchar *pEntryPoint,
2502                                          GLuint numSpecializationConstants,
2503                                          const GLuint *pConstantIndex,
2504                                          const GLuint *pConstantValue,
2505                                          angle::ParamCapture *paramCapture);
2506 void CaptureSpecializeShader_pConstantIndex(const State &glState,
2507                                             bool isCallValid,
2508                                             GLuint shader,
2509                                             const GLchar *pEntryPoint,
2510                                             GLuint numSpecializationConstants,
2511                                             const GLuint *pConstantIndex,
2512                                             const GLuint *pConstantValue,
2513                                             angle::ParamCapture *paramCapture);
2514 void CaptureSpecializeShader_pConstantValue(const State &glState,
2515                                             bool isCallValid,
2516                                             GLuint shader,
2517                                             const GLchar *pEntryPoint,
2518                                             GLuint numSpecializationConstants,
2519                                             const GLuint *pConstantIndex,
2520                                             const GLuint *pConstantValue,
2521                                             angle::ParamCapture *paramCapture);
2522 }  // namespace gl
2523 
2524 #endif  // LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
2525