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_3_1_autogen.h:
9 //   Capture functions for the OpenGL ES 3.1 entry points.
10 
11 #ifndef LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
12 #define LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
13 
14 #include "common/PackedEnums.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 
17 namespace gl
18 {
19 
20 // Method Captures
21 
22 angle::CallCapture CaptureActiveShaderProgram(const State &glState,
23                                               bool isCallValid,
24                                               ProgramPipelineID pipelinePacked,
25                                               ShaderProgramID programPacked);
26 angle::CallCapture CaptureBindImageTexture(const State &glState,
27                                            bool isCallValid,
28                                            GLuint unit,
29                                            TextureID texturePacked,
30                                            GLint level,
31                                            GLboolean layered,
32                                            GLint layer,
33                                            GLenum access,
34                                            GLenum format);
35 angle::CallCapture CaptureBindProgramPipeline(const State &glState,
36                                               bool isCallValid,
37                                               ProgramPipelineID pipelinePacked);
38 angle::CallCapture CaptureBindVertexBuffer(const State &glState,
39                                            bool isCallValid,
40                                            GLuint bindingindex,
41                                            BufferID bufferPacked,
42                                            GLintptr offset,
43                                            GLsizei stride);
44 angle::CallCapture CaptureCreateShaderProgramv(const State &glState,
45                                                bool isCallValid,
46                                                ShaderType typePacked,
47                                                GLsizei count,
48                                                const GLchar *const *strings,
49                                                GLuint returnValue);
50 angle::CallCapture CaptureDeleteProgramPipelines(const State &glState,
51                                                  bool isCallValid,
52                                                  GLsizei n,
53                                                  const ProgramPipelineID *pipelinesPacked);
54 angle::CallCapture CaptureDispatchCompute(const State &glState,
55                                           bool isCallValid,
56                                           GLuint num_groups_x,
57                                           GLuint num_groups_y,
58                                           GLuint num_groups_z);
59 angle::CallCapture CaptureDispatchComputeIndirect(const State &glState,
60                                                   bool isCallValid,
61                                                   GLintptr indirect);
62 angle::CallCapture CaptureDrawArraysIndirect(const State &glState,
63                                              bool isCallValid,
64                                              PrimitiveMode modePacked,
65                                              const void *indirect);
66 angle::CallCapture CaptureDrawElementsIndirect(const State &glState,
67                                                bool isCallValid,
68                                                PrimitiveMode modePacked,
69                                                DrawElementsType typePacked,
70                                                const void *indirect);
71 angle::CallCapture CaptureFramebufferParameteri(const State &glState,
72                                                 bool isCallValid,
73                                                 GLenum target,
74                                                 GLenum pname,
75                                                 GLint param);
76 angle::CallCapture CaptureGenProgramPipelines(const State &glState,
77                                               bool isCallValid,
78                                               GLsizei n,
79                                               ProgramPipelineID *pipelinesPacked);
80 angle::CallCapture CaptureGetBooleani_v(const State &glState,
81                                         bool isCallValid,
82                                         GLenum target,
83                                         GLuint index,
84                                         GLboolean *data);
85 angle::CallCapture CaptureGetFramebufferParameteriv(const State &glState,
86                                                     bool isCallValid,
87                                                     GLenum target,
88                                                     GLenum pname,
89                                                     GLint *params);
90 angle::CallCapture CaptureGetMultisamplefv(const State &glState,
91                                            bool isCallValid,
92                                            GLenum pname,
93                                            GLuint index,
94                                            GLfloat *val);
95 angle::CallCapture CaptureGetProgramInterfaceiv(const State &glState,
96                                                 bool isCallValid,
97                                                 ShaderProgramID programPacked,
98                                                 GLenum programInterface,
99                                                 GLenum pname,
100                                                 GLint *params);
101 angle::CallCapture CaptureGetProgramPipelineInfoLog(const State &glState,
102                                                     bool isCallValid,
103                                                     ProgramPipelineID pipelinePacked,
104                                                     GLsizei bufSize,
105                                                     GLsizei *length,
106                                                     GLchar *infoLog);
107 angle::CallCapture CaptureGetProgramPipelineiv(const State &glState,
108                                                bool isCallValid,
109                                                ProgramPipelineID pipelinePacked,
110                                                GLenum pname,
111                                                GLint *params);
112 angle::CallCapture CaptureGetProgramResourceIndex(const State &glState,
113                                                   bool isCallValid,
114                                                   ShaderProgramID programPacked,
115                                                   GLenum programInterface,
116                                                   const GLchar *name,
117                                                   GLuint returnValue);
118 angle::CallCapture CaptureGetProgramResourceLocation(const State &glState,
119                                                      bool isCallValid,
120                                                      ShaderProgramID programPacked,
121                                                      GLenum programInterface,
122                                                      const GLchar *name,
123                                                      GLint returnValue);
124 angle::CallCapture CaptureGetProgramResourceName(const State &glState,
125                                                  bool isCallValid,
126                                                  ShaderProgramID programPacked,
127                                                  GLenum programInterface,
128                                                  GLuint index,
129                                                  GLsizei bufSize,
130                                                  GLsizei *length,
131                                                  GLchar *name);
132 angle::CallCapture CaptureGetProgramResourceiv(const State &glState,
133                                                bool isCallValid,
134                                                ShaderProgramID programPacked,
135                                                GLenum programInterface,
136                                                GLuint index,
137                                                GLsizei propCount,
138                                                const GLenum *props,
139                                                GLsizei bufSize,
140                                                GLsizei *length,
141                                                GLint *params);
142 angle::CallCapture CaptureGetTexLevelParameterfv(const State &glState,
143                                                  bool isCallValid,
144                                                  TextureTarget targetPacked,
145                                                  GLint level,
146                                                  GLenum pname,
147                                                  GLfloat *params);
148 angle::CallCapture CaptureGetTexLevelParameteriv(const State &glState,
149                                                  bool isCallValid,
150                                                  TextureTarget targetPacked,
151                                                  GLint level,
152                                                  GLenum pname,
153                                                  GLint *params);
154 angle::CallCapture CaptureIsProgramPipeline(const State &glState,
155                                             bool isCallValid,
156                                             ProgramPipelineID pipelinePacked,
157                                             GLboolean returnValue);
158 angle::CallCapture CaptureMemoryBarrier(const State &glState,
159                                         bool isCallValid,
160                                         GLbitfield barriers);
161 angle::CallCapture CaptureMemoryBarrierByRegion(const State &glState,
162                                                 bool isCallValid,
163                                                 GLbitfield barriers);
164 angle::CallCapture CaptureProgramUniform1f(const State &glState,
165                                            bool isCallValid,
166                                            ShaderProgramID programPacked,
167                                            UniformLocation locationPacked,
168                                            GLfloat v0);
169 angle::CallCapture CaptureProgramUniform1fv(const State &glState,
170                                             bool isCallValid,
171                                             ShaderProgramID programPacked,
172                                             UniformLocation locationPacked,
173                                             GLsizei count,
174                                             const GLfloat *value);
175 angle::CallCapture CaptureProgramUniform1i(const State &glState,
176                                            bool isCallValid,
177                                            ShaderProgramID programPacked,
178                                            UniformLocation locationPacked,
179                                            GLint v0);
180 angle::CallCapture CaptureProgramUniform1iv(const State &glState,
181                                             bool isCallValid,
182                                             ShaderProgramID programPacked,
183                                             UniformLocation locationPacked,
184                                             GLsizei count,
185                                             const GLint *value);
186 angle::CallCapture CaptureProgramUniform1ui(const State &glState,
187                                             bool isCallValid,
188                                             ShaderProgramID programPacked,
189                                             UniformLocation locationPacked,
190                                             GLuint v0);
191 angle::CallCapture CaptureProgramUniform1uiv(const State &glState,
192                                              bool isCallValid,
193                                              ShaderProgramID programPacked,
194                                              UniformLocation locationPacked,
195                                              GLsizei count,
196                                              const GLuint *value);
197 angle::CallCapture CaptureProgramUniform2f(const State &glState,
198                                            bool isCallValid,
199                                            ShaderProgramID programPacked,
200                                            UniformLocation locationPacked,
201                                            GLfloat v0,
202                                            GLfloat v1);
203 angle::CallCapture CaptureProgramUniform2fv(const State &glState,
204                                             bool isCallValid,
205                                             ShaderProgramID programPacked,
206                                             UniformLocation locationPacked,
207                                             GLsizei count,
208                                             const GLfloat *value);
209 angle::CallCapture CaptureProgramUniform2i(const State &glState,
210                                            bool isCallValid,
211                                            ShaderProgramID programPacked,
212                                            UniformLocation locationPacked,
213                                            GLint v0,
214                                            GLint v1);
215 angle::CallCapture CaptureProgramUniform2iv(const State &glState,
216                                             bool isCallValid,
217                                             ShaderProgramID programPacked,
218                                             UniformLocation locationPacked,
219                                             GLsizei count,
220                                             const GLint *value);
221 angle::CallCapture CaptureProgramUniform2ui(const State &glState,
222                                             bool isCallValid,
223                                             ShaderProgramID programPacked,
224                                             UniformLocation locationPacked,
225                                             GLuint v0,
226                                             GLuint v1);
227 angle::CallCapture CaptureProgramUniform2uiv(const State &glState,
228                                              bool isCallValid,
229                                              ShaderProgramID programPacked,
230                                              UniformLocation locationPacked,
231                                              GLsizei count,
232                                              const GLuint *value);
233 angle::CallCapture CaptureProgramUniform3f(const State &glState,
234                                            bool isCallValid,
235                                            ShaderProgramID programPacked,
236                                            UniformLocation locationPacked,
237                                            GLfloat v0,
238                                            GLfloat v1,
239                                            GLfloat v2);
240 angle::CallCapture CaptureProgramUniform3fv(const State &glState,
241                                             bool isCallValid,
242                                             ShaderProgramID programPacked,
243                                             UniformLocation locationPacked,
244                                             GLsizei count,
245                                             const GLfloat *value);
246 angle::CallCapture CaptureProgramUniform3i(const State &glState,
247                                            bool isCallValid,
248                                            ShaderProgramID programPacked,
249                                            UniformLocation locationPacked,
250                                            GLint v0,
251                                            GLint v1,
252                                            GLint v2);
253 angle::CallCapture CaptureProgramUniform3iv(const State &glState,
254                                             bool isCallValid,
255                                             ShaderProgramID programPacked,
256                                             UniformLocation locationPacked,
257                                             GLsizei count,
258                                             const GLint *value);
259 angle::CallCapture CaptureProgramUniform3ui(const State &glState,
260                                             bool isCallValid,
261                                             ShaderProgramID programPacked,
262                                             UniformLocation locationPacked,
263                                             GLuint v0,
264                                             GLuint v1,
265                                             GLuint v2);
266 angle::CallCapture CaptureProgramUniform3uiv(const State &glState,
267                                              bool isCallValid,
268                                              ShaderProgramID programPacked,
269                                              UniformLocation locationPacked,
270                                              GLsizei count,
271                                              const GLuint *value);
272 angle::CallCapture CaptureProgramUniform4f(const State &glState,
273                                            bool isCallValid,
274                                            ShaderProgramID programPacked,
275                                            UniformLocation locationPacked,
276                                            GLfloat v0,
277                                            GLfloat v1,
278                                            GLfloat v2,
279                                            GLfloat v3);
280 angle::CallCapture CaptureProgramUniform4fv(const State &glState,
281                                             bool isCallValid,
282                                             ShaderProgramID programPacked,
283                                             UniformLocation locationPacked,
284                                             GLsizei count,
285                                             const GLfloat *value);
286 angle::CallCapture CaptureProgramUniform4i(const State &glState,
287                                            bool isCallValid,
288                                            ShaderProgramID programPacked,
289                                            UniformLocation locationPacked,
290                                            GLint v0,
291                                            GLint v1,
292                                            GLint v2,
293                                            GLint v3);
294 angle::CallCapture CaptureProgramUniform4iv(const State &glState,
295                                             bool isCallValid,
296                                             ShaderProgramID programPacked,
297                                             UniformLocation locationPacked,
298                                             GLsizei count,
299                                             const GLint *value);
300 angle::CallCapture CaptureProgramUniform4ui(const State &glState,
301                                             bool isCallValid,
302                                             ShaderProgramID programPacked,
303                                             UniformLocation locationPacked,
304                                             GLuint v0,
305                                             GLuint v1,
306                                             GLuint v2,
307                                             GLuint v3);
308 angle::CallCapture CaptureProgramUniform4uiv(const State &glState,
309                                              bool isCallValid,
310                                              ShaderProgramID programPacked,
311                                              UniformLocation locationPacked,
312                                              GLsizei count,
313                                              const GLuint *value);
314 angle::CallCapture CaptureProgramUniformMatrix2fv(const State &glState,
315                                                   bool isCallValid,
316                                                   ShaderProgramID programPacked,
317                                                   UniformLocation locationPacked,
318                                                   GLsizei count,
319                                                   GLboolean transpose,
320                                                   const GLfloat *value);
321 angle::CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState,
322                                                     bool isCallValid,
323                                                     ShaderProgramID programPacked,
324                                                     UniformLocation locationPacked,
325                                                     GLsizei count,
326                                                     GLboolean transpose,
327                                                     const GLfloat *value);
328 angle::CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState,
329                                                     bool isCallValid,
330                                                     ShaderProgramID programPacked,
331                                                     UniformLocation locationPacked,
332                                                     GLsizei count,
333                                                     GLboolean transpose,
334                                                     const GLfloat *value);
335 angle::CallCapture CaptureProgramUniformMatrix3fv(const State &glState,
336                                                   bool isCallValid,
337                                                   ShaderProgramID programPacked,
338                                                   UniformLocation locationPacked,
339                                                   GLsizei count,
340                                                   GLboolean transpose,
341                                                   const GLfloat *value);
342 angle::CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState,
343                                                     bool isCallValid,
344                                                     ShaderProgramID programPacked,
345                                                     UniformLocation locationPacked,
346                                                     GLsizei count,
347                                                     GLboolean transpose,
348                                                     const GLfloat *value);
349 angle::CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState,
350                                                     bool isCallValid,
351                                                     ShaderProgramID programPacked,
352                                                     UniformLocation locationPacked,
353                                                     GLsizei count,
354                                                     GLboolean transpose,
355                                                     const GLfloat *value);
356 angle::CallCapture CaptureProgramUniformMatrix4fv(const State &glState,
357                                                   bool isCallValid,
358                                                   ShaderProgramID programPacked,
359                                                   UniformLocation locationPacked,
360                                                   GLsizei count,
361                                                   GLboolean transpose,
362                                                   const GLfloat *value);
363 angle::CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState,
364                                                     bool isCallValid,
365                                                     ShaderProgramID programPacked,
366                                                     UniformLocation locationPacked,
367                                                     GLsizei count,
368                                                     GLboolean transpose,
369                                                     const GLfloat *value);
370 angle::CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState,
371                                                     bool isCallValid,
372                                                     ShaderProgramID programPacked,
373                                                     UniformLocation locationPacked,
374                                                     GLsizei count,
375                                                     GLboolean transpose,
376                                                     const GLfloat *value);
377 angle::CallCapture CaptureSampleMaski(const State &glState,
378                                       bool isCallValid,
379                                       GLuint maskNumber,
380                                       GLbitfield mask);
381 angle::CallCapture CaptureTexStorage2DMultisample(const State &glState,
382                                                   bool isCallValid,
383                                                   TextureType targetPacked,
384                                                   GLsizei samples,
385                                                   GLenum internalformat,
386                                                   GLsizei width,
387                                                   GLsizei height,
388                                                   GLboolean fixedsamplelocations);
389 angle::CallCapture CaptureUseProgramStages(const State &glState,
390                                            bool isCallValid,
391                                            ProgramPipelineID pipelinePacked,
392                                            GLbitfield stages,
393                                            ShaderProgramID programPacked);
394 angle::CallCapture CaptureValidateProgramPipeline(const State &glState,
395                                                   bool isCallValid,
396                                                   ProgramPipelineID pipelinePacked);
397 angle::CallCapture CaptureVertexAttribBinding(const State &glState,
398                                               bool isCallValid,
399                                               GLuint attribindex,
400                                               GLuint bindingindex);
401 angle::CallCapture CaptureVertexAttribFormat(const State &glState,
402                                              bool isCallValid,
403                                              GLuint attribindex,
404                                              GLint size,
405                                              VertexAttribType typePacked,
406                                              GLboolean normalized,
407                                              GLuint relativeoffset);
408 angle::CallCapture CaptureVertexAttribIFormat(const State &glState,
409                                               bool isCallValid,
410                                               GLuint attribindex,
411                                               GLint size,
412                                               VertexAttribType typePacked,
413                                               GLuint relativeoffset);
414 angle::CallCapture CaptureVertexBindingDivisor(const State &glState,
415                                                bool isCallValid,
416                                                GLuint bindingindex,
417                                                GLuint divisor);
418 
419 // Parameter Captures
420 
421 void CaptureCreateShaderProgramv_strings(const State &glState,
422                                          bool isCallValid,
423                                          ShaderType typePacked,
424                                          GLsizei count,
425                                          const GLchar *const *strings,
426                                          angle::ParamCapture *paramCapture);
427 void CaptureDeleteProgramPipelines_pipelinesPacked(const State &glState,
428                                                    bool isCallValid,
429                                                    GLsizei n,
430                                                    const ProgramPipelineID *pipelinesPacked,
431                                                    angle::ParamCapture *paramCapture);
432 void CaptureDrawArraysIndirect_indirect(const State &glState,
433                                         bool isCallValid,
434                                         PrimitiveMode modePacked,
435                                         const void *indirect,
436                                         angle::ParamCapture *paramCapture);
437 void CaptureDrawElementsIndirect_indirect(const State &glState,
438                                           bool isCallValid,
439                                           PrimitiveMode modePacked,
440                                           DrawElementsType typePacked,
441                                           const void *indirect,
442                                           angle::ParamCapture *paramCapture);
443 void CaptureGenProgramPipelines_pipelinesPacked(const State &glState,
444                                                 bool isCallValid,
445                                                 GLsizei n,
446                                                 ProgramPipelineID *pipelinesPacked,
447                                                 angle::ParamCapture *paramCapture);
448 void CaptureGetBooleani_v_data(const State &glState,
449                                bool isCallValid,
450                                GLenum target,
451                                GLuint index,
452                                GLboolean *data,
453                                angle::ParamCapture *paramCapture);
454 void CaptureGetFramebufferParameteriv_params(const State &glState,
455                                              bool isCallValid,
456                                              GLenum target,
457                                              GLenum pname,
458                                              GLint *params,
459                                              angle::ParamCapture *paramCapture);
460 void CaptureGetMultisamplefv_val(const State &glState,
461                                  bool isCallValid,
462                                  GLenum pname,
463                                  GLuint index,
464                                  GLfloat *val,
465                                  angle::ParamCapture *paramCapture);
466 void CaptureGetProgramInterfaceiv_params(const State &glState,
467                                          bool isCallValid,
468                                          ShaderProgramID programPacked,
469                                          GLenum programInterface,
470                                          GLenum pname,
471                                          GLint *params,
472                                          angle::ParamCapture *paramCapture);
473 void CaptureGetProgramPipelineInfoLog_length(const State &glState,
474                                              bool isCallValid,
475                                              ProgramPipelineID pipelinePacked,
476                                              GLsizei bufSize,
477                                              GLsizei *length,
478                                              GLchar *infoLog,
479                                              angle::ParamCapture *paramCapture);
480 void CaptureGetProgramPipelineInfoLog_infoLog(const State &glState,
481                                               bool isCallValid,
482                                               ProgramPipelineID pipelinePacked,
483                                               GLsizei bufSize,
484                                               GLsizei *length,
485                                               GLchar *infoLog,
486                                               angle::ParamCapture *paramCapture);
487 void CaptureGetProgramPipelineiv_params(const State &glState,
488                                         bool isCallValid,
489                                         ProgramPipelineID pipelinePacked,
490                                         GLenum pname,
491                                         GLint *params,
492                                         angle::ParamCapture *paramCapture);
493 void CaptureGetProgramResourceIndex_name(const State &glState,
494                                          bool isCallValid,
495                                          ShaderProgramID programPacked,
496                                          GLenum programInterface,
497                                          const GLchar *name,
498                                          angle::ParamCapture *paramCapture);
499 void CaptureGetProgramResourceLocation_name(const State &glState,
500                                             bool isCallValid,
501                                             ShaderProgramID programPacked,
502                                             GLenum programInterface,
503                                             const GLchar *name,
504                                             angle::ParamCapture *paramCapture);
505 void CaptureGetProgramResourceName_length(const State &glState,
506                                           bool isCallValid,
507                                           ShaderProgramID programPacked,
508                                           GLenum programInterface,
509                                           GLuint index,
510                                           GLsizei bufSize,
511                                           GLsizei *length,
512                                           GLchar *name,
513                                           angle::ParamCapture *paramCapture);
514 void CaptureGetProgramResourceName_name(const State &glState,
515                                         bool isCallValid,
516                                         ShaderProgramID programPacked,
517                                         GLenum programInterface,
518                                         GLuint index,
519                                         GLsizei bufSize,
520                                         GLsizei *length,
521                                         GLchar *name,
522                                         angle::ParamCapture *paramCapture);
523 void CaptureGetProgramResourceiv_props(const State &glState,
524                                        bool isCallValid,
525                                        ShaderProgramID programPacked,
526                                        GLenum programInterface,
527                                        GLuint index,
528                                        GLsizei propCount,
529                                        const GLenum *props,
530                                        GLsizei bufSize,
531                                        GLsizei *length,
532                                        GLint *params,
533                                        angle::ParamCapture *paramCapture);
534 void CaptureGetProgramResourceiv_length(const State &glState,
535                                         bool isCallValid,
536                                         ShaderProgramID programPacked,
537                                         GLenum programInterface,
538                                         GLuint index,
539                                         GLsizei propCount,
540                                         const GLenum *props,
541                                         GLsizei bufSize,
542                                         GLsizei *length,
543                                         GLint *params,
544                                         angle::ParamCapture *paramCapture);
545 void CaptureGetProgramResourceiv_params(const State &glState,
546                                         bool isCallValid,
547                                         ShaderProgramID programPacked,
548                                         GLenum programInterface,
549                                         GLuint index,
550                                         GLsizei propCount,
551                                         const GLenum *props,
552                                         GLsizei bufSize,
553                                         GLsizei *length,
554                                         GLint *params,
555                                         angle::ParamCapture *paramCapture);
556 void CaptureGetTexLevelParameterfv_params(const State &glState,
557                                           bool isCallValid,
558                                           TextureTarget targetPacked,
559                                           GLint level,
560                                           GLenum pname,
561                                           GLfloat *params,
562                                           angle::ParamCapture *paramCapture);
563 void CaptureGetTexLevelParameteriv_params(const State &glState,
564                                           bool isCallValid,
565                                           TextureTarget targetPacked,
566                                           GLint level,
567                                           GLenum pname,
568                                           GLint *params,
569                                           angle::ParamCapture *paramCapture);
570 void CaptureProgramUniform1fv_value(const State &glState,
571                                     bool isCallValid,
572                                     ShaderProgramID programPacked,
573                                     UniformLocation locationPacked,
574                                     GLsizei count,
575                                     const GLfloat *value,
576                                     angle::ParamCapture *paramCapture);
577 void CaptureProgramUniform1iv_value(const State &glState,
578                                     bool isCallValid,
579                                     ShaderProgramID programPacked,
580                                     UniformLocation locationPacked,
581                                     GLsizei count,
582                                     const GLint *value,
583                                     angle::ParamCapture *paramCapture);
584 void CaptureProgramUniform1uiv_value(const State &glState,
585                                      bool isCallValid,
586                                      ShaderProgramID programPacked,
587                                      UniformLocation locationPacked,
588                                      GLsizei count,
589                                      const GLuint *value,
590                                      angle::ParamCapture *paramCapture);
591 void CaptureProgramUniform2fv_value(const State &glState,
592                                     bool isCallValid,
593                                     ShaderProgramID programPacked,
594                                     UniformLocation locationPacked,
595                                     GLsizei count,
596                                     const GLfloat *value,
597                                     angle::ParamCapture *paramCapture);
598 void CaptureProgramUniform2iv_value(const State &glState,
599                                     bool isCallValid,
600                                     ShaderProgramID programPacked,
601                                     UniformLocation locationPacked,
602                                     GLsizei count,
603                                     const GLint *value,
604                                     angle::ParamCapture *paramCapture);
605 void CaptureProgramUniform2uiv_value(const State &glState,
606                                      bool isCallValid,
607                                      ShaderProgramID programPacked,
608                                      UniformLocation locationPacked,
609                                      GLsizei count,
610                                      const GLuint *value,
611                                      angle::ParamCapture *paramCapture);
612 void CaptureProgramUniform3fv_value(const State &glState,
613                                     bool isCallValid,
614                                     ShaderProgramID programPacked,
615                                     UniformLocation locationPacked,
616                                     GLsizei count,
617                                     const GLfloat *value,
618                                     angle::ParamCapture *paramCapture);
619 void CaptureProgramUniform3iv_value(const State &glState,
620                                     bool isCallValid,
621                                     ShaderProgramID programPacked,
622                                     UniformLocation locationPacked,
623                                     GLsizei count,
624                                     const GLint *value,
625                                     angle::ParamCapture *paramCapture);
626 void CaptureProgramUniform3uiv_value(const State &glState,
627                                      bool isCallValid,
628                                      ShaderProgramID programPacked,
629                                      UniformLocation locationPacked,
630                                      GLsizei count,
631                                      const GLuint *value,
632                                      angle::ParamCapture *paramCapture);
633 void CaptureProgramUniform4fv_value(const State &glState,
634                                     bool isCallValid,
635                                     ShaderProgramID programPacked,
636                                     UniformLocation locationPacked,
637                                     GLsizei count,
638                                     const GLfloat *value,
639                                     angle::ParamCapture *paramCapture);
640 void CaptureProgramUniform4iv_value(const State &glState,
641                                     bool isCallValid,
642                                     ShaderProgramID programPacked,
643                                     UniformLocation locationPacked,
644                                     GLsizei count,
645                                     const GLint *value,
646                                     angle::ParamCapture *paramCapture);
647 void CaptureProgramUniform4uiv_value(const State &glState,
648                                      bool isCallValid,
649                                      ShaderProgramID programPacked,
650                                      UniformLocation locationPacked,
651                                      GLsizei count,
652                                      const GLuint *value,
653                                      angle::ParamCapture *paramCapture);
654 void CaptureProgramUniformMatrix2fv_value(const State &glState,
655                                           bool isCallValid,
656                                           ShaderProgramID programPacked,
657                                           UniformLocation locationPacked,
658                                           GLsizei count,
659                                           GLboolean transpose,
660                                           const GLfloat *value,
661                                           angle::ParamCapture *paramCapture);
662 void CaptureProgramUniformMatrix2x3fv_value(const State &glState,
663                                             bool isCallValid,
664                                             ShaderProgramID programPacked,
665                                             UniformLocation locationPacked,
666                                             GLsizei count,
667                                             GLboolean transpose,
668                                             const GLfloat *value,
669                                             angle::ParamCapture *paramCapture);
670 void CaptureProgramUniformMatrix2x4fv_value(const State &glState,
671                                             bool isCallValid,
672                                             ShaderProgramID programPacked,
673                                             UniformLocation locationPacked,
674                                             GLsizei count,
675                                             GLboolean transpose,
676                                             const GLfloat *value,
677                                             angle::ParamCapture *paramCapture);
678 void CaptureProgramUniformMatrix3fv_value(const State &glState,
679                                           bool isCallValid,
680                                           ShaderProgramID programPacked,
681                                           UniformLocation locationPacked,
682                                           GLsizei count,
683                                           GLboolean transpose,
684                                           const GLfloat *value,
685                                           angle::ParamCapture *paramCapture);
686 void CaptureProgramUniformMatrix3x2fv_value(const State &glState,
687                                             bool isCallValid,
688                                             ShaderProgramID programPacked,
689                                             UniformLocation locationPacked,
690                                             GLsizei count,
691                                             GLboolean transpose,
692                                             const GLfloat *value,
693                                             angle::ParamCapture *paramCapture);
694 void CaptureProgramUniformMatrix3x4fv_value(const State &glState,
695                                             bool isCallValid,
696                                             ShaderProgramID programPacked,
697                                             UniformLocation locationPacked,
698                                             GLsizei count,
699                                             GLboolean transpose,
700                                             const GLfloat *value,
701                                             angle::ParamCapture *paramCapture);
702 void CaptureProgramUniformMatrix4fv_value(const State &glState,
703                                           bool isCallValid,
704                                           ShaderProgramID programPacked,
705                                           UniformLocation locationPacked,
706                                           GLsizei count,
707                                           GLboolean transpose,
708                                           const GLfloat *value,
709                                           angle::ParamCapture *paramCapture);
710 void CaptureProgramUniformMatrix4x2fv_value(const State &glState,
711                                             bool isCallValid,
712                                             ShaderProgramID programPacked,
713                                             UniformLocation locationPacked,
714                                             GLsizei count,
715                                             GLboolean transpose,
716                                             const GLfloat *value,
717                                             angle::ParamCapture *paramCapture);
718 void CaptureProgramUniformMatrix4x3fv_value(const State &glState,
719                                             bool isCallValid,
720                                             ShaderProgramID programPacked,
721                                             UniformLocation locationPacked,
722                                             GLsizei count,
723                                             GLboolean transpose,
724                                             const GLfloat *value,
725                                             angle::ParamCapture *paramCapture);
726 }  // namespace gl
727 
728 #endif  // LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
729