• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // capture_gl_3_autogen.cpp:
9 //   Capture functions for the OpenGL ES Desktop GL 3.x entry points.
10 
11 #include "libANGLE/capture/capture_gl_3_autogen.h"
12 
13 #include "common/gl_enum_utils.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 #include "libANGLE/validationGL3_autogen.h"
17 
18 using namespace angle;
19 
20 namespace gl
21 {
22 
23 // GL 3.0
CaptureBeginConditionalRender(const State & glState,bool isCallValid,GLuint id,GLenum mode)24 CallCapture CaptureBeginConditionalRender(const State &glState,
25                                           bool isCallValid,
26                                           GLuint id,
27                                           GLenum mode)
28 {
29     ParamBuffer paramBuffer;
30 
31     paramBuffer.addValueParam("id", ParamType::TGLuint, id);
32     paramBuffer.addEnumParam("mode", BigGLEnum::ConditionalRenderMode, ParamType::TGLenum, mode);
33 
34     return CallCapture(angle::EntryPoint::GLBeginConditionalRender, std::move(paramBuffer));
35 }
36 
CaptureBindFragDataLocation(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint color,const GLchar * name)37 CallCapture CaptureBindFragDataLocation(const State &glState,
38                                         bool isCallValid,
39                                         ShaderProgramID programPacked,
40                                         GLuint color,
41                                         const GLchar *name)
42 {
43     ParamBuffer paramBuffer;
44 
45     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
46     paramBuffer.addValueParam("color", ParamType::TGLuint, color);
47 
48     if (isCallValid)
49     {
50         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
51         InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
52         CaptureBindFragDataLocation_name(glState, isCallValid, programPacked, color, name,
53                                          &nameParam);
54         paramBuffer.addParam(std::move(nameParam));
55     }
56     else
57     {
58         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
59         InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
60                        &nameParam.value);
61         paramBuffer.addParam(std::move(nameParam));
62     }
63 
64     return CallCapture(angle::EntryPoint::GLBindFragDataLocation, std::move(paramBuffer));
65 }
66 
CaptureClampColor(const State & glState,bool isCallValid,GLenum target,GLenum clamp)67 CallCapture CaptureClampColor(const State &glState, bool isCallValid, GLenum target, GLenum clamp)
68 {
69     ParamBuffer paramBuffer;
70 
71     paramBuffer.addEnumParam("target", BigGLEnum::AllEnums, ParamType::TGLenum, target);
72     paramBuffer.addEnumParam("clamp", BigGLEnum::AllEnums, ParamType::TGLenum, clamp);
73 
74     return CallCapture(angle::EntryPoint::GLClampColor, std::move(paramBuffer));
75 }
76 
CaptureEndConditionalRender(const State & glState,bool isCallValid)77 CallCapture CaptureEndConditionalRender(const State &glState, bool isCallValid)
78 {
79     ParamBuffer paramBuffer;
80 
81     return CallCapture(angle::EntryPoint::GLEndConditionalRender, std::move(paramBuffer));
82 }
83 
CaptureFramebufferTexture1D(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level)84 CallCapture CaptureFramebufferTexture1D(const State &glState,
85                                         bool isCallValid,
86                                         GLenum target,
87                                         GLenum attachment,
88                                         TextureTarget textargetPacked,
89                                         TextureID texturePacked,
90                                         GLint level)
91 {
92     ParamBuffer paramBuffer;
93 
94     paramBuffer.addEnumParam("target", BigGLEnum::FramebufferTarget, ParamType::TGLenum, target);
95     paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum,
96                              attachment);
97     paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
98     paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
99     paramBuffer.addValueParam("level", ParamType::TGLint, level);
100 
101     return CallCapture(angle::EntryPoint::GLFramebufferTexture1D, std::move(paramBuffer));
102 }
103 
CaptureFramebufferTexture3D(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLint zoffset)104 CallCapture CaptureFramebufferTexture3D(const State &glState,
105                                         bool isCallValid,
106                                         GLenum target,
107                                         GLenum attachment,
108                                         TextureTarget textargetPacked,
109                                         TextureID texturePacked,
110                                         GLint level,
111                                         GLint zoffset)
112 {
113     ParamBuffer paramBuffer;
114 
115     paramBuffer.addEnumParam("target", BigGLEnum::FramebufferTarget, ParamType::TGLenum, target);
116     paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum,
117                              attachment);
118     paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
119     paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
120     paramBuffer.addValueParam("level", ParamType::TGLint, level);
121     paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
122 
123     return CallCapture(angle::EntryPoint::GLFramebufferTexture3D, std::move(paramBuffer));
124 }
125 
CaptureVertexAttribI1i(const State & glState,bool isCallValid,GLuint index,GLint x)126 CallCapture CaptureVertexAttribI1i(const State &glState, bool isCallValid, GLuint index, GLint x)
127 {
128     ParamBuffer paramBuffer;
129 
130     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
131     paramBuffer.addValueParam("x", ParamType::TGLint, x);
132 
133     return CallCapture(angle::EntryPoint::GLVertexAttribI1i, std::move(paramBuffer));
134 }
135 
CaptureVertexAttribI1iv(const State & glState,bool isCallValid,GLuint index,const GLint * v)136 CallCapture CaptureVertexAttribI1iv(const State &glState,
137                                     bool isCallValid,
138                                     GLuint index,
139                                     const GLint *v)
140 {
141     ParamBuffer paramBuffer;
142 
143     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
144 
145     if (isCallValid)
146     {
147         ParamCapture vParam("v", ParamType::TGLintConstPointer);
148         InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
149         CaptureVertexAttribI1iv_v(glState, isCallValid, index, v, &vParam);
150         paramBuffer.addParam(std::move(vParam));
151     }
152     else
153     {
154         ParamCapture vParam("v", ParamType::TGLintConstPointer);
155         InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
156                        &vParam.value);
157         paramBuffer.addParam(std::move(vParam));
158     }
159 
160     return CallCapture(angle::EntryPoint::GLVertexAttribI1iv, std::move(paramBuffer));
161 }
162 
CaptureVertexAttribI1ui(const State & glState,bool isCallValid,GLuint index,GLuint x)163 CallCapture CaptureVertexAttribI1ui(const State &glState, bool isCallValid, GLuint index, GLuint x)
164 {
165     ParamBuffer paramBuffer;
166 
167     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
168     paramBuffer.addValueParam("x", ParamType::TGLuint, x);
169 
170     return CallCapture(angle::EntryPoint::GLVertexAttribI1ui, std::move(paramBuffer));
171 }
172 
CaptureVertexAttribI1uiv(const State & glState,bool isCallValid,GLuint index,const GLuint * v)173 CallCapture CaptureVertexAttribI1uiv(const State &glState,
174                                      bool isCallValid,
175                                      GLuint index,
176                                      const GLuint *v)
177 {
178     ParamBuffer paramBuffer;
179 
180     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
181 
182     if (isCallValid)
183     {
184         ParamCapture vParam("v", ParamType::TGLuintConstPointer);
185         InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
186         CaptureVertexAttribI1uiv_v(glState, isCallValid, index, v, &vParam);
187         paramBuffer.addParam(std::move(vParam));
188     }
189     else
190     {
191         ParamCapture vParam("v", ParamType::TGLuintConstPointer);
192         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
193                        &vParam.value);
194         paramBuffer.addParam(std::move(vParam));
195     }
196 
197     return CallCapture(angle::EntryPoint::GLVertexAttribI1uiv, std::move(paramBuffer));
198 }
199 
CaptureVertexAttribI2i(const State & glState,bool isCallValid,GLuint index,GLint x,GLint y)200 CallCapture CaptureVertexAttribI2i(const State &glState,
201                                    bool isCallValid,
202                                    GLuint index,
203                                    GLint x,
204                                    GLint y)
205 {
206     ParamBuffer paramBuffer;
207 
208     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
209     paramBuffer.addValueParam("x", ParamType::TGLint, x);
210     paramBuffer.addValueParam("y", ParamType::TGLint, y);
211 
212     return CallCapture(angle::EntryPoint::GLVertexAttribI2i, std::move(paramBuffer));
213 }
214 
CaptureVertexAttribI2iv(const State & glState,bool isCallValid,GLuint index,const GLint * v)215 CallCapture CaptureVertexAttribI2iv(const State &glState,
216                                     bool isCallValid,
217                                     GLuint index,
218                                     const GLint *v)
219 {
220     ParamBuffer paramBuffer;
221 
222     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
223 
224     if (isCallValid)
225     {
226         ParamCapture vParam("v", ParamType::TGLintConstPointer);
227         InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
228         CaptureVertexAttribI2iv_v(glState, isCallValid, index, v, &vParam);
229         paramBuffer.addParam(std::move(vParam));
230     }
231     else
232     {
233         ParamCapture vParam("v", ParamType::TGLintConstPointer);
234         InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
235                        &vParam.value);
236         paramBuffer.addParam(std::move(vParam));
237     }
238 
239     return CallCapture(angle::EntryPoint::GLVertexAttribI2iv, std::move(paramBuffer));
240 }
241 
CaptureVertexAttribI2ui(const State & glState,bool isCallValid,GLuint index,GLuint x,GLuint y)242 CallCapture CaptureVertexAttribI2ui(const State &glState,
243                                     bool isCallValid,
244                                     GLuint index,
245                                     GLuint x,
246                                     GLuint y)
247 {
248     ParamBuffer paramBuffer;
249 
250     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
251     paramBuffer.addValueParam("x", ParamType::TGLuint, x);
252     paramBuffer.addValueParam("y", ParamType::TGLuint, y);
253 
254     return CallCapture(angle::EntryPoint::GLVertexAttribI2ui, std::move(paramBuffer));
255 }
256 
CaptureVertexAttribI2uiv(const State & glState,bool isCallValid,GLuint index,const GLuint * v)257 CallCapture CaptureVertexAttribI2uiv(const State &glState,
258                                      bool isCallValid,
259                                      GLuint index,
260                                      const GLuint *v)
261 {
262     ParamBuffer paramBuffer;
263 
264     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
265 
266     if (isCallValid)
267     {
268         ParamCapture vParam("v", ParamType::TGLuintConstPointer);
269         InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
270         CaptureVertexAttribI2uiv_v(glState, isCallValid, index, v, &vParam);
271         paramBuffer.addParam(std::move(vParam));
272     }
273     else
274     {
275         ParamCapture vParam("v", ParamType::TGLuintConstPointer);
276         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
277                        &vParam.value);
278         paramBuffer.addParam(std::move(vParam));
279     }
280 
281     return CallCapture(angle::EntryPoint::GLVertexAttribI2uiv, std::move(paramBuffer));
282 }
283 
CaptureVertexAttribI3i(const State & glState,bool isCallValid,GLuint index,GLint x,GLint y,GLint z)284 CallCapture CaptureVertexAttribI3i(const State &glState,
285                                    bool isCallValid,
286                                    GLuint index,
287                                    GLint x,
288                                    GLint y,
289                                    GLint z)
290 {
291     ParamBuffer paramBuffer;
292 
293     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
294     paramBuffer.addValueParam("x", ParamType::TGLint, x);
295     paramBuffer.addValueParam("y", ParamType::TGLint, y);
296     paramBuffer.addValueParam("z", ParamType::TGLint, z);
297 
298     return CallCapture(angle::EntryPoint::GLVertexAttribI3i, std::move(paramBuffer));
299 }
300 
CaptureVertexAttribI3iv(const State & glState,bool isCallValid,GLuint index,const GLint * v)301 CallCapture CaptureVertexAttribI3iv(const State &glState,
302                                     bool isCallValid,
303                                     GLuint index,
304                                     const GLint *v)
305 {
306     ParamBuffer paramBuffer;
307 
308     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
309 
310     if (isCallValid)
311     {
312         ParamCapture vParam("v", ParamType::TGLintConstPointer);
313         InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
314         CaptureVertexAttribI3iv_v(glState, isCallValid, index, v, &vParam);
315         paramBuffer.addParam(std::move(vParam));
316     }
317     else
318     {
319         ParamCapture vParam("v", ParamType::TGLintConstPointer);
320         InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
321                        &vParam.value);
322         paramBuffer.addParam(std::move(vParam));
323     }
324 
325     return CallCapture(angle::EntryPoint::GLVertexAttribI3iv, std::move(paramBuffer));
326 }
327 
CaptureVertexAttribI3ui(const State & glState,bool isCallValid,GLuint index,GLuint x,GLuint y,GLuint z)328 CallCapture CaptureVertexAttribI3ui(const State &glState,
329                                     bool isCallValid,
330                                     GLuint index,
331                                     GLuint x,
332                                     GLuint y,
333                                     GLuint z)
334 {
335     ParamBuffer paramBuffer;
336 
337     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
338     paramBuffer.addValueParam("x", ParamType::TGLuint, x);
339     paramBuffer.addValueParam("y", ParamType::TGLuint, y);
340     paramBuffer.addValueParam("z", ParamType::TGLuint, z);
341 
342     return CallCapture(angle::EntryPoint::GLVertexAttribI3ui, std::move(paramBuffer));
343 }
344 
CaptureVertexAttribI3uiv(const State & glState,bool isCallValid,GLuint index,const GLuint * v)345 CallCapture CaptureVertexAttribI3uiv(const State &glState,
346                                      bool isCallValid,
347                                      GLuint index,
348                                      const GLuint *v)
349 {
350     ParamBuffer paramBuffer;
351 
352     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
353 
354     if (isCallValid)
355     {
356         ParamCapture vParam("v", ParamType::TGLuintConstPointer);
357         InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
358         CaptureVertexAttribI3uiv_v(glState, isCallValid, index, v, &vParam);
359         paramBuffer.addParam(std::move(vParam));
360     }
361     else
362     {
363         ParamCapture vParam("v", ParamType::TGLuintConstPointer);
364         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
365                        &vParam.value);
366         paramBuffer.addParam(std::move(vParam));
367     }
368 
369     return CallCapture(angle::EntryPoint::GLVertexAttribI3uiv, std::move(paramBuffer));
370 }
371 
CaptureVertexAttribI4bv(const State & glState,bool isCallValid,GLuint index,const GLbyte * v)372 CallCapture CaptureVertexAttribI4bv(const State &glState,
373                                     bool isCallValid,
374                                     GLuint index,
375                                     const GLbyte *v)
376 {
377     ParamBuffer paramBuffer;
378 
379     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
380 
381     if (isCallValid)
382     {
383         ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
384         InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value);
385         CaptureVertexAttribI4bv_v(glState, isCallValid, index, v, &vParam);
386         paramBuffer.addParam(std::move(vParam));
387     }
388     else
389     {
390         ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
391         InitParamValue(ParamType::TGLbyteConstPointer, static_cast<const GLbyte *>(nullptr),
392                        &vParam.value);
393         paramBuffer.addParam(std::move(vParam));
394     }
395 
396     return CallCapture(angle::EntryPoint::GLVertexAttribI4bv, std::move(paramBuffer));
397 }
398 
CaptureVertexAttribI4sv(const State & glState,bool isCallValid,GLuint index,const GLshort * v)399 CallCapture CaptureVertexAttribI4sv(const State &glState,
400                                     bool isCallValid,
401                                     GLuint index,
402                                     const GLshort *v)
403 {
404     ParamBuffer paramBuffer;
405 
406     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
407 
408     if (isCallValid)
409     {
410         ParamCapture vParam("v", ParamType::TGLshortConstPointer);
411         InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
412         CaptureVertexAttribI4sv_v(glState, isCallValid, index, v, &vParam);
413         paramBuffer.addParam(std::move(vParam));
414     }
415     else
416     {
417         ParamCapture vParam("v", ParamType::TGLshortConstPointer);
418         InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
419                        &vParam.value);
420         paramBuffer.addParam(std::move(vParam));
421     }
422 
423     return CallCapture(angle::EntryPoint::GLVertexAttribI4sv, std::move(paramBuffer));
424 }
425 
CaptureVertexAttribI4ubv(const State & glState,bool isCallValid,GLuint index,const GLubyte * v)426 CallCapture CaptureVertexAttribI4ubv(const State &glState,
427                                      bool isCallValid,
428                                      GLuint index,
429                                      const GLubyte *v)
430 {
431     ParamBuffer paramBuffer;
432 
433     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
434 
435     if (isCallValid)
436     {
437         ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
438         InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value);
439         CaptureVertexAttribI4ubv_v(glState, isCallValid, index, v, &vParam);
440         paramBuffer.addParam(std::move(vParam));
441     }
442     else
443     {
444         ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
445         InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr),
446                        &vParam.value);
447         paramBuffer.addParam(std::move(vParam));
448     }
449 
450     return CallCapture(angle::EntryPoint::GLVertexAttribI4ubv, std::move(paramBuffer));
451 }
452 
CaptureVertexAttribI4usv(const State & glState,bool isCallValid,GLuint index,const GLushort * v)453 CallCapture CaptureVertexAttribI4usv(const State &glState,
454                                      bool isCallValid,
455                                      GLuint index,
456                                      const GLushort *v)
457 {
458     ParamBuffer paramBuffer;
459 
460     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
461 
462     if (isCallValid)
463     {
464         ParamCapture vParam("v", ParamType::TGLushortConstPointer);
465         InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value);
466         CaptureVertexAttribI4usv_v(glState, isCallValid, index, v, &vParam);
467         paramBuffer.addParam(std::move(vParam));
468     }
469     else
470     {
471         ParamCapture vParam("v", ParamType::TGLushortConstPointer);
472         InitParamValue(ParamType::TGLushortConstPointer, static_cast<const GLushort *>(nullptr),
473                        &vParam.value);
474         paramBuffer.addParam(std::move(vParam));
475     }
476 
477     return CallCapture(angle::EntryPoint::GLVertexAttribI4usv, std::move(paramBuffer));
478 }
479 
480 // GL 3.1
CaptureGetActiveUniformName(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint uniformIndex,GLsizei bufSize,GLsizei * length,GLchar * uniformName)481 CallCapture CaptureGetActiveUniformName(const State &glState,
482                                         bool isCallValid,
483                                         ShaderProgramID programPacked,
484                                         GLuint uniformIndex,
485                                         GLsizei bufSize,
486                                         GLsizei *length,
487                                         GLchar *uniformName)
488 {
489     ParamBuffer paramBuffer;
490 
491     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
492     paramBuffer.addValueParam("uniformIndex", ParamType::TGLuint, uniformIndex);
493     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
494 
495     if (isCallValid)
496     {
497         ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
498         InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
499         CaptureGetActiveUniformName_length(glState, isCallValid, programPacked, uniformIndex,
500                                            bufSize, length, uniformName, &lengthParam);
501         paramBuffer.addParam(std::move(lengthParam));
502     }
503     else
504     {
505         ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
506         InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
507                        &lengthParam.value);
508         paramBuffer.addParam(std::move(lengthParam));
509     }
510 
511     if (isCallValid)
512     {
513         ParamCapture uniformNameParam("uniformName", ParamType::TGLcharPointer);
514         InitParamValue(ParamType::TGLcharPointer, uniformName, &uniformNameParam.value);
515         CaptureGetActiveUniformName_uniformName(glState, isCallValid, programPacked, uniformIndex,
516                                                 bufSize, length, uniformName, &uniformNameParam);
517         paramBuffer.addParam(std::move(uniformNameParam));
518     }
519     else
520     {
521         ParamCapture uniformNameParam("uniformName", ParamType::TGLcharPointer);
522         InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
523                        &uniformNameParam.value);
524         paramBuffer.addParam(std::move(uniformNameParam));
525     }
526 
527     return CallCapture(angle::EntryPoint::GLGetActiveUniformName, std::move(paramBuffer));
528 }
529 
CapturePrimitiveRestartIndex(const State & glState,bool isCallValid,GLuint index)530 CallCapture CapturePrimitiveRestartIndex(const State &glState, bool isCallValid, GLuint index)
531 {
532     ParamBuffer paramBuffer;
533 
534     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
535 
536     return CallCapture(angle::EntryPoint::GLPrimitiveRestartIndex, std::move(paramBuffer));
537 }
538 
539 // GL 3.2
CaptureMultiDrawElementsBaseVertex(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount,const GLint * basevertex)540 CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState,
541                                                bool isCallValid,
542                                                PrimitiveMode modePacked,
543                                                const GLsizei *count,
544                                                DrawElementsType typePacked,
545                                                const void *const *indices,
546                                                GLsizei drawcount,
547                                                const GLint *basevertex)
548 {
549     ParamBuffer paramBuffer;
550 
551     paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
552 
553     if (isCallValid)
554     {
555         ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
556         InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value);
557         CaptureMultiDrawElementsBaseVertex_count(glState, isCallValid, modePacked, count,
558                                                  typePacked, indices, drawcount, basevertex,
559                                                  &countParam);
560         paramBuffer.addParam(std::move(countParam));
561     }
562     else
563     {
564         ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
565         InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
566                        &countParam.value);
567         paramBuffer.addParam(std::move(countParam));
568     }
569 
570     paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
571 
572     if (isCallValid)
573     {
574         ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
575         InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
576         CaptureMultiDrawElementsBaseVertex_indices(glState, isCallValid, modePacked, count,
577                                                    typePacked, indices, drawcount, basevertex,
578                                                    &indicesParam);
579         paramBuffer.addParam(std::move(indicesParam));
580     }
581     else
582     {
583         ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
584         InitParamValue(ParamType::TvoidConstPointerPointer,
585                        static_cast<const void *const *>(nullptr), &indicesParam.value);
586         paramBuffer.addParam(std::move(indicesParam));
587     }
588 
589     paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
590 
591     if (isCallValid)
592     {
593         ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
594         InitParamValue(ParamType::TGLintConstPointer, basevertex, &basevertexParam.value);
595         CaptureMultiDrawElementsBaseVertex_basevertex(glState, isCallValid, modePacked, count,
596                                                       typePacked, indices, drawcount, basevertex,
597                                                       &basevertexParam);
598         paramBuffer.addParam(std::move(basevertexParam));
599     }
600     else
601     {
602         ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
603         InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
604                        &basevertexParam.value);
605         paramBuffer.addParam(std::move(basevertexParam));
606     }
607 
608     return CallCapture(angle::EntryPoint::GLMultiDrawElementsBaseVertex, std::move(paramBuffer));
609 }
610 
CaptureProvokingVertex(const State & glState,bool isCallValid,ProvokingVertexConvention modePacked)611 CallCapture CaptureProvokingVertex(const State &glState,
612                                    bool isCallValid,
613                                    ProvokingVertexConvention modePacked)
614 {
615     ParamBuffer paramBuffer;
616 
617     paramBuffer.addValueParam("modePacked", ParamType::TProvokingVertexConvention, modePacked);
618 
619     return CallCapture(angle::EntryPoint::GLProvokingVertex, std::move(paramBuffer));
620 }
621 
CaptureTexImage2DMultisample(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)622 CallCapture CaptureTexImage2DMultisample(const State &glState,
623                                          bool isCallValid,
624                                          GLenum target,
625                                          GLsizei samples,
626                                          GLenum internalformat,
627                                          GLsizei width,
628                                          GLsizei height,
629                                          GLboolean fixedsamplelocations)
630 {
631     ParamBuffer paramBuffer;
632 
633     paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
634     paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
635     paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum,
636                              internalformat);
637     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
638     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
639     paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
640 
641     return CallCapture(angle::EntryPoint::GLTexImage2DMultisample, std::move(paramBuffer));
642 }
643 
CaptureTexImage3DMultisample(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)644 CallCapture CaptureTexImage3DMultisample(const State &glState,
645                                          bool isCallValid,
646                                          GLenum target,
647                                          GLsizei samples,
648                                          GLenum internalformat,
649                                          GLsizei width,
650                                          GLsizei height,
651                                          GLsizei depth,
652                                          GLboolean fixedsamplelocations)
653 {
654     ParamBuffer paramBuffer;
655 
656     paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
657     paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
658     paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum,
659                              internalformat);
660     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
661     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
662     paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
663     paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
664 
665     return CallCapture(angle::EntryPoint::GLTexImage3DMultisample, std::move(paramBuffer));
666 }
667 
668 // GL 3.3
CaptureBindFragDataLocationIndexed(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint colorNumber,GLuint index,const GLchar * name)669 CallCapture CaptureBindFragDataLocationIndexed(const State &glState,
670                                                bool isCallValid,
671                                                ShaderProgramID programPacked,
672                                                GLuint colorNumber,
673                                                GLuint index,
674                                                const GLchar *name)
675 {
676     ParamBuffer paramBuffer;
677 
678     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
679     paramBuffer.addValueParam("colorNumber", ParamType::TGLuint, colorNumber);
680     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
681 
682     if (isCallValid)
683     {
684         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
685         InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
686         CaptureBindFragDataLocationIndexed_name(glState, isCallValid, programPacked, colorNumber,
687                                                 index, name, &nameParam);
688         paramBuffer.addParam(std::move(nameParam));
689     }
690     else
691     {
692         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
693         InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
694                        &nameParam.value);
695         paramBuffer.addParam(std::move(nameParam));
696     }
697 
698     return CallCapture(angle::EntryPoint::GLBindFragDataLocationIndexed, std::move(paramBuffer));
699 }
700 
CaptureColorP3ui(const State & glState,bool isCallValid,GLenum type,GLuint color)701 CallCapture CaptureColorP3ui(const State &glState, bool isCallValid, GLenum type, GLuint color)
702 {
703     ParamBuffer paramBuffer;
704 
705     paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type);
706     paramBuffer.addValueParam("color", ParamType::TGLuint, color);
707 
708     return CallCapture(angle::EntryPoint::GLColorP3ui, std::move(paramBuffer));
709 }
710 
CaptureColorP3uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * color)711 CallCapture CaptureColorP3uiv(const State &glState,
712                               bool isCallValid,
713                               GLenum type,
714                               const GLuint *color)
715 {
716     ParamBuffer paramBuffer;
717 
718     paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type);
719 
720     if (isCallValid)
721     {
722         ParamCapture colorParam("color", ParamType::TGLuintConstPointer);
723         InitParamValue(ParamType::TGLuintConstPointer, color, &colorParam.value);
724         CaptureColorP3uiv_color(glState, isCallValid, type, color, &colorParam);
725         paramBuffer.addParam(std::move(colorParam));
726     }
727     else
728     {
729         ParamCapture colorParam("color", ParamType::TGLuintConstPointer);
730         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
731                        &colorParam.value);
732         paramBuffer.addParam(std::move(colorParam));
733     }
734 
735     return CallCapture(angle::EntryPoint::GLColorP3uiv, std::move(paramBuffer));
736 }
737 
CaptureColorP4ui(const State & glState,bool isCallValid,GLenum type,GLuint color)738 CallCapture CaptureColorP4ui(const State &glState, bool isCallValid, GLenum type, GLuint color)
739 {
740     ParamBuffer paramBuffer;
741 
742     paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type);
743     paramBuffer.addValueParam("color", ParamType::TGLuint, color);
744 
745     return CallCapture(angle::EntryPoint::GLColorP4ui, std::move(paramBuffer));
746 }
747 
CaptureColorP4uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * color)748 CallCapture CaptureColorP4uiv(const State &glState,
749                               bool isCallValid,
750                               GLenum type,
751                               const GLuint *color)
752 {
753     ParamBuffer paramBuffer;
754 
755     paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type);
756 
757     if (isCallValid)
758     {
759         ParamCapture colorParam("color", ParamType::TGLuintConstPointer);
760         InitParamValue(ParamType::TGLuintConstPointer, color, &colorParam.value);
761         CaptureColorP4uiv_color(glState, isCallValid, type, color, &colorParam);
762         paramBuffer.addParam(std::move(colorParam));
763     }
764     else
765     {
766         ParamCapture colorParam("color", ParamType::TGLuintConstPointer);
767         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
768                        &colorParam.value);
769         paramBuffer.addParam(std::move(colorParam));
770     }
771 
772     return CallCapture(angle::EntryPoint::GLColorP4uiv, std::move(paramBuffer));
773 }
774 
CaptureGetFragDataIndex(const State & glState,bool isCallValid,ShaderProgramID programPacked,const GLchar * name,GLint returnValue)775 CallCapture CaptureGetFragDataIndex(const State &glState,
776                                     bool isCallValid,
777                                     ShaderProgramID programPacked,
778                                     const GLchar *name,
779                                     GLint returnValue)
780 {
781     ParamBuffer paramBuffer;
782 
783     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
784 
785     if (isCallValid)
786     {
787         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
788         InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
789         CaptureGetFragDataIndex_name(glState, isCallValid, programPacked, name, &nameParam);
790         paramBuffer.addParam(std::move(nameParam));
791     }
792     else
793     {
794         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
795         InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
796                        &nameParam.value);
797         paramBuffer.addParam(std::move(nameParam));
798     }
799 
800     ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
801     InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
802     paramBuffer.addReturnValue(std::move(returnValueCapture));
803 
804     return CallCapture(angle::EntryPoint::GLGetFragDataIndex, std::move(paramBuffer));
805 }
806 
CaptureGetQueryObjecti64v(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint64 * params)807 CallCapture CaptureGetQueryObjecti64v(const State &glState,
808                                       bool isCallValid,
809                                       QueryID idPacked,
810                                       GLenum pname,
811                                       GLint64 *params)
812 {
813     ParamBuffer paramBuffer;
814 
815     paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
816     paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum,
817                              pname);
818 
819     if (isCallValid)
820     {
821         ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
822         InitParamValue(ParamType::TGLint64Pointer, params, &paramsParam.value);
823         CaptureGetQueryObjecti64v_params(glState, isCallValid, idPacked, pname, params,
824                                          &paramsParam);
825         paramBuffer.addParam(std::move(paramsParam));
826     }
827     else
828     {
829         ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
830         InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
831                        &paramsParam.value);
832         paramBuffer.addParam(std::move(paramsParam));
833     }
834 
835     return CallCapture(angle::EntryPoint::GLGetQueryObjecti64v, std::move(paramBuffer));
836 }
837 
CaptureGetQueryObjectui64v(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint64 * params)838 CallCapture CaptureGetQueryObjectui64v(const State &glState,
839                                        bool isCallValid,
840                                        QueryID idPacked,
841                                        GLenum pname,
842                                        GLuint64 *params)
843 {
844     ParamBuffer paramBuffer;
845 
846     paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
847     paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum,
848                              pname);
849 
850     if (isCallValid)
851     {
852         ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
853         InitParamValue(ParamType::TGLuint64Pointer, params, &paramsParam.value);
854         CaptureGetQueryObjectui64v_params(glState, isCallValid, idPacked, pname, params,
855                                           &paramsParam);
856         paramBuffer.addParam(std::move(paramsParam));
857     }
858     else
859     {
860         ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
861         InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
862                        &paramsParam.value);
863         paramBuffer.addParam(std::move(paramsParam));
864     }
865 
866     return CallCapture(angle::EntryPoint::GLGetQueryObjectui64v, std::move(paramBuffer));
867 }
868 
CaptureMultiTexCoordP1ui(const State & glState,bool isCallValid,GLenum texture,GLenum type,GLuint coords)869 CallCapture CaptureMultiTexCoordP1ui(const State &glState,
870                                      bool isCallValid,
871                                      GLenum texture,
872                                      GLenum type,
873                                      GLuint coords)
874 {
875     ParamBuffer paramBuffer;
876 
877     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
878     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
879     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
880 
881     return CallCapture(angle::EntryPoint::GLMultiTexCoordP1ui, std::move(paramBuffer));
882 }
883 
CaptureMultiTexCoordP1uiv(const State & glState,bool isCallValid,GLenum texture,GLenum type,const GLuint * coords)884 CallCapture CaptureMultiTexCoordP1uiv(const State &glState,
885                                       bool isCallValid,
886                                       GLenum texture,
887                                       GLenum type,
888                                       const GLuint *coords)
889 {
890     ParamBuffer paramBuffer;
891 
892     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
893     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
894 
895     if (isCallValid)
896     {
897         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
898         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
899         CaptureMultiTexCoordP1uiv_coords(glState, isCallValid, texture, type, coords, &coordsParam);
900         paramBuffer.addParam(std::move(coordsParam));
901     }
902     else
903     {
904         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
905         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
906                        &coordsParam.value);
907         paramBuffer.addParam(std::move(coordsParam));
908     }
909 
910     return CallCapture(angle::EntryPoint::GLMultiTexCoordP1uiv, std::move(paramBuffer));
911 }
912 
CaptureMultiTexCoordP2ui(const State & glState,bool isCallValid,GLenum texture,GLenum type,GLuint coords)913 CallCapture CaptureMultiTexCoordP2ui(const State &glState,
914                                      bool isCallValid,
915                                      GLenum texture,
916                                      GLenum type,
917                                      GLuint coords)
918 {
919     ParamBuffer paramBuffer;
920 
921     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
922     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
923     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
924 
925     return CallCapture(angle::EntryPoint::GLMultiTexCoordP2ui, std::move(paramBuffer));
926 }
927 
CaptureMultiTexCoordP2uiv(const State & glState,bool isCallValid,GLenum texture,GLenum type,const GLuint * coords)928 CallCapture CaptureMultiTexCoordP2uiv(const State &glState,
929                                       bool isCallValid,
930                                       GLenum texture,
931                                       GLenum type,
932                                       const GLuint *coords)
933 {
934     ParamBuffer paramBuffer;
935 
936     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
937     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
938 
939     if (isCallValid)
940     {
941         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
942         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
943         CaptureMultiTexCoordP2uiv_coords(glState, isCallValid, texture, type, coords, &coordsParam);
944         paramBuffer.addParam(std::move(coordsParam));
945     }
946     else
947     {
948         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
949         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
950                        &coordsParam.value);
951         paramBuffer.addParam(std::move(coordsParam));
952     }
953 
954     return CallCapture(angle::EntryPoint::GLMultiTexCoordP2uiv, std::move(paramBuffer));
955 }
956 
CaptureMultiTexCoordP3ui(const State & glState,bool isCallValid,GLenum texture,GLenum type,GLuint coords)957 CallCapture CaptureMultiTexCoordP3ui(const State &glState,
958                                      bool isCallValid,
959                                      GLenum texture,
960                                      GLenum type,
961                                      GLuint coords)
962 {
963     ParamBuffer paramBuffer;
964 
965     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
966     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
967     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
968 
969     return CallCapture(angle::EntryPoint::GLMultiTexCoordP3ui, std::move(paramBuffer));
970 }
971 
CaptureMultiTexCoordP3uiv(const State & glState,bool isCallValid,GLenum texture,GLenum type,const GLuint * coords)972 CallCapture CaptureMultiTexCoordP3uiv(const State &glState,
973                                       bool isCallValid,
974                                       GLenum texture,
975                                       GLenum type,
976                                       const GLuint *coords)
977 {
978     ParamBuffer paramBuffer;
979 
980     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
981     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
982 
983     if (isCallValid)
984     {
985         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
986         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
987         CaptureMultiTexCoordP3uiv_coords(glState, isCallValid, texture, type, coords, &coordsParam);
988         paramBuffer.addParam(std::move(coordsParam));
989     }
990     else
991     {
992         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
993         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
994                        &coordsParam.value);
995         paramBuffer.addParam(std::move(coordsParam));
996     }
997 
998     return CallCapture(angle::EntryPoint::GLMultiTexCoordP3uiv, std::move(paramBuffer));
999 }
1000 
CaptureMultiTexCoordP4ui(const State & glState,bool isCallValid,GLenum texture,GLenum type,GLuint coords)1001 CallCapture CaptureMultiTexCoordP4ui(const State &glState,
1002                                      bool isCallValid,
1003                                      GLenum texture,
1004                                      GLenum type,
1005                                      GLuint coords)
1006 {
1007     ParamBuffer paramBuffer;
1008 
1009     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
1010     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1011     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
1012 
1013     return CallCapture(angle::EntryPoint::GLMultiTexCoordP4ui, std::move(paramBuffer));
1014 }
1015 
CaptureMultiTexCoordP4uiv(const State & glState,bool isCallValid,GLenum texture,GLenum type,const GLuint * coords)1016 CallCapture CaptureMultiTexCoordP4uiv(const State &glState,
1017                                       bool isCallValid,
1018                                       GLenum texture,
1019                                       GLenum type,
1020                                       const GLuint *coords)
1021 {
1022     ParamBuffer paramBuffer;
1023 
1024     paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture);
1025     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1026 
1027     if (isCallValid)
1028     {
1029         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1030         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
1031         CaptureMultiTexCoordP4uiv_coords(glState, isCallValid, texture, type, coords, &coordsParam);
1032         paramBuffer.addParam(std::move(coordsParam));
1033     }
1034     else
1035     {
1036         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1037         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1038                        &coordsParam.value);
1039         paramBuffer.addParam(std::move(coordsParam));
1040     }
1041 
1042     return CallCapture(angle::EntryPoint::GLMultiTexCoordP4uiv, std::move(paramBuffer));
1043 }
1044 
CaptureNormalP3ui(const State & glState,bool isCallValid,GLenum type,GLuint coords)1045 CallCapture CaptureNormalP3ui(const State &glState, bool isCallValid, GLenum type, GLuint coords)
1046 {
1047     ParamBuffer paramBuffer;
1048 
1049     paramBuffer.addEnumParam("type", BigGLEnum::NormalPointerType, ParamType::TGLenum, type);
1050     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
1051 
1052     return CallCapture(angle::EntryPoint::GLNormalP3ui, std::move(paramBuffer));
1053 }
1054 
CaptureNormalP3uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * coords)1055 CallCapture CaptureNormalP3uiv(const State &glState,
1056                                bool isCallValid,
1057                                GLenum type,
1058                                const GLuint *coords)
1059 {
1060     ParamBuffer paramBuffer;
1061 
1062     paramBuffer.addEnumParam("type", BigGLEnum::NormalPointerType, ParamType::TGLenum, type);
1063 
1064     if (isCallValid)
1065     {
1066         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1067         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
1068         CaptureNormalP3uiv_coords(glState, isCallValid, type, coords, &coordsParam);
1069         paramBuffer.addParam(std::move(coordsParam));
1070     }
1071     else
1072     {
1073         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1074         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1075                        &coordsParam.value);
1076         paramBuffer.addParam(std::move(coordsParam));
1077     }
1078 
1079     return CallCapture(angle::EntryPoint::GLNormalP3uiv, std::move(paramBuffer));
1080 }
1081 
CaptureQueryCounter(const State & glState,bool isCallValid,QueryID idPacked,QueryType targetPacked)1082 CallCapture CaptureQueryCounter(const State &glState,
1083                                 bool isCallValid,
1084                                 QueryID idPacked,
1085                                 QueryType targetPacked)
1086 {
1087     ParamBuffer paramBuffer;
1088 
1089     paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
1090     paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
1091 
1092     return CallCapture(angle::EntryPoint::GLQueryCounter, std::move(paramBuffer));
1093 }
1094 
CaptureSecondaryColorP3ui(const State & glState,bool isCallValid,GLenum type,GLuint color)1095 CallCapture CaptureSecondaryColorP3ui(const State &glState,
1096                                       bool isCallValid,
1097                                       GLenum type,
1098                                       GLuint color)
1099 {
1100     ParamBuffer paramBuffer;
1101 
1102     paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type);
1103     paramBuffer.addValueParam("color", ParamType::TGLuint, color);
1104 
1105     return CallCapture(angle::EntryPoint::GLSecondaryColorP3ui, std::move(paramBuffer));
1106 }
1107 
CaptureSecondaryColorP3uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * color)1108 CallCapture CaptureSecondaryColorP3uiv(const State &glState,
1109                                        bool isCallValid,
1110                                        GLenum type,
1111                                        const GLuint *color)
1112 {
1113     ParamBuffer paramBuffer;
1114 
1115     paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type);
1116 
1117     if (isCallValid)
1118     {
1119         ParamCapture colorParam("color", ParamType::TGLuintConstPointer);
1120         InitParamValue(ParamType::TGLuintConstPointer, color, &colorParam.value);
1121         CaptureSecondaryColorP3uiv_color(glState, isCallValid, type, color, &colorParam);
1122         paramBuffer.addParam(std::move(colorParam));
1123     }
1124     else
1125     {
1126         ParamCapture colorParam("color", ParamType::TGLuintConstPointer);
1127         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1128                        &colorParam.value);
1129         paramBuffer.addParam(std::move(colorParam));
1130     }
1131 
1132     return CallCapture(angle::EntryPoint::GLSecondaryColorP3uiv, std::move(paramBuffer));
1133 }
1134 
CaptureTexCoordP1ui(const State & glState,bool isCallValid,GLenum type,GLuint coords)1135 CallCapture CaptureTexCoordP1ui(const State &glState, bool isCallValid, GLenum type, GLuint coords)
1136 {
1137     ParamBuffer paramBuffer;
1138 
1139     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1140     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
1141 
1142     return CallCapture(angle::EntryPoint::GLTexCoordP1ui, std::move(paramBuffer));
1143 }
1144 
CaptureTexCoordP1uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * coords)1145 CallCapture CaptureTexCoordP1uiv(const State &glState,
1146                                  bool isCallValid,
1147                                  GLenum type,
1148                                  const GLuint *coords)
1149 {
1150     ParamBuffer paramBuffer;
1151 
1152     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1153 
1154     if (isCallValid)
1155     {
1156         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1157         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
1158         CaptureTexCoordP1uiv_coords(glState, isCallValid, type, coords, &coordsParam);
1159         paramBuffer.addParam(std::move(coordsParam));
1160     }
1161     else
1162     {
1163         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1164         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1165                        &coordsParam.value);
1166         paramBuffer.addParam(std::move(coordsParam));
1167     }
1168 
1169     return CallCapture(angle::EntryPoint::GLTexCoordP1uiv, std::move(paramBuffer));
1170 }
1171 
CaptureTexCoordP2ui(const State & glState,bool isCallValid,GLenum type,GLuint coords)1172 CallCapture CaptureTexCoordP2ui(const State &glState, bool isCallValid, GLenum type, GLuint coords)
1173 {
1174     ParamBuffer paramBuffer;
1175 
1176     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1177     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
1178 
1179     return CallCapture(angle::EntryPoint::GLTexCoordP2ui, std::move(paramBuffer));
1180 }
1181 
CaptureTexCoordP2uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * coords)1182 CallCapture CaptureTexCoordP2uiv(const State &glState,
1183                                  bool isCallValid,
1184                                  GLenum type,
1185                                  const GLuint *coords)
1186 {
1187     ParamBuffer paramBuffer;
1188 
1189     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1190 
1191     if (isCallValid)
1192     {
1193         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1194         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
1195         CaptureTexCoordP2uiv_coords(glState, isCallValid, type, coords, &coordsParam);
1196         paramBuffer.addParam(std::move(coordsParam));
1197     }
1198     else
1199     {
1200         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1201         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1202                        &coordsParam.value);
1203         paramBuffer.addParam(std::move(coordsParam));
1204     }
1205 
1206     return CallCapture(angle::EntryPoint::GLTexCoordP2uiv, std::move(paramBuffer));
1207 }
1208 
CaptureTexCoordP3ui(const State & glState,bool isCallValid,GLenum type,GLuint coords)1209 CallCapture CaptureTexCoordP3ui(const State &glState, bool isCallValid, GLenum type, GLuint coords)
1210 {
1211     ParamBuffer paramBuffer;
1212 
1213     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1214     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
1215 
1216     return CallCapture(angle::EntryPoint::GLTexCoordP3ui, std::move(paramBuffer));
1217 }
1218 
CaptureTexCoordP3uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * coords)1219 CallCapture CaptureTexCoordP3uiv(const State &glState,
1220                                  bool isCallValid,
1221                                  GLenum type,
1222                                  const GLuint *coords)
1223 {
1224     ParamBuffer paramBuffer;
1225 
1226     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1227 
1228     if (isCallValid)
1229     {
1230         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1231         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
1232         CaptureTexCoordP3uiv_coords(glState, isCallValid, type, coords, &coordsParam);
1233         paramBuffer.addParam(std::move(coordsParam));
1234     }
1235     else
1236     {
1237         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1238         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1239                        &coordsParam.value);
1240         paramBuffer.addParam(std::move(coordsParam));
1241     }
1242 
1243     return CallCapture(angle::EntryPoint::GLTexCoordP3uiv, std::move(paramBuffer));
1244 }
1245 
CaptureTexCoordP4ui(const State & glState,bool isCallValid,GLenum type,GLuint coords)1246 CallCapture CaptureTexCoordP4ui(const State &glState, bool isCallValid, GLenum type, GLuint coords)
1247 {
1248     ParamBuffer paramBuffer;
1249 
1250     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1251     paramBuffer.addValueParam("coords", ParamType::TGLuint, coords);
1252 
1253     return CallCapture(angle::EntryPoint::GLTexCoordP4ui, std::move(paramBuffer));
1254 }
1255 
CaptureTexCoordP4uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * coords)1256 CallCapture CaptureTexCoordP4uiv(const State &glState,
1257                                  bool isCallValid,
1258                                  GLenum type,
1259                                  const GLuint *coords)
1260 {
1261     ParamBuffer paramBuffer;
1262 
1263     paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type);
1264 
1265     if (isCallValid)
1266     {
1267         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1268         InitParamValue(ParamType::TGLuintConstPointer, coords, &coordsParam.value);
1269         CaptureTexCoordP4uiv_coords(glState, isCallValid, type, coords, &coordsParam);
1270         paramBuffer.addParam(std::move(coordsParam));
1271     }
1272     else
1273     {
1274         ParamCapture coordsParam("coords", ParamType::TGLuintConstPointer);
1275         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1276                        &coordsParam.value);
1277         paramBuffer.addParam(std::move(coordsParam));
1278     }
1279 
1280     return CallCapture(angle::EntryPoint::GLTexCoordP4uiv, std::move(paramBuffer));
1281 }
1282 
CaptureVertexAttribP1ui(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,GLuint value)1283 CallCapture CaptureVertexAttribP1ui(const State &glState,
1284                                     bool isCallValid,
1285                                     GLuint index,
1286                                     GLenum type,
1287                                     GLboolean normalized,
1288                                     GLuint value)
1289 {
1290     ParamBuffer paramBuffer;
1291 
1292     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1293     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1294     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1295     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1296 
1297     return CallCapture(angle::EntryPoint::GLVertexAttribP1ui, std::move(paramBuffer));
1298 }
1299 
CaptureVertexAttribP1uiv(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1300 CallCapture CaptureVertexAttribP1uiv(const State &glState,
1301                                      bool isCallValid,
1302                                      GLuint index,
1303                                      GLenum type,
1304                                      GLboolean normalized,
1305                                      const GLuint *value)
1306 {
1307     ParamBuffer paramBuffer;
1308 
1309     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1310     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1311     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1312 
1313     if (isCallValid)
1314     {
1315         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1316         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1317         CaptureVertexAttribP1uiv_value(glState, isCallValid, index, type, normalized, value,
1318                                        &valueParam);
1319         paramBuffer.addParam(std::move(valueParam));
1320     }
1321     else
1322     {
1323         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1324         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1325                        &valueParam.value);
1326         paramBuffer.addParam(std::move(valueParam));
1327     }
1328 
1329     return CallCapture(angle::EntryPoint::GLVertexAttribP1uiv, std::move(paramBuffer));
1330 }
1331 
CaptureVertexAttribP2ui(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,GLuint value)1332 CallCapture CaptureVertexAttribP2ui(const State &glState,
1333                                     bool isCallValid,
1334                                     GLuint index,
1335                                     GLenum type,
1336                                     GLboolean normalized,
1337                                     GLuint value)
1338 {
1339     ParamBuffer paramBuffer;
1340 
1341     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1342     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1343     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1344     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1345 
1346     return CallCapture(angle::EntryPoint::GLVertexAttribP2ui, std::move(paramBuffer));
1347 }
1348 
CaptureVertexAttribP2uiv(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1349 CallCapture CaptureVertexAttribP2uiv(const State &glState,
1350                                      bool isCallValid,
1351                                      GLuint index,
1352                                      GLenum type,
1353                                      GLboolean normalized,
1354                                      const GLuint *value)
1355 {
1356     ParamBuffer paramBuffer;
1357 
1358     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1359     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1360     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1361 
1362     if (isCallValid)
1363     {
1364         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1365         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1366         CaptureVertexAttribP2uiv_value(glState, isCallValid, index, type, normalized, value,
1367                                        &valueParam);
1368         paramBuffer.addParam(std::move(valueParam));
1369     }
1370     else
1371     {
1372         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1373         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1374                        &valueParam.value);
1375         paramBuffer.addParam(std::move(valueParam));
1376     }
1377 
1378     return CallCapture(angle::EntryPoint::GLVertexAttribP2uiv, std::move(paramBuffer));
1379 }
1380 
CaptureVertexAttribP3ui(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,GLuint value)1381 CallCapture CaptureVertexAttribP3ui(const State &glState,
1382                                     bool isCallValid,
1383                                     GLuint index,
1384                                     GLenum type,
1385                                     GLboolean normalized,
1386                                     GLuint value)
1387 {
1388     ParamBuffer paramBuffer;
1389 
1390     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1391     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1392     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1393     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1394 
1395     return CallCapture(angle::EntryPoint::GLVertexAttribP3ui, std::move(paramBuffer));
1396 }
1397 
CaptureVertexAttribP3uiv(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1398 CallCapture CaptureVertexAttribP3uiv(const State &glState,
1399                                      bool isCallValid,
1400                                      GLuint index,
1401                                      GLenum type,
1402                                      GLboolean normalized,
1403                                      const GLuint *value)
1404 {
1405     ParamBuffer paramBuffer;
1406 
1407     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1408     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1409     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1410 
1411     if (isCallValid)
1412     {
1413         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1414         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1415         CaptureVertexAttribP3uiv_value(glState, isCallValid, index, type, normalized, value,
1416                                        &valueParam);
1417         paramBuffer.addParam(std::move(valueParam));
1418     }
1419     else
1420     {
1421         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1422         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1423                        &valueParam.value);
1424         paramBuffer.addParam(std::move(valueParam));
1425     }
1426 
1427     return CallCapture(angle::EntryPoint::GLVertexAttribP3uiv, std::move(paramBuffer));
1428 }
1429 
CaptureVertexAttribP4ui(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,GLuint value)1430 CallCapture CaptureVertexAttribP4ui(const State &glState,
1431                                     bool isCallValid,
1432                                     GLuint index,
1433                                     GLenum type,
1434                                     GLboolean normalized,
1435                                     GLuint value)
1436 {
1437     ParamBuffer paramBuffer;
1438 
1439     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1440     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1441     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1442     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1443 
1444     return CallCapture(angle::EntryPoint::GLVertexAttribP4ui, std::move(paramBuffer));
1445 }
1446 
CaptureVertexAttribP4uiv(const State & glState,bool isCallValid,GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1447 CallCapture CaptureVertexAttribP4uiv(const State &glState,
1448                                      bool isCallValid,
1449                                      GLuint index,
1450                                      GLenum type,
1451                                      GLboolean normalized,
1452                                      const GLuint *value)
1453 {
1454     ParamBuffer paramBuffer;
1455 
1456     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1457     paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type);
1458     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1459 
1460     if (isCallValid)
1461     {
1462         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1463         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1464         CaptureVertexAttribP4uiv_value(glState, isCallValid, index, type, normalized, value,
1465                                        &valueParam);
1466         paramBuffer.addParam(std::move(valueParam));
1467     }
1468     else
1469     {
1470         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1471         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1472                        &valueParam.value);
1473         paramBuffer.addParam(std::move(valueParam));
1474     }
1475 
1476     return CallCapture(angle::EntryPoint::GLVertexAttribP4uiv, std::move(paramBuffer));
1477 }
1478 
CaptureVertexP2ui(const State & glState,bool isCallValid,GLenum type,GLuint value)1479 CallCapture CaptureVertexP2ui(const State &glState, bool isCallValid, GLenum type, GLuint value)
1480 {
1481     ParamBuffer paramBuffer;
1482 
1483     paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type);
1484     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1485 
1486     return CallCapture(angle::EntryPoint::GLVertexP2ui, std::move(paramBuffer));
1487 }
1488 
CaptureVertexP2uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * value)1489 CallCapture CaptureVertexP2uiv(const State &glState,
1490                                bool isCallValid,
1491                                GLenum type,
1492                                const GLuint *value)
1493 {
1494     ParamBuffer paramBuffer;
1495 
1496     paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type);
1497 
1498     if (isCallValid)
1499     {
1500         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1501         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1502         CaptureVertexP2uiv_value(glState, isCallValid, type, value, &valueParam);
1503         paramBuffer.addParam(std::move(valueParam));
1504     }
1505     else
1506     {
1507         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1508         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1509                        &valueParam.value);
1510         paramBuffer.addParam(std::move(valueParam));
1511     }
1512 
1513     return CallCapture(angle::EntryPoint::GLVertexP2uiv, std::move(paramBuffer));
1514 }
1515 
CaptureVertexP3ui(const State & glState,bool isCallValid,GLenum type,GLuint value)1516 CallCapture CaptureVertexP3ui(const State &glState, bool isCallValid, GLenum type, GLuint value)
1517 {
1518     ParamBuffer paramBuffer;
1519 
1520     paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type);
1521     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1522 
1523     return CallCapture(angle::EntryPoint::GLVertexP3ui, std::move(paramBuffer));
1524 }
1525 
CaptureVertexP3uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * value)1526 CallCapture CaptureVertexP3uiv(const State &glState,
1527                                bool isCallValid,
1528                                GLenum type,
1529                                const GLuint *value)
1530 {
1531     ParamBuffer paramBuffer;
1532 
1533     paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type);
1534 
1535     if (isCallValid)
1536     {
1537         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1538         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1539         CaptureVertexP3uiv_value(glState, isCallValid, type, value, &valueParam);
1540         paramBuffer.addParam(std::move(valueParam));
1541     }
1542     else
1543     {
1544         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1545         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1546                        &valueParam.value);
1547         paramBuffer.addParam(std::move(valueParam));
1548     }
1549 
1550     return CallCapture(angle::EntryPoint::GLVertexP3uiv, std::move(paramBuffer));
1551 }
1552 
CaptureVertexP4ui(const State & glState,bool isCallValid,GLenum type,GLuint value)1553 CallCapture CaptureVertexP4ui(const State &glState, bool isCallValid, GLenum type, GLuint value)
1554 {
1555     ParamBuffer paramBuffer;
1556 
1557     paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type);
1558     paramBuffer.addValueParam("value", ParamType::TGLuint, value);
1559 
1560     return CallCapture(angle::EntryPoint::GLVertexP4ui, std::move(paramBuffer));
1561 }
1562 
CaptureVertexP4uiv(const State & glState,bool isCallValid,GLenum type,const GLuint * value)1563 CallCapture CaptureVertexP4uiv(const State &glState,
1564                                bool isCallValid,
1565                                GLenum type,
1566                                const GLuint *value)
1567 {
1568     ParamBuffer paramBuffer;
1569 
1570     paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type);
1571 
1572     if (isCallValid)
1573     {
1574         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1575         InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1576         CaptureVertexP4uiv_value(glState, isCallValid, type, value, &valueParam);
1577         paramBuffer.addParam(std::move(valueParam));
1578     }
1579     else
1580     {
1581         ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1582         InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
1583                        &valueParam.value);
1584         paramBuffer.addParam(std::move(valueParam));
1585     }
1586 
1587     return CallCapture(angle::EntryPoint::GLVertexP4uiv, std::move(paramBuffer));
1588 }
1589 
1590 }  // namespace gl
1591