1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // capture_gles_2_0_autogen.h:
9 //   Capture functions for the OpenGL ES 2.0 entry points.
10 
11 #ifndef LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
12 #define LIBANGLE_CAPTURE_GLES_2_0_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 angle::CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture);
23 angle::CallCapture CaptureAttachShader(const State &glState,
24                                        bool isCallValid,
25                                        ShaderProgramID programPacked,
26                                        ShaderProgramID shaderPacked);
27 angle::CallCapture CaptureBindAttribLocation(const State &glState,
28                                              bool isCallValid,
29                                              ShaderProgramID programPacked,
30                                              GLuint index,
31                                              const GLchar *name);
32 angle::CallCapture CaptureBindBuffer(const State &glState,
33                                      bool isCallValid,
34                                      BufferBinding targetPacked,
35                                      BufferID bufferPacked);
36 angle::CallCapture CaptureBindFramebuffer(const State &glState,
37                                           bool isCallValid,
38                                           GLenum target,
39                                           FramebufferID framebufferPacked);
40 angle::CallCapture CaptureBindRenderbuffer(const State &glState,
41                                            bool isCallValid,
42                                            GLenum target,
43                                            RenderbufferID renderbufferPacked);
44 angle::CallCapture CaptureBindTexture(const State &glState,
45                                       bool isCallValid,
46                                       TextureType targetPacked,
47                                       TextureID texturePacked);
48 angle::CallCapture CaptureBlendColor(const State &glState,
49                                      bool isCallValid,
50                                      GLfloat red,
51                                      GLfloat green,
52                                      GLfloat blue,
53                                      GLfloat alpha);
54 angle::CallCapture CaptureBlendEquation(const State &glState, bool isCallValid, GLenum mode);
55 angle::CallCapture CaptureBlendEquationSeparate(const State &glState,
56                                                 bool isCallValid,
57                                                 GLenum modeRGB,
58                                                 GLenum modeAlpha);
59 angle::CallCapture CaptureBlendFunc(const State &glState,
60                                     bool isCallValid,
61                                     GLenum sfactor,
62                                     GLenum dfactor);
63 angle::CallCapture CaptureBlendFuncSeparate(const State &glState,
64                                             bool isCallValid,
65                                             GLenum sfactorRGB,
66                                             GLenum dfactorRGB,
67                                             GLenum sfactorAlpha,
68                                             GLenum dfactorAlpha);
69 angle::CallCapture CaptureBufferData(const State &glState,
70                                      bool isCallValid,
71                                      BufferBinding targetPacked,
72                                      GLsizeiptr size,
73                                      const void *data,
74                                      BufferUsage usagePacked);
75 angle::CallCapture CaptureBufferSubData(const State &glState,
76                                         bool isCallValid,
77                                         BufferBinding targetPacked,
78                                         GLintptr offset,
79                                         GLsizeiptr size,
80                                         const void *data);
81 angle::CallCapture CaptureCheckFramebufferStatus(const State &glState,
82                                                  bool isCallValid,
83                                                  GLenum target,
84                                                  GLenum returnValue);
85 angle::CallCapture CaptureClear(const State &glState, bool isCallValid, GLbitfield mask);
86 angle::CallCapture CaptureClearColor(const State &glState,
87                                      bool isCallValid,
88                                      GLfloat red,
89                                      GLfloat green,
90                                      GLfloat blue,
91                                      GLfloat alpha);
92 angle::CallCapture CaptureClearDepthf(const State &glState, bool isCallValid, GLfloat d);
93 angle::CallCapture CaptureClearStencil(const State &glState, bool isCallValid, GLint s);
94 angle::CallCapture CaptureColorMask(const State &glState,
95                                     bool isCallValid,
96                                     GLboolean red,
97                                     GLboolean green,
98                                     GLboolean blue,
99                                     GLboolean alpha);
100 angle::CallCapture CaptureCompileShader(const State &glState,
101                                         bool isCallValid,
102                                         ShaderProgramID shaderPacked);
103 angle::CallCapture CaptureCompressedTexImage2D(const State &glState,
104                                                bool isCallValid,
105                                                TextureTarget targetPacked,
106                                                GLint level,
107                                                GLenum internalformat,
108                                                GLsizei width,
109                                                GLsizei height,
110                                                GLint border,
111                                                GLsizei imageSize,
112                                                const void *data);
113 angle::CallCapture CaptureCompressedTexSubImage2D(const State &glState,
114                                                   bool isCallValid,
115                                                   TextureTarget targetPacked,
116                                                   GLint level,
117                                                   GLint xoffset,
118                                                   GLint yoffset,
119                                                   GLsizei width,
120                                                   GLsizei height,
121                                                   GLenum format,
122                                                   GLsizei imageSize,
123                                                   const void *data);
124 angle::CallCapture CaptureCopyTexImage2D(const State &glState,
125                                          bool isCallValid,
126                                          TextureTarget targetPacked,
127                                          GLint level,
128                                          GLenum internalformat,
129                                          GLint x,
130                                          GLint y,
131                                          GLsizei width,
132                                          GLsizei height,
133                                          GLint border);
134 angle::CallCapture CaptureCopyTexSubImage2D(const State &glState,
135                                             bool isCallValid,
136                                             TextureTarget targetPacked,
137                                             GLint level,
138                                             GLint xoffset,
139                                             GLint yoffset,
140                                             GLint x,
141                                             GLint y,
142                                             GLsizei width,
143                                             GLsizei height);
144 angle::CallCapture CaptureCreateProgram(const State &glState, bool isCallValid, GLuint returnValue);
145 angle::CallCapture CaptureCreateShader(const State &glState,
146                                        bool isCallValid,
147                                        ShaderType typePacked,
148                                        GLuint returnValue);
149 angle::CallCapture CaptureCullFace(const State &glState, bool isCallValid, CullFaceMode modePacked);
150 angle::CallCapture CaptureDeleteBuffers(const State &glState,
151                                         bool isCallValid,
152                                         GLsizei n,
153                                         const BufferID *buffersPacked);
154 angle::CallCapture CaptureDeleteFramebuffers(const State &glState,
155                                              bool isCallValid,
156                                              GLsizei n,
157                                              const FramebufferID *framebuffersPacked);
158 angle::CallCapture CaptureDeleteProgram(const State &glState,
159                                         bool isCallValid,
160                                         ShaderProgramID programPacked);
161 angle::CallCapture CaptureDeleteRenderbuffers(const State &glState,
162                                               bool isCallValid,
163                                               GLsizei n,
164                                               const RenderbufferID *renderbuffersPacked);
165 angle::CallCapture CaptureDeleteShader(const State &glState,
166                                        bool isCallValid,
167                                        ShaderProgramID shaderPacked);
168 angle::CallCapture CaptureDeleteTextures(const State &glState,
169                                          bool isCallValid,
170                                          GLsizei n,
171                                          const TextureID *texturesPacked);
172 angle::CallCapture CaptureDepthFunc(const State &glState, bool isCallValid, GLenum func);
173 angle::CallCapture CaptureDepthMask(const State &glState, bool isCallValid, GLboolean flag);
174 angle::CallCapture CaptureDepthRangef(const State &glState, bool isCallValid, GLfloat n, GLfloat f);
175 angle::CallCapture CaptureDetachShader(const State &glState,
176                                        bool isCallValid,
177                                        ShaderProgramID programPacked,
178                                        ShaderProgramID shaderPacked);
179 angle::CallCapture CaptureDisable(const State &glState, bool isCallValid, GLenum cap);
180 angle::CallCapture CaptureDisableVertexAttribArray(const State &glState,
181                                                    bool isCallValid,
182                                                    GLuint index);
183 angle::CallCapture CaptureDrawArrays(const State &glState,
184                                      bool isCallValid,
185                                      PrimitiveMode modePacked,
186                                      GLint first,
187                                      GLsizei count);
188 angle::CallCapture CaptureDrawElements(const State &glState,
189                                        bool isCallValid,
190                                        PrimitiveMode modePacked,
191                                        GLsizei count,
192                                        DrawElementsType typePacked,
193                                        const void *indices);
194 angle::CallCapture CaptureEnable(const State &glState, bool isCallValid, GLenum cap);
195 angle::CallCapture CaptureEnableVertexAttribArray(const State &glState,
196                                                   bool isCallValid,
197                                                   GLuint index);
198 angle::CallCapture CaptureFinish(const State &glState, bool isCallValid);
199 angle::CallCapture CaptureFlush(const State &glState, bool isCallValid);
200 angle::CallCapture CaptureFramebufferRenderbuffer(const State &glState,
201                                                   bool isCallValid,
202                                                   GLenum target,
203                                                   GLenum attachment,
204                                                   GLenum renderbuffertarget,
205                                                   RenderbufferID renderbufferPacked);
206 angle::CallCapture CaptureFramebufferTexture2D(const State &glState,
207                                                bool isCallValid,
208                                                GLenum target,
209                                                GLenum attachment,
210                                                TextureTarget textargetPacked,
211                                                TextureID texturePacked,
212                                                GLint level);
213 angle::CallCapture CaptureFrontFace(const State &glState, bool isCallValid, GLenum mode);
214 angle::CallCapture CaptureGenBuffers(const State &glState,
215                                      bool isCallValid,
216                                      GLsizei n,
217                                      BufferID *buffersPacked);
218 angle::CallCapture CaptureGenFramebuffers(const State &glState,
219                                           bool isCallValid,
220                                           GLsizei n,
221                                           FramebufferID *framebuffersPacked);
222 angle::CallCapture CaptureGenRenderbuffers(const State &glState,
223                                            bool isCallValid,
224                                            GLsizei n,
225                                            RenderbufferID *renderbuffersPacked);
226 angle::CallCapture CaptureGenTextures(const State &glState,
227                                       bool isCallValid,
228                                       GLsizei n,
229                                       TextureID *texturesPacked);
230 angle::CallCapture CaptureGenerateMipmap(const State &glState,
231                                          bool isCallValid,
232                                          TextureType targetPacked);
233 angle::CallCapture CaptureGetActiveAttrib(const State &glState,
234                                           bool isCallValid,
235                                           ShaderProgramID programPacked,
236                                           GLuint index,
237                                           GLsizei bufSize,
238                                           GLsizei *length,
239                                           GLint *size,
240                                           GLenum *type,
241                                           GLchar *name);
242 angle::CallCapture CaptureGetActiveUniform(const State &glState,
243                                            bool isCallValid,
244                                            ShaderProgramID programPacked,
245                                            GLuint index,
246                                            GLsizei bufSize,
247                                            GLsizei *length,
248                                            GLint *size,
249                                            GLenum *type,
250                                            GLchar *name);
251 angle::CallCapture CaptureGetAttachedShaders(const State &glState,
252                                              bool isCallValid,
253                                              ShaderProgramID programPacked,
254                                              GLsizei maxCount,
255                                              GLsizei *count,
256                                              ShaderProgramID *shadersPacked);
257 angle::CallCapture CaptureGetAttribLocation(const State &glState,
258                                             bool isCallValid,
259                                             ShaderProgramID programPacked,
260                                             const GLchar *name,
261                                             GLint returnValue);
262 angle::CallCapture CaptureGetBooleanv(const State &glState,
263                                       bool isCallValid,
264                                       GLenum pname,
265                                       GLboolean *data);
266 angle::CallCapture CaptureGetBufferParameteriv(const State &glState,
267                                                bool isCallValid,
268                                                BufferBinding targetPacked,
269                                                GLenum pname,
270                                                GLint *params);
271 angle::CallCapture CaptureGetError(const State &glState, bool isCallValid, GLenum returnValue);
272 angle::CallCapture CaptureGetFloatv(const State &glState,
273                                     bool isCallValid,
274                                     GLenum pname,
275                                     GLfloat *data);
276 angle::CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState,
277                                                               bool isCallValid,
278                                                               GLenum target,
279                                                               GLenum attachment,
280                                                               GLenum pname,
281                                                               GLint *params);
282 angle::CallCapture CaptureGetIntegerv(const State &glState,
283                                       bool isCallValid,
284                                       GLenum pname,
285                                       GLint *data);
286 angle::CallCapture CaptureGetProgramInfoLog(const State &glState,
287                                             bool isCallValid,
288                                             ShaderProgramID programPacked,
289                                             GLsizei bufSize,
290                                             GLsizei *length,
291                                             GLchar *infoLog);
292 angle::CallCapture CaptureGetProgramiv(const State &glState,
293                                        bool isCallValid,
294                                        ShaderProgramID programPacked,
295                                        GLenum pname,
296                                        GLint *params);
297 angle::CallCapture CaptureGetRenderbufferParameteriv(const State &glState,
298                                                      bool isCallValid,
299                                                      GLenum target,
300                                                      GLenum pname,
301                                                      GLint *params);
302 angle::CallCapture CaptureGetShaderInfoLog(const State &glState,
303                                            bool isCallValid,
304                                            ShaderProgramID shaderPacked,
305                                            GLsizei bufSize,
306                                            GLsizei *length,
307                                            GLchar *infoLog);
308 angle::CallCapture CaptureGetShaderPrecisionFormat(const State &glState,
309                                                    bool isCallValid,
310                                                    GLenum shadertype,
311                                                    GLenum precisiontype,
312                                                    GLint *range,
313                                                    GLint *precision);
314 angle::CallCapture CaptureGetShaderSource(const State &glState,
315                                           bool isCallValid,
316                                           ShaderProgramID shaderPacked,
317                                           GLsizei bufSize,
318                                           GLsizei *length,
319                                           GLchar *source);
320 angle::CallCapture CaptureGetShaderiv(const State &glState,
321                                       bool isCallValid,
322                                       ShaderProgramID shaderPacked,
323                                       GLenum pname,
324                                       GLint *params);
325 angle::CallCapture CaptureGetString(const State &glState,
326                                     bool isCallValid,
327                                     GLenum name,
328                                     const GLubyte *returnValue);
329 angle::CallCapture CaptureGetTexParameterfv(const State &glState,
330                                             bool isCallValid,
331                                             TextureType targetPacked,
332                                             GLenum pname,
333                                             GLfloat *params);
334 angle::CallCapture CaptureGetTexParameteriv(const State &glState,
335                                             bool isCallValid,
336                                             TextureType targetPacked,
337                                             GLenum pname,
338                                             GLint *params);
339 angle::CallCapture CaptureGetUniformLocation(const State &glState,
340                                              bool isCallValid,
341                                              ShaderProgramID programPacked,
342                                              const GLchar *name,
343                                              GLint returnValue);
344 angle::CallCapture CaptureGetUniformfv(const State &glState,
345                                        bool isCallValid,
346                                        ShaderProgramID programPacked,
347                                        UniformLocation locationPacked,
348                                        GLfloat *params);
349 angle::CallCapture CaptureGetUniformiv(const State &glState,
350                                        bool isCallValid,
351                                        ShaderProgramID programPacked,
352                                        UniformLocation locationPacked,
353                                        GLint *params);
354 angle::CallCapture CaptureGetVertexAttribPointerv(const State &glState,
355                                                   bool isCallValid,
356                                                   GLuint index,
357                                                   GLenum pname,
358                                                   void **pointer);
359 angle::CallCapture CaptureGetVertexAttribfv(const State &glState,
360                                             bool isCallValid,
361                                             GLuint index,
362                                             GLenum pname,
363                                             GLfloat *params);
364 angle::CallCapture CaptureGetVertexAttribiv(const State &glState,
365                                             bool isCallValid,
366                                             GLuint index,
367                                             GLenum pname,
368                                             GLint *params);
369 angle::CallCapture CaptureHint(const State &glState, bool isCallValid, GLenum target, GLenum mode);
370 angle::CallCapture CaptureIsBuffer(const State &glState,
371                                    bool isCallValid,
372                                    BufferID bufferPacked,
373                                    GLboolean returnValue);
374 angle::CallCapture CaptureIsEnabled(const State &glState,
375                                     bool isCallValid,
376                                     GLenum cap,
377                                     GLboolean returnValue);
378 angle::CallCapture CaptureIsFramebuffer(const State &glState,
379                                         bool isCallValid,
380                                         FramebufferID framebufferPacked,
381                                         GLboolean returnValue);
382 angle::CallCapture CaptureIsProgram(const State &glState,
383                                     bool isCallValid,
384                                     ShaderProgramID programPacked,
385                                     GLboolean returnValue);
386 angle::CallCapture CaptureIsRenderbuffer(const State &glState,
387                                          bool isCallValid,
388                                          RenderbufferID renderbufferPacked,
389                                          GLboolean returnValue);
390 angle::CallCapture CaptureIsShader(const State &glState,
391                                    bool isCallValid,
392                                    ShaderProgramID shaderPacked,
393                                    GLboolean returnValue);
394 angle::CallCapture CaptureIsTexture(const State &glState,
395                                     bool isCallValid,
396                                     TextureID texturePacked,
397                                     GLboolean returnValue);
398 angle::CallCapture CaptureLineWidth(const State &glState, bool isCallValid, GLfloat width);
399 angle::CallCapture CaptureLinkProgram(const State &glState,
400                                       bool isCallValid,
401                                       ShaderProgramID programPacked);
402 angle::CallCapture CapturePixelStorei(const State &glState,
403                                       bool isCallValid,
404                                       GLenum pname,
405                                       GLint param);
406 angle::CallCapture CapturePolygonOffset(const State &glState,
407                                         bool isCallValid,
408                                         GLfloat factor,
409                                         GLfloat units);
410 angle::CallCapture CaptureReadPixels(const State &glState,
411                                      bool isCallValid,
412                                      GLint x,
413                                      GLint y,
414                                      GLsizei width,
415                                      GLsizei height,
416                                      GLenum format,
417                                      GLenum type,
418                                      void *pixels);
419 angle::CallCapture CaptureReleaseShaderCompiler(const State &glState, bool isCallValid);
420 angle::CallCapture CaptureRenderbufferStorage(const State &glState,
421                                               bool isCallValid,
422                                               GLenum target,
423                                               GLenum internalformat,
424                                               GLsizei width,
425                                               GLsizei height);
426 angle::CallCapture CaptureSampleCoverage(const State &glState,
427                                          bool isCallValid,
428                                          GLfloat value,
429                                          GLboolean invert);
430 angle::CallCapture CaptureScissor(const State &glState,
431                                   bool isCallValid,
432                                   GLint x,
433                                   GLint y,
434                                   GLsizei width,
435                                   GLsizei height);
436 angle::CallCapture CaptureShaderBinary(const State &glState,
437                                        bool isCallValid,
438                                        GLsizei count,
439                                        const ShaderProgramID *shadersPacked,
440                                        GLenum binaryformat,
441                                        const void *binary,
442                                        GLsizei length);
443 angle::CallCapture CaptureShaderSource(const State &glState,
444                                        bool isCallValid,
445                                        ShaderProgramID shaderPacked,
446                                        GLsizei count,
447                                        const GLchar *const *string,
448                                        const GLint *length);
449 angle::CallCapture CaptureStencilFunc(const State &glState,
450                                       bool isCallValid,
451                                       GLenum func,
452                                       GLint ref,
453                                       GLuint mask);
454 angle::CallCapture CaptureStencilFuncSeparate(const State &glState,
455                                               bool isCallValid,
456                                               GLenum face,
457                                               GLenum func,
458                                               GLint ref,
459                                               GLuint mask);
460 angle::CallCapture CaptureStencilMask(const State &glState, bool isCallValid, GLuint mask);
461 angle::CallCapture CaptureStencilMaskSeparate(const State &glState,
462                                               bool isCallValid,
463                                               GLenum face,
464                                               GLuint mask);
465 angle::CallCapture CaptureStencilOp(const State &glState,
466                                     bool isCallValid,
467                                     GLenum fail,
468                                     GLenum zfail,
469                                     GLenum zpass);
470 angle::CallCapture CaptureStencilOpSeparate(const State &glState,
471                                             bool isCallValid,
472                                             GLenum face,
473                                             GLenum sfail,
474                                             GLenum dpfail,
475                                             GLenum dppass);
476 angle::CallCapture CaptureTexImage2D(const State &glState,
477                                      bool isCallValid,
478                                      TextureTarget targetPacked,
479                                      GLint level,
480                                      GLint internalformat,
481                                      GLsizei width,
482                                      GLsizei height,
483                                      GLint border,
484                                      GLenum format,
485                                      GLenum type,
486                                      const void *pixels);
487 angle::CallCapture CaptureTexParameterf(const State &glState,
488                                         bool isCallValid,
489                                         TextureType targetPacked,
490                                         GLenum pname,
491                                         GLfloat param);
492 angle::CallCapture CaptureTexParameterfv(const State &glState,
493                                          bool isCallValid,
494                                          TextureType targetPacked,
495                                          GLenum pname,
496                                          const GLfloat *params);
497 angle::CallCapture CaptureTexParameteri(const State &glState,
498                                         bool isCallValid,
499                                         TextureType targetPacked,
500                                         GLenum pname,
501                                         GLint param);
502 angle::CallCapture CaptureTexParameteriv(const State &glState,
503                                          bool isCallValid,
504                                          TextureType targetPacked,
505                                          GLenum pname,
506                                          const GLint *params);
507 angle::CallCapture CaptureTexSubImage2D(const State &glState,
508                                         bool isCallValid,
509                                         TextureTarget targetPacked,
510                                         GLint level,
511                                         GLint xoffset,
512                                         GLint yoffset,
513                                         GLsizei width,
514                                         GLsizei height,
515                                         GLenum format,
516                                         GLenum type,
517                                         const void *pixels);
518 angle::CallCapture CaptureUniform1f(const State &glState,
519                                     bool isCallValid,
520                                     UniformLocation locationPacked,
521                                     GLfloat v0);
522 angle::CallCapture CaptureUniform1fv(const State &glState,
523                                      bool isCallValid,
524                                      UniformLocation locationPacked,
525                                      GLsizei count,
526                                      const GLfloat *value);
527 angle::CallCapture CaptureUniform1i(const State &glState,
528                                     bool isCallValid,
529                                     UniformLocation locationPacked,
530                                     GLint v0);
531 angle::CallCapture CaptureUniform1iv(const State &glState,
532                                      bool isCallValid,
533                                      UniformLocation locationPacked,
534                                      GLsizei count,
535                                      const GLint *value);
536 angle::CallCapture CaptureUniform2f(const State &glState,
537                                     bool isCallValid,
538                                     UniformLocation locationPacked,
539                                     GLfloat v0,
540                                     GLfloat v1);
541 angle::CallCapture CaptureUniform2fv(const State &glState,
542                                      bool isCallValid,
543                                      UniformLocation locationPacked,
544                                      GLsizei count,
545                                      const GLfloat *value);
546 angle::CallCapture CaptureUniform2i(const State &glState,
547                                     bool isCallValid,
548                                     UniformLocation locationPacked,
549                                     GLint v0,
550                                     GLint v1);
551 angle::CallCapture CaptureUniform2iv(const State &glState,
552                                      bool isCallValid,
553                                      UniformLocation locationPacked,
554                                      GLsizei count,
555                                      const GLint *value);
556 angle::CallCapture CaptureUniform3f(const State &glState,
557                                     bool isCallValid,
558                                     UniformLocation locationPacked,
559                                     GLfloat v0,
560                                     GLfloat v1,
561                                     GLfloat v2);
562 angle::CallCapture CaptureUniform3fv(const State &glState,
563                                      bool isCallValid,
564                                      UniformLocation locationPacked,
565                                      GLsizei count,
566                                      const GLfloat *value);
567 angle::CallCapture CaptureUniform3i(const State &glState,
568                                     bool isCallValid,
569                                     UniformLocation locationPacked,
570                                     GLint v0,
571                                     GLint v1,
572                                     GLint v2);
573 angle::CallCapture CaptureUniform3iv(const State &glState,
574                                      bool isCallValid,
575                                      UniformLocation locationPacked,
576                                      GLsizei count,
577                                      const GLint *value);
578 angle::CallCapture CaptureUniform4f(const State &glState,
579                                     bool isCallValid,
580                                     UniformLocation locationPacked,
581                                     GLfloat v0,
582                                     GLfloat v1,
583                                     GLfloat v2,
584                                     GLfloat v3);
585 angle::CallCapture CaptureUniform4fv(const State &glState,
586                                      bool isCallValid,
587                                      UniformLocation locationPacked,
588                                      GLsizei count,
589                                      const GLfloat *value);
590 angle::CallCapture CaptureUniform4i(const State &glState,
591                                     bool isCallValid,
592                                     UniformLocation locationPacked,
593                                     GLint v0,
594                                     GLint v1,
595                                     GLint v2,
596                                     GLint v3);
597 angle::CallCapture CaptureUniform4iv(const State &glState,
598                                      bool isCallValid,
599                                      UniformLocation locationPacked,
600                                      GLsizei count,
601                                      const GLint *value);
602 angle::CallCapture CaptureUniformMatrix2fv(const State &glState,
603                                            bool isCallValid,
604                                            UniformLocation locationPacked,
605                                            GLsizei count,
606                                            GLboolean transpose,
607                                            const GLfloat *value);
608 angle::CallCapture CaptureUniformMatrix3fv(const State &glState,
609                                            bool isCallValid,
610                                            UniformLocation locationPacked,
611                                            GLsizei count,
612                                            GLboolean transpose,
613                                            const GLfloat *value);
614 angle::CallCapture CaptureUniformMatrix4fv(const State &glState,
615                                            bool isCallValid,
616                                            UniformLocation locationPacked,
617                                            GLsizei count,
618                                            GLboolean transpose,
619                                            const GLfloat *value);
620 angle::CallCapture CaptureUseProgram(const State &glState,
621                                      bool isCallValid,
622                                      ShaderProgramID programPacked);
623 angle::CallCapture CaptureValidateProgram(const State &glState,
624                                           bool isCallValid,
625                                           ShaderProgramID programPacked);
626 angle::CallCapture CaptureVertexAttrib1f(const State &glState,
627                                          bool isCallValid,
628                                          GLuint index,
629                                          GLfloat x);
630 angle::CallCapture CaptureVertexAttrib1fv(const State &glState,
631                                           bool isCallValid,
632                                           GLuint index,
633                                           const GLfloat *v);
634 angle::CallCapture CaptureVertexAttrib2f(const State &glState,
635                                          bool isCallValid,
636                                          GLuint index,
637                                          GLfloat x,
638                                          GLfloat y);
639 angle::CallCapture CaptureVertexAttrib2fv(const State &glState,
640                                           bool isCallValid,
641                                           GLuint index,
642                                           const GLfloat *v);
643 angle::CallCapture CaptureVertexAttrib3f(const State &glState,
644                                          bool isCallValid,
645                                          GLuint index,
646                                          GLfloat x,
647                                          GLfloat y,
648                                          GLfloat z);
649 angle::CallCapture CaptureVertexAttrib3fv(const State &glState,
650                                           bool isCallValid,
651                                           GLuint index,
652                                           const GLfloat *v);
653 angle::CallCapture CaptureVertexAttrib4f(const State &glState,
654                                          bool isCallValid,
655                                          GLuint index,
656                                          GLfloat x,
657                                          GLfloat y,
658                                          GLfloat z,
659                                          GLfloat w);
660 angle::CallCapture CaptureVertexAttrib4fv(const State &glState,
661                                           bool isCallValid,
662                                           GLuint index,
663                                           const GLfloat *v);
664 angle::CallCapture CaptureVertexAttribPointer(const State &glState,
665                                               bool isCallValid,
666                                               GLuint index,
667                                               GLint size,
668                                               VertexAttribType typePacked,
669                                               GLboolean normalized,
670                                               GLsizei stride,
671                                               const void *pointer);
672 angle::CallCapture CaptureViewport(const State &glState,
673                                    bool isCallValid,
674                                    GLint x,
675                                    GLint y,
676                                    GLsizei width,
677                                    GLsizei height);
678 
679 // Parameter Captures
680 
681 void CaptureBindAttribLocation_name(const State &glState,
682                                     bool isCallValid,
683                                     ShaderProgramID programPacked,
684                                     GLuint index,
685                                     const GLchar *name,
686                                     angle::ParamCapture *paramCapture);
687 void CaptureBufferData_data(const State &glState,
688                             bool isCallValid,
689                             BufferBinding targetPacked,
690                             GLsizeiptr size,
691                             const void *data,
692                             BufferUsage usagePacked,
693                             angle::ParamCapture *paramCapture);
694 void CaptureBufferSubData_data(const State &glState,
695                                bool isCallValid,
696                                BufferBinding targetPacked,
697                                GLintptr offset,
698                                GLsizeiptr size,
699                                const void *data,
700                                angle::ParamCapture *paramCapture);
701 void CaptureCompressedTexImage2D_data(const State &glState,
702                                       bool isCallValid,
703                                       TextureTarget targetPacked,
704                                       GLint level,
705                                       GLenum internalformat,
706                                       GLsizei width,
707                                       GLsizei height,
708                                       GLint border,
709                                       GLsizei imageSize,
710                                       const void *data,
711                                       angle::ParamCapture *paramCapture);
712 void CaptureCompressedTexSubImage2D_data(const State &glState,
713                                          bool isCallValid,
714                                          TextureTarget targetPacked,
715                                          GLint level,
716                                          GLint xoffset,
717                                          GLint yoffset,
718                                          GLsizei width,
719                                          GLsizei height,
720                                          GLenum format,
721                                          GLsizei imageSize,
722                                          const void *data,
723                                          angle::ParamCapture *paramCapture);
724 void CaptureDeleteBuffers_buffersPacked(const State &glState,
725                                         bool isCallValid,
726                                         GLsizei n,
727                                         const BufferID *buffersPacked,
728                                         angle::ParamCapture *paramCapture);
729 void CaptureDeleteFramebuffers_framebuffersPacked(const State &glState,
730                                                   bool isCallValid,
731                                                   GLsizei n,
732                                                   const FramebufferID *framebuffersPacked,
733                                                   angle::ParamCapture *paramCapture);
734 void CaptureDeleteRenderbuffers_renderbuffersPacked(const State &glState,
735                                                     bool isCallValid,
736                                                     GLsizei n,
737                                                     const RenderbufferID *renderbuffersPacked,
738                                                     angle::ParamCapture *paramCapture);
739 void CaptureDeleteTextures_texturesPacked(const State &glState,
740                                           bool isCallValid,
741                                           GLsizei n,
742                                           const TextureID *texturesPacked,
743                                           angle::ParamCapture *paramCapture);
744 void CaptureDrawElements_indices(const State &glState,
745                                  bool isCallValid,
746                                  PrimitiveMode modePacked,
747                                  GLsizei count,
748                                  DrawElementsType typePacked,
749                                  const void *indices,
750                                  angle::ParamCapture *paramCapture);
751 void CaptureGenBuffers_buffersPacked(const State &glState,
752                                      bool isCallValid,
753                                      GLsizei n,
754                                      BufferID *buffersPacked,
755                                      angle::ParamCapture *paramCapture);
756 void CaptureGenFramebuffers_framebuffersPacked(const State &glState,
757                                                bool isCallValid,
758                                                GLsizei n,
759                                                FramebufferID *framebuffersPacked,
760                                                angle::ParamCapture *paramCapture);
761 void CaptureGenRenderbuffers_renderbuffersPacked(const State &glState,
762                                                  bool isCallValid,
763                                                  GLsizei n,
764                                                  RenderbufferID *renderbuffersPacked,
765                                                  angle::ParamCapture *paramCapture);
766 void CaptureGenTextures_texturesPacked(const State &glState,
767                                        bool isCallValid,
768                                        GLsizei n,
769                                        TextureID *texturesPacked,
770                                        angle::ParamCapture *paramCapture);
771 void CaptureGetActiveAttrib_length(const State &glState,
772                                    bool isCallValid,
773                                    ShaderProgramID programPacked,
774                                    GLuint index,
775                                    GLsizei bufSize,
776                                    GLsizei *length,
777                                    GLint *size,
778                                    GLenum *type,
779                                    GLchar *name,
780                                    angle::ParamCapture *paramCapture);
781 void CaptureGetActiveAttrib_size(const State &glState,
782                                  bool isCallValid,
783                                  ShaderProgramID programPacked,
784                                  GLuint index,
785                                  GLsizei bufSize,
786                                  GLsizei *length,
787                                  GLint *size,
788                                  GLenum *type,
789                                  GLchar *name,
790                                  angle::ParamCapture *paramCapture);
791 void CaptureGetActiveAttrib_type(const State &glState,
792                                  bool isCallValid,
793                                  ShaderProgramID programPacked,
794                                  GLuint index,
795                                  GLsizei bufSize,
796                                  GLsizei *length,
797                                  GLint *size,
798                                  GLenum *type,
799                                  GLchar *name,
800                                  angle::ParamCapture *paramCapture);
801 void CaptureGetActiveAttrib_name(const State &glState,
802                                  bool isCallValid,
803                                  ShaderProgramID programPacked,
804                                  GLuint index,
805                                  GLsizei bufSize,
806                                  GLsizei *length,
807                                  GLint *size,
808                                  GLenum *type,
809                                  GLchar *name,
810                                  angle::ParamCapture *paramCapture);
811 void CaptureGetActiveUniform_length(const State &glState,
812                                     bool isCallValid,
813                                     ShaderProgramID programPacked,
814                                     GLuint index,
815                                     GLsizei bufSize,
816                                     GLsizei *length,
817                                     GLint *size,
818                                     GLenum *type,
819                                     GLchar *name,
820                                     angle::ParamCapture *paramCapture);
821 void CaptureGetActiveUniform_size(const State &glState,
822                                   bool isCallValid,
823                                   ShaderProgramID programPacked,
824                                   GLuint index,
825                                   GLsizei bufSize,
826                                   GLsizei *length,
827                                   GLint *size,
828                                   GLenum *type,
829                                   GLchar *name,
830                                   angle::ParamCapture *paramCapture);
831 void CaptureGetActiveUniform_type(const State &glState,
832                                   bool isCallValid,
833                                   ShaderProgramID programPacked,
834                                   GLuint index,
835                                   GLsizei bufSize,
836                                   GLsizei *length,
837                                   GLint *size,
838                                   GLenum *type,
839                                   GLchar *name,
840                                   angle::ParamCapture *paramCapture);
841 void CaptureGetActiveUniform_name(const State &glState,
842                                   bool isCallValid,
843                                   ShaderProgramID programPacked,
844                                   GLuint index,
845                                   GLsizei bufSize,
846                                   GLsizei *length,
847                                   GLint *size,
848                                   GLenum *type,
849                                   GLchar *name,
850                                   angle::ParamCapture *paramCapture);
851 void CaptureGetAttachedShaders_count(const State &glState,
852                                      bool isCallValid,
853                                      ShaderProgramID programPacked,
854                                      GLsizei maxCount,
855                                      GLsizei *count,
856                                      ShaderProgramID *shadersPacked,
857                                      angle::ParamCapture *paramCapture);
858 void CaptureGetAttachedShaders_shadersPacked(const State &glState,
859                                              bool isCallValid,
860                                              ShaderProgramID programPacked,
861                                              GLsizei maxCount,
862                                              GLsizei *count,
863                                              ShaderProgramID *shadersPacked,
864                                              angle::ParamCapture *paramCapture);
865 void CaptureGetAttribLocation_name(const State &glState,
866                                    bool isCallValid,
867                                    ShaderProgramID programPacked,
868                                    const GLchar *name,
869                                    angle::ParamCapture *paramCapture);
870 void CaptureGetBooleanv_data(const State &glState,
871                              bool isCallValid,
872                              GLenum pname,
873                              GLboolean *data,
874                              angle::ParamCapture *paramCapture);
875 void CaptureGetBufferParameteriv_params(const State &glState,
876                                         bool isCallValid,
877                                         BufferBinding targetPacked,
878                                         GLenum pname,
879                                         GLint *params,
880                                         angle::ParamCapture *paramCapture);
881 void CaptureGetFloatv_data(const State &glState,
882                            bool isCallValid,
883                            GLenum pname,
884                            GLfloat *data,
885                            angle::ParamCapture *paramCapture);
886 void CaptureGetFramebufferAttachmentParameteriv_params(const State &glState,
887                                                        bool isCallValid,
888                                                        GLenum target,
889                                                        GLenum attachment,
890                                                        GLenum pname,
891                                                        GLint *params,
892                                                        angle::ParamCapture *paramCapture);
893 void CaptureGetIntegerv_data(const State &glState,
894                              bool isCallValid,
895                              GLenum pname,
896                              GLint *data,
897                              angle::ParamCapture *paramCapture);
898 void CaptureGetProgramInfoLog_length(const State &glState,
899                                      bool isCallValid,
900                                      ShaderProgramID programPacked,
901                                      GLsizei bufSize,
902                                      GLsizei *length,
903                                      GLchar *infoLog,
904                                      angle::ParamCapture *paramCapture);
905 void CaptureGetProgramInfoLog_infoLog(const State &glState,
906                                       bool isCallValid,
907                                       ShaderProgramID programPacked,
908                                       GLsizei bufSize,
909                                       GLsizei *length,
910                                       GLchar *infoLog,
911                                       angle::ParamCapture *paramCapture);
912 void CaptureGetProgramiv_params(const State &glState,
913                                 bool isCallValid,
914                                 ShaderProgramID programPacked,
915                                 GLenum pname,
916                                 GLint *params,
917                                 angle::ParamCapture *paramCapture);
918 void CaptureGetRenderbufferParameteriv_params(const State &glState,
919                                               bool isCallValid,
920                                               GLenum target,
921                                               GLenum pname,
922                                               GLint *params,
923                                               angle::ParamCapture *paramCapture);
924 void CaptureGetShaderInfoLog_length(const State &glState,
925                                     bool isCallValid,
926                                     ShaderProgramID shaderPacked,
927                                     GLsizei bufSize,
928                                     GLsizei *length,
929                                     GLchar *infoLog,
930                                     angle::ParamCapture *paramCapture);
931 void CaptureGetShaderInfoLog_infoLog(const State &glState,
932                                      bool isCallValid,
933                                      ShaderProgramID shaderPacked,
934                                      GLsizei bufSize,
935                                      GLsizei *length,
936                                      GLchar *infoLog,
937                                      angle::ParamCapture *paramCapture);
938 void CaptureGetShaderPrecisionFormat_range(const State &glState,
939                                            bool isCallValid,
940                                            GLenum shadertype,
941                                            GLenum precisiontype,
942                                            GLint *range,
943                                            GLint *precision,
944                                            angle::ParamCapture *paramCapture);
945 void CaptureGetShaderPrecisionFormat_precision(const State &glState,
946                                                bool isCallValid,
947                                                GLenum shadertype,
948                                                GLenum precisiontype,
949                                                GLint *range,
950                                                GLint *precision,
951                                                angle::ParamCapture *paramCapture);
952 void CaptureGetShaderSource_length(const State &glState,
953                                    bool isCallValid,
954                                    ShaderProgramID shaderPacked,
955                                    GLsizei bufSize,
956                                    GLsizei *length,
957                                    GLchar *source,
958                                    angle::ParamCapture *paramCapture);
959 void CaptureGetShaderSource_source(const State &glState,
960                                    bool isCallValid,
961                                    ShaderProgramID shaderPacked,
962                                    GLsizei bufSize,
963                                    GLsizei *length,
964                                    GLchar *source,
965                                    angle::ParamCapture *paramCapture);
966 void CaptureGetShaderiv_params(const State &glState,
967                                bool isCallValid,
968                                ShaderProgramID shaderPacked,
969                                GLenum pname,
970                                GLint *params,
971                                angle::ParamCapture *paramCapture);
972 void CaptureGetTexParameterfv_params(const State &glState,
973                                      bool isCallValid,
974                                      TextureType targetPacked,
975                                      GLenum pname,
976                                      GLfloat *params,
977                                      angle::ParamCapture *paramCapture);
978 void CaptureGetTexParameteriv_params(const State &glState,
979                                      bool isCallValid,
980                                      TextureType targetPacked,
981                                      GLenum pname,
982                                      GLint *params,
983                                      angle::ParamCapture *paramCapture);
984 void CaptureGetUniformLocation_name(const State &glState,
985                                     bool isCallValid,
986                                     ShaderProgramID programPacked,
987                                     const GLchar *name,
988                                     angle::ParamCapture *paramCapture);
989 void CaptureGetUniformfv_params(const State &glState,
990                                 bool isCallValid,
991                                 ShaderProgramID programPacked,
992                                 UniformLocation locationPacked,
993                                 GLfloat *params,
994                                 angle::ParamCapture *paramCapture);
995 void CaptureGetUniformiv_params(const State &glState,
996                                 bool isCallValid,
997                                 ShaderProgramID programPacked,
998                                 UniformLocation locationPacked,
999                                 GLint *params,
1000                                 angle::ParamCapture *paramCapture);
1001 void CaptureGetVertexAttribPointerv_pointer(const State &glState,
1002                                             bool isCallValid,
1003                                             GLuint index,
1004                                             GLenum pname,
1005                                             void **pointer,
1006                                             angle::ParamCapture *paramCapture);
1007 void CaptureGetVertexAttribfv_params(const State &glState,
1008                                      bool isCallValid,
1009                                      GLuint index,
1010                                      GLenum pname,
1011                                      GLfloat *params,
1012                                      angle::ParamCapture *paramCapture);
1013 void CaptureGetVertexAttribiv_params(const State &glState,
1014                                      bool isCallValid,
1015                                      GLuint index,
1016                                      GLenum pname,
1017                                      GLint *params,
1018                                      angle::ParamCapture *paramCapture);
1019 void CaptureReadPixels_pixels(const State &glState,
1020                               bool isCallValid,
1021                               GLint x,
1022                               GLint y,
1023                               GLsizei width,
1024                               GLsizei height,
1025                               GLenum format,
1026                               GLenum type,
1027                               void *pixels,
1028                               angle::ParamCapture *paramCapture);
1029 void CaptureShaderBinary_shadersPacked(const State &glState,
1030                                        bool isCallValid,
1031                                        GLsizei count,
1032                                        const ShaderProgramID *shadersPacked,
1033                                        GLenum binaryformat,
1034                                        const void *binary,
1035                                        GLsizei length,
1036                                        angle::ParamCapture *paramCapture);
1037 void CaptureShaderBinary_binary(const State &glState,
1038                                 bool isCallValid,
1039                                 GLsizei count,
1040                                 const ShaderProgramID *shadersPacked,
1041                                 GLenum binaryformat,
1042                                 const void *binary,
1043                                 GLsizei length,
1044                                 angle::ParamCapture *paramCapture);
1045 void CaptureShaderSource_string(const State &glState,
1046                                 bool isCallValid,
1047                                 ShaderProgramID shaderPacked,
1048                                 GLsizei count,
1049                                 const GLchar *const *string,
1050                                 const GLint *length,
1051                                 angle::ParamCapture *paramCapture);
1052 void CaptureShaderSource_length(const State &glState,
1053                                 bool isCallValid,
1054                                 ShaderProgramID shaderPacked,
1055                                 GLsizei count,
1056                                 const GLchar *const *string,
1057                                 const GLint *length,
1058                                 angle::ParamCapture *paramCapture);
1059 void CaptureTexImage2D_pixels(const State &glState,
1060                               bool isCallValid,
1061                               TextureTarget targetPacked,
1062                               GLint level,
1063                               GLint internalformat,
1064                               GLsizei width,
1065                               GLsizei height,
1066                               GLint border,
1067                               GLenum format,
1068                               GLenum type,
1069                               const void *pixels,
1070                               angle::ParamCapture *paramCapture);
1071 void CaptureTexParameterfv_params(const State &glState,
1072                                   bool isCallValid,
1073                                   TextureType targetPacked,
1074                                   GLenum pname,
1075                                   const GLfloat *params,
1076                                   angle::ParamCapture *paramCapture);
1077 void CaptureTexParameteriv_params(const State &glState,
1078                                   bool isCallValid,
1079                                   TextureType targetPacked,
1080                                   GLenum pname,
1081                                   const GLint *params,
1082                                   angle::ParamCapture *paramCapture);
1083 void CaptureTexSubImage2D_pixels(const State &glState,
1084                                  bool isCallValid,
1085                                  TextureTarget targetPacked,
1086                                  GLint level,
1087                                  GLint xoffset,
1088                                  GLint yoffset,
1089                                  GLsizei width,
1090                                  GLsizei height,
1091                                  GLenum format,
1092                                  GLenum type,
1093                                  const void *pixels,
1094                                  angle::ParamCapture *paramCapture);
1095 void CaptureUniform1fv_value(const State &glState,
1096                              bool isCallValid,
1097                              UniformLocation locationPacked,
1098                              GLsizei count,
1099                              const GLfloat *value,
1100                              angle::ParamCapture *paramCapture);
1101 void CaptureUniform1iv_value(const State &glState,
1102                              bool isCallValid,
1103                              UniformLocation locationPacked,
1104                              GLsizei count,
1105                              const GLint *value,
1106                              angle::ParamCapture *paramCapture);
1107 void CaptureUniform2fv_value(const State &glState,
1108                              bool isCallValid,
1109                              UniformLocation locationPacked,
1110                              GLsizei count,
1111                              const GLfloat *value,
1112                              angle::ParamCapture *paramCapture);
1113 void CaptureUniform2iv_value(const State &glState,
1114                              bool isCallValid,
1115                              UniformLocation locationPacked,
1116                              GLsizei count,
1117                              const GLint *value,
1118                              angle::ParamCapture *paramCapture);
1119 void CaptureUniform3fv_value(const State &glState,
1120                              bool isCallValid,
1121                              UniformLocation locationPacked,
1122                              GLsizei count,
1123                              const GLfloat *value,
1124                              angle::ParamCapture *paramCapture);
1125 void CaptureUniform3iv_value(const State &glState,
1126                              bool isCallValid,
1127                              UniformLocation locationPacked,
1128                              GLsizei count,
1129                              const GLint *value,
1130                              angle::ParamCapture *paramCapture);
1131 void CaptureUniform4fv_value(const State &glState,
1132                              bool isCallValid,
1133                              UniformLocation locationPacked,
1134                              GLsizei count,
1135                              const GLfloat *value,
1136                              angle::ParamCapture *paramCapture);
1137 void CaptureUniform4iv_value(const State &glState,
1138                              bool isCallValid,
1139                              UniformLocation locationPacked,
1140                              GLsizei count,
1141                              const GLint *value,
1142                              angle::ParamCapture *paramCapture);
1143 void CaptureUniformMatrix2fv_value(const State &glState,
1144                                    bool isCallValid,
1145                                    UniformLocation locationPacked,
1146                                    GLsizei count,
1147                                    GLboolean transpose,
1148                                    const GLfloat *value,
1149                                    angle::ParamCapture *paramCapture);
1150 void CaptureUniformMatrix3fv_value(const State &glState,
1151                                    bool isCallValid,
1152                                    UniformLocation locationPacked,
1153                                    GLsizei count,
1154                                    GLboolean transpose,
1155                                    const GLfloat *value,
1156                                    angle::ParamCapture *paramCapture);
1157 void CaptureUniformMatrix4fv_value(const State &glState,
1158                                    bool isCallValid,
1159                                    UniformLocation locationPacked,
1160                                    GLsizei count,
1161                                    GLboolean transpose,
1162                                    const GLfloat *value,
1163                                    angle::ParamCapture *paramCapture);
1164 void CaptureVertexAttrib1fv_v(const State &glState,
1165                               bool isCallValid,
1166                               GLuint index,
1167                               const GLfloat *v,
1168                               angle::ParamCapture *paramCapture);
1169 void CaptureVertexAttrib2fv_v(const State &glState,
1170                               bool isCallValid,
1171                               GLuint index,
1172                               const GLfloat *v,
1173                               angle::ParamCapture *paramCapture);
1174 void CaptureVertexAttrib3fv_v(const State &glState,
1175                               bool isCallValid,
1176                               GLuint index,
1177                               const GLfloat *v,
1178                               angle::ParamCapture *paramCapture);
1179 void CaptureVertexAttrib4fv_v(const State &glState,
1180                               bool isCallValid,
1181                               GLuint index,
1182                               const GLfloat *v,
1183                               angle::ParamCapture *paramCapture);
1184 void CaptureVertexAttribPointer_pointer(const State &glState,
1185                                         bool isCallValid,
1186                                         GLuint index,
1187                                         GLint size,
1188                                         VertexAttribType typePacked,
1189                                         GLboolean normalized,
1190                                         GLsizei stride,
1191                                         const void *pointer,
1192                                         angle::ParamCapture *paramCapture);
1193 }  // namespace gl
1194 
1195 #endif  // LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
1196