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_1_0_autogen.cpp:
9 //   Capture functions for the OpenGL ES 1.0 entry points.
10 
11 #include "libANGLE/capture/capture_gles_1_0_autogen.h"
12 
13 #include "libANGLE/Context.h"
14 #include "libANGLE/capture/FrameCapture.h"
15 #include "libANGLE/capture/gl_enum_utils.h"
16 #include "libANGLE/validationES1.h"
17 
18 using namespace angle;
19 
20 namespace gl
21 {
22 
CaptureAlphaFunc(const State & glState,bool isCallValid,AlphaTestFunc funcPacked,GLfloat ref)23 CallCapture CaptureAlphaFunc(const State &glState,
24                              bool isCallValid,
25                              AlphaTestFunc funcPacked,
26                              GLfloat ref)
27 {
28     ParamBuffer paramBuffer;
29 
30     paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked);
31     paramBuffer.addValueParam("ref", ParamType::TGLfloat, ref);
32 
33     return CallCapture(angle::EntryPoint::GLAlphaFunc, std::move(paramBuffer));
34 }
35 
CaptureAlphaFuncx(const State & glState,bool isCallValid,AlphaTestFunc funcPacked,GLfixed ref)36 CallCapture CaptureAlphaFuncx(const State &glState,
37                               bool isCallValid,
38                               AlphaTestFunc funcPacked,
39                               GLfixed ref)
40 {
41     ParamBuffer paramBuffer;
42 
43     paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked);
44     paramBuffer.addValueParam("ref", ParamType::TGLfixed, ref);
45 
46     return CallCapture(angle::EntryPoint::GLAlphaFuncx, std::move(paramBuffer));
47 }
48 
CaptureClearColorx(const State & glState,bool isCallValid,GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)49 CallCapture CaptureClearColorx(const State &glState,
50                                bool isCallValid,
51                                GLfixed red,
52                                GLfixed green,
53                                GLfixed blue,
54                                GLfixed alpha)
55 {
56     ParamBuffer paramBuffer;
57 
58     paramBuffer.addValueParam("red", ParamType::TGLfixed, red);
59     paramBuffer.addValueParam("green", ParamType::TGLfixed, green);
60     paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue);
61     paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha);
62 
63     return CallCapture(angle::EntryPoint::GLClearColorx, std::move(paramBuffer));
64 }
65 
CaptureClearDepthx(const State & glState,bool isCallValid,GLfixed depth)66 CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth)
67 {
68     ParamBuffer paramBuffer;
69 
70     paramBuffer.addValueParam("depth", ParamType::TGLfixed, depth);
71 
72     return CallCapture(angle::EntryPoint::GLClearDepthx, std::move(paramBuffer));
73 }
74 
CaptureClientActiveTexture(const State & glState,bool isCallValid,GLenum texture)75 CallCapture CaptureClientActiveTexture(const State &glState, bool isCallValid, GLenum texture)
76 {
77     ParamBuffer paramBuffer;
78 
79     paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture);
80 
81     return CallCapture(angle::EntryPoint::GLClientActiveTexture, std::move(paramBuffer));
82 }
83 
CaptureClipPlanef(const State & glState,bool isCallValid,GLenum p,const GLfloat * eqn)84 CallCapture CaptureClipPlanef(const State &glState, bool isCallValid, GLenum p, const GLfloat *eqn)
85 {
86     ParamBuffer paramBuffer;
87 
88     paramBuffer.addEnumParam("p", GLenumGroup::ClipPlaneName, ParamType::TGLenum, p);
89 
90     if (isCallValid)
91     {
92         ParamCapture eqnParam("eqn", ParamType::TGLfloatConstPointer);
93         InitParamValue(ParamType::TGLfloatConstPointer, eqn, &eqnParam.value);
94         CaptureClipPlanef_eqn(glState, isCallValid, p, eqn, &eqnParam);
95         paramBuffer.addParam(std::move(eqnParam));
96     }
97     else
98     {
99         ParamCapture eqnParam("eqn", ParamType::TGLfloatConstPointer);
100         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
101                        &eqnParam.value);
102         paramBuffer.addParam(std::move(eqnParam));
103     }
104 
105     return CallCapture(angle::EntryPoint::GLClipPlanef, std::move(paramBuffer));
106 }
107 
CaptureClipPlanex(const State & glState,bool isCallValid,GLenum plane,const GLfixed * equation)108 CallCapture CaptureClipPlanex(const State &glState,
109                               bool isCallValid,
110                               GLenum plane,
111                               const GLfixed *equation)
112 {
113     ParamBuffer paramBuffer;
114 
115     paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);
116 
117     if (isCallValid)
118     {
119         ParamCapture equationParam("equation", ParamType::TGLfixedConstPointer);
120         InitParamValue(ParamType::TGLfixedConstPointer, equation, &equationParam.value);
121         CaptureClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam);
122         paramBuffer.addParam(std::move(equationParam));
123     }
124     else
125     {
126         ParamCapture equationParam("equation", ParamType::TGLfixedConstPointer);
127         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
128                        &equationParam.value);
129         paramBuffer.addParam(std::move(equationParam));
130     }
131 
132     return CallCapture(angle::EntryPoint::GLClipPlanex, std::move(paramBuffer));
133 }
134 
CaptureColor4f(const State & glState,bool isCallValid,GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)135 CallCapture CaptureColor4f(const State &glState,
136                            bool isCallValid,
137                            GLfloat red,
138                            GLfloat green,
139                            GLfloat blue,
140                            GLfloat alpha)
141 {
142     ParamBuffer paramBuffer;
143 
144     paramBuffer.addValueParam("red", ParamType::TGLfloat, red);
145     paramBuffer.addValueParam("green", ParamType::TGLfloat, green);
146     paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue);
147     paramBuffer.addValueParam("alpha", ParamType::TGLfloat, alpha);
148 
149     return CallCapture(angle::EntryPoint::GLColor4f, std::move(paramBuffer));
150 }
151 
CaptureColor4ub(const State & glState,bool isCallValid,GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)152 CallCapture CaptureColor4ub(const State &glState,
153                             bool isCallValid,
154                             GLubyte red,
155                             GLubyte green,
156                             GLubyte blue,
157                             GLubyte alpha)
158 {
159     ParamBuffer paramBuffer;
160 
161     paramBuffer.addValueParam("red", ParamType::TGLubyte, red);
162     paramBuffer.addValueParam("green", ParamType::TGLubyte, green);
163     paramBuffer.addValueParam("blue", ParamType::TGLubyte, blue);
164     paramBuffer.addValueParam("alpha", ParamType::TGLubyte, alpha);
165 
166     return CallCapture(angle::EntryPoint::GLColor4ub, std::move(paramBuffer));
167 }
168 
CaptureColor4x(const State & glState,bool isCallValid,GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)169 CallCapture CaptureColor4x(const State &glState,
170                            bool isCallValid,
171                            GLfixed red,
172                            GLfixed green,
173                            GLfixed blue,
174                            GLfixed alpha)
175 {
176     ParamBuffer paramBuffer;
177 
178     paramBuffer.addValueParam("red", ParamType::TGLfixed, red);
179     paramBuffer.addValueParam("green", ParamType::TGLfixed, green);
180     paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue);
181     paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha);
182 
183     return CallCapture(angle::EntryPoint::GLColor4x, std::move(paramBuffer));
184 }
185 
CaptureColorPointer(const State & glState,bool isCallValid,GLint size,VertexAttribType typePacked,GLsizei stride,const void * pointer)186 CallCapture CaptureColorPointer(const State &glState,
187                                 bool isCallValid,
188                                 GLint size,
189                                 VertexAttribType typePacked,
190                                 GLsizei stride,
191                                 const void *pointer)
192 {
193     ParamBuffer paramBuffer;
194 
195     paramBuffer.addValueParam("size", ParamType::TGLint, size);
196     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
197     paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
198 
199     if (isCallValid)
200     {
201         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
202         InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
203         CaptureColorPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer,
204                                     &pointerParam);
205         paramBuffer.addParam(std::move(pointerParam));
206     }
207     else
208     {
209         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
210         InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
211                        &pointerParam.value);
212         paramBuffer.addParam(std::move(pointerParam));
213     }
214 
215     return CallCapture(angle::EntryPoint::GLColorPointer, std::move(paramBuffer));
216 }
217 
CaptureDepthRangex(const State & glState,bool isCallValid,GLfixed n,GLfixed f)218 CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f)
219 {
220     ParamBuffer paramBuffer;
221 
222     paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
223     paramBuffer.addValueParam("f", ParamType::TGLfixed, f);
224 
225     return CallCapture(angle::EntryPoint::GLDepthRangex, std::move(paramBuffer));
226 }
227 
CaptureDisableClientState(const State & glState,bool isCallValid,ClientVertexArrayType arrayPacked)228 CallCapture CaptureDisableClientState(const State &glState,
229                                       bool isCallValid,
230                                       ClientVertexArrayType arrayPacked)
231 {
232     ParamBuffer paramBuffer;
233 
234     paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked);
235 
236     return CallCapture(angle::EntryPoint::GLDisableClientState, std::move(paramBuffer));
237 }
238 
CaptureEnableClientState(const State & glState,bool isCallValid,ClientVertexArrayType arrayPacked)239 CallCapture CaptureEnableClientState(const State &glState,
240                                      bool isCallValid,
241                                      ClientVertexArrayType arrayPacked)
242 {
243     ParamBuffer paramBuffer;
244 
245     paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked);
246 
247     return CallCapture(angle::EntryPoint::GLEnableClientState, std::move(paramBuffer));
248 }
249 
CaptureFogf(const State & glState,bool isCallValid,GLenum pname,GLfloat param)250 CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param)
251 {
252     ParamBuffer paramBuffer;
253 
254     paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname);
255     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
256 
257     return CallCapture(angle::EntryPoint::GLFogf, std::move(paramBuffer));
258 }
259 
CaptureFogfv(const State & glState,bool isCallValid,GLenum pname,const GLfloat * params)260 CallCapture CaptureFogfv(const State &glState,
261                          bool isCallValid,
262                          GLenum pname,
263                          const GLfloat *params)
264 {
265     ParamBuffer paramBuffer;
266 
267     paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname);
268 
269     if (isCallValid)
270     {
271         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
272         InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
273         CaptureFogfv_params(glState, isCallValid, pname, params, &paramsParam);
274         paramBuffer.addParam(std::move(paramsParam));
275     }
276     else
277     {
278         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
279         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
280                        &paramsParam.value);
281         paramBuffer.addParam(std::move(paramsParam));
282     }
283 
284     return CallCapture(angle::EntryPoint::GLFogfv, std::move(paramBuffer));
285 }
286 
CaptureFogx(const State & glState,bool isCallValid,GLenum pname,GLfixed param)287 CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param)
288 {
289     ParamBuffer paramBuffer;
290 
291     paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname);
292     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
293 
294     return CallCapture(angle::EntryPoint::GLFogx, std::move(paramBuffer));
295 }
296 
CaptureFogxv(const State & glState,bool isCallValid,GLenum pname,const GLfixed * param)297 CallCapture CaptureFogxv(const State &glState, bool isCallValid, GLenum pname, const GLfixed *param)
298 {
299     ParamBuffer paramBuffer;
300 
301     paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname);
302 
303     if (isCallValid)
304     {
305         ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
306         InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
307         CaptureFogxv_param(glState, isCallValid, pname, param, &paramParam);
308         paramBuffer.addParam(std::move(paramParam));
309     }
310     else
311     {
312         ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
313         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
314                        &paramParam.value);
315         paramBuffer.addParam(std::move(paramParam));
316     }
317 
318     return CallCapture(angle::EntryPoint::GLFogxv, std::move(paramBuffer));
319 }
320 
CaptureFrustumf(const State & glState,bool isCallValid,GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f)321 CallCapture CaptureFrustumf(const State &glState,
322                             bool isCallValid,
323                             GLfloat l,
324                             GLfloat r,
325                             GLfloat b,
326                             GLfloat t,
327                             GLfloat n,
328                             GLfloat f)
329 {
330     ParamBuffer paramBuffer;
331 
332     paramBuffer.addValueParam("l", ParamType::TGLfloat, l);
333     paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
334     paramBuffer.addValueParam("b", ParamType::TGLfloat, b);
335     paramBuffer.addValueParam("t", ParamType::TGLfloat, t);
336     paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
337     paramBuffer.addValueParam("f", ParamType::TGLfloat, f);
338 
339     return CallCapture(angle::EntryPoint::GLFrustumf, std::move(paramBuffer));
340 }
341 
CaptureFrustumx(const State & glState,bool isCallValid,GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f)342 CallCapture CaptureFrustumx(const State &glState,
343                             bool isCallValid,
344                             GLfixed l,
345                             GLfixed r,
346                             GLfixed b,
347                             GLfixed t,
348                             GLfixed n,
349                             GLfixed f)
350 {
351     ParamBuffer paramBuffer;
352 
353     paramBuffer.addValueParam("l", ParamType::TGLfixed, l);
354     paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
355     paramBuffer.addValueParam("b", ParamType::TGLfixed, b);
356     paramBuffer.addValueParam("t", ParamType::TGLfixed, t);
357     paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
358     paramBuffer.addValueParam("f", ParamType::TGLfixed, f);
359 
360     return CallCapture(angle::EntryPoint::GLFrustumx, std::move(paramBuffer));
361 }
362 
CaptureGetClipPlanef(const State & glState,bool isCallValid,GLenum plane,GLfloat * equation)363 CallCapture CaptureGetClipPlanef(const State &glState,
364                                  bool isCallValid,
365                                  GLenum plane,
366                                  GLfloat *equation)
367 {
368     ParamBuffer paramBuffer;
369 
370     paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);
371 
372     if (isCallValid)
373     {
374         ParamCapture equationParam("equation", ParamType::TGLfloatPointer);
375         InitParamValue(ParamType::TGLfloatPointer, equation, &equationParam.value);
376         CaptureGetClipPlanef_equation(glState, isCallValid, plane, equation, &equationParam);
377         paramBuffer.addParam(std::move(equationParam));
378     }
379     else
380     {
381         ParamCapture equationParam("equation", ParamType::TGLfloatPointer);
382         InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
383                        &equationParam.value);
384         paramBuffer.addParam(std::move(equationParam));
385     }
386 
387     return CallCapture(angle::EntryPoint::GLGetClipPlanef, std::move(paramBuffer));
388 }
389 
CaptureGetClipPlanex(const State & glState,bool isCallValid,GLenum plane,GLfixed * equation)390 CallCapture CaptureGetClipPlanex(const State &glState,
391                                  bool isCallValid,
392                                  GLenum plane,
393                                  GLfixed *equation)
394 {
395     ParamBuffer paramBuffer;
396 
397     paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);
398 
399     if (isCallValid)
400     {
401         ParamCapture equationParam("equation", ParamType::TGLfixedPointer);
402         InitParamValue(ParamType::TGLfixedPointer, equation, &equationParam.value);
403         CaptureGetClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam);
404         paramBuffer.addParam(std::move(equationParam));
405     }
406     else
407     {
408         ParamCapture equationParam("equation", ParamType::TGLfixedPointer);
409         InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
410                        &equationParam.value);
411         paramBuffer.addParam(std::move(equationParam));
412     }
413 
414     return CallCapture(angle::EntryPoint::GLGetClipPlanex, std::move(paramBuffer));
415 }
416 
CaptureGetFixedv(const State & glState,bool isCallValid,GLenum pname,GLfixed * params)417 CallCapture CaptureGetFixedv(const State &glState, bool isCallValid, GLenum pname, GLfixed *params)
418 {
419     ParamBuffer paramBuffer;
420 
421     paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
422 
423     if (isCallValid)
424     {
425         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
426         InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
427         CaptureGetFixedv_params(glState, isCallValid, pname, params, &paramsParam);
428         paramBuffer.addParam(std::move(paramsParam));
429     }
430     else
431     {
432         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
433         InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
434                        &paramsParam.value);
435         paramBuffer.addParam(std::move(paramsParam));
436     }
437 
438     return CallCapture(angle::EntryPoint::GLGetFixedv, std::move(paramBuffer));
439 }
440 
CaptureGetLightfv(const State & glState,bool isCallValid,GLenum light,LightParameter pnamePacked,GLfloat * params)441 CallCapture CaptureGetLightfv(const State &glState,
442                               bool isCallValid,
443                               GLenum light,
444                               LightParameter pnamePacked,
445                               GLfloat *params)
446 {
447     ParamBuffer paramBuffer;
448 
449     paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
450     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
451 
452     if (isCallValid)
453     {
454         ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
455         InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
456         CaptureGetLightfv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
457         paramBuffer.addParam(std::move(paramsParam));
458     }
459     else
460     {
461         ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
462         InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
463                        &paramsParam.value);
464         paramBuffer.addParam(std::move(paramsParam));
465     }
466 
467     return CallCapture(angle::EntryPoint::GLGetLightfv, std::move(paramBuffer));
468 }
469 
CaptureGetLightxv(const State & glState,bool isCallValid,GLenum light,LightParameter pnamePacked,GLfixed * params)470 CallCapture CaptureGetLightxv(const State &glState,
471                               bool isCallValid,
472                               GLenum light,
473                               LightParameter pnamePacked,
474                               GLfixed *params)
475 {
476     ParamBuffer paramBuffer;
477 
478     paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
479     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
480 
481     if (isCallValid)
482     {
483         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
484         InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
485         CaptureGetLightxv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
486         paramBuffer.addParam(std::move(paramsParam));
487     }
488     else
489     {
490         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
491         InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
492                        &paramsParam.value);
493         paramBuffer.addParam(std::move(paramsParam));
494     }
495 
496     return CallCapture(angle::EntryPoint::GLGetLightxv, std::move(paramBuffer));
497 }
498 
CaptureGetMaterialfv(const State & glState,bool isCallValid,GLenum face,MaterialParameter pnamePacked,GLfloat * params)499 CallCapture CaptureGetMaterialfv(const State &glState,
500                                  bool isCallValid,
501                                  GLenum face,
502                                  MaterialParameter pnamePacked,
503                                  GLfloat *params)
504 {
505     ParamBuffer paramBuffer;
506 
507     paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
508     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
509 
510     if (isCallValid)
511     {
512         ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
513         InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
514         CaptureGetMaterialfv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
515         paramBuffer.addParam(std::move(paramsParam));
516     }
517     else
518     {
519         ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
520         InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
521                        &paramsParam.value);
522         paramBuffer.addParam(std::move(paramsParam));
523     }
524 
525     return CallCapture(angle::EntryPoint::GLGetMaterialfv, std::move(paramBuffer));
526 }
527 
CaptureGetMaterialxv(const State & glState,bool isCallValid,GLenum face,MaterialParameter pnamePacked,GLfixed * params)528 CallCapture CaptureGetMaterialxv(const State &glState,
529                                  bool isCallValid,
530                                  GLenum face,
531                                  MaterialParameter pnamePacked,
532                                  GLfixed *params)
533 {
534     ParamBuffer paramBuffer;
535 
536     paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
537     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
538 
539     if (isCallValid)
540     {
541         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
542         InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
543         CaptureGetMaterialxv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
544         paramBuffer.addParam(std::move(paramsParam));
545     }
546     else
547     {
548         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
549         InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
550                        &paramsParam.value);
551         paramBuffer.addParam(std::move(paramsParam));
552     }
553 
554     return CallCapture(angle::EntryPoint::GLGetMaterialxv, std::move(paramBuffer));
555 }
556 
CaptureGetTexEnvfv(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,GLfloat * params)557 CallCapture CaptureGetTexEnvfv(const State &glState,
558                                bool isCallValid,
559                                TextureEnvTarget targetPacked,
560                                TextureEnvParameter pnamePacked,
561                                GLfloat *params)
562 {
563     ParamBuffer paramBuffer;
564 
565     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
566     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
567 
568     if (isCallValid)
569     {
570         ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
571         InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
572         CaptureGetTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params,
573                                   &paramsParam);
574         paramBuffer.addParam(std::move(paramsParam));
575     }
576     else
577     {
578         ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
579         InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
580                        &paramsParam.value);
581         paramBuffer.addParam(std::move(paramsParam));
582     }
583 
584     return CallCapture(angle::EntryPoint::GLGetTexEnvfv, std::move(paramBuffer));
585 }
586 
CaptureGetTexEnviv(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,GLint * params)587 CallCapture CaptureGetTexEnviv(const State &glState,
588                                bool isCallValid,
589                                TextureEnvTarget targetPacked,
590                                TextureEnvParameter pnamePacked,
591                                GLint *params)
592 {
593     ParamBuffer paramBuffer;
594 
595     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
596     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
597 
598     if (isCallValid)
599     {
600         ParamCapture paramsParam("params", ParamType::TGLintPointer);
601         InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
602         CaptureGetTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params,
603                                   &paramsParam);
604         paramBuffer.addParam(std::move(paramsParam));
605     }
606     else
607     {
608         ParamCapture paramsParam("params", ParamType::TGLintPointer);
609         InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
610         paramBuffer.addParam(std::move(paramsParam));
611     }
612 
613     return CallCapture(angle::EntryPoint::GLGetTexEnviv, std::move(paramBuffer));
614 }
615 
CaptureGetTexEnvxv(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,GLfixed * params)616 CallCapture CaptureGetTexEnvxv(const State &glState,
617                                bool isCallValid,
618                                TextureEnvTarget targetPacked,
619                                TextureEnvParameter pnamePacked,
620                                GLfixed *params)
621 {
622     ParamBuffer paramBuffer;
623 
624     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
625     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
626 
627     if (isCallValid)
628     {
629         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
630         InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
631         CaptureGetTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params,
632                                   &paramsParam);
633         paramBuffer.addParam(std::move(paramsParam));
634     }
635     else
636     {
637         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
638         InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
639                        &paramsParam.value);
640         paramBuffer.addParam(std::move(paramsParam));
641     }
642 
643     return CallCapture(angle::EntryPoint::GLGetTexEnvxv, std::move(paramBuffer));
644 }
645 
CaptureGetTexParameterxv(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLfixed * params)646 CallCapture CaptureGetTexParameterxv(const State &glState,
647                                      bool isCallValid,
648                                      TextureType targetPacked,
649                                      GLenum pname,
650                                      GLfixed *params)
651 {
652     ParamBuffer paramBuffer;
653 
654     paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
655     paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
656 
657     if (isCallValid)
658     {
659         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
660         InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
661         CaptureGetTexParameterxv_params(glState, isCallValid, targetPacked, pname, params,
662                                         &paramsParam);
663         paramBuffer.addParam(std::move(paramsParam));
664     }
665     else
666     {
667         ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
668         InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
669                        &paramsParam.value);
670         paramBuffer.addParam(std::move(paramsParam));
671     }
672 
673     return CallCapture(angle::EntryPoint::GLGetTexParameterxv, std::move(paramBuffer));
674 }
675 
CaptureLightModelf(const State & glState,bool isCallValid,GLenum pname,GLfloat param)676 CallCapture CaptureLightModelf(const State &glState, bool isCallValid, GLenum pname, GLfloat param)
677 {
678     ParamBuffer paramBuffer;
679 
680     paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
681     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
682 
683     return CallCapture(angle::EntryPoint::GLLightModelf, std::move(paramBuffer));
684 }
685 
CaptureLightModelfv(const State & glState,bool isCallValid,GLenum pname,const GLfloat * params)686 CallCapture CaptureLightModelfv(const State &glState,
687                                 bool isCallValid,
688                                 GLenum pname,
689                                 const GLfloat *params)
690 {
691     ParamBuffer paramBuffer;
692 
693     paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
694 
695     if (isCallValid)
696     {
697         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
698         InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
699         CaptureLightModelfv_params(glState, isCallValid, pname, params, &paramsParam);
700         paramBuffer.addParam(std::move(paramsParam));
701     }
702     else
703     {
704         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
705         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
706                        &paramsParam.value);
707         paramBuffer.addParam(std::move(paramsParam));
708     }
709 
710     return CallCapture(angle::EntryPoint::GLLightModelfv, std::move(paramBuffer));
711 }
712 
CaptureLightModelx(const State & glState,bool isCallValid,GLenum pname,GLfixed param)713 CallCapture CaptureLightModelx(const State &glState, bool isCallValid, GLenum pname, GLfixed param)
714 {
715     ParamBuffer paramBuffer;
716 
717     paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
718     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
719 
720     return CallCapture(angle::EntryPoint::GLLightModelx, std::move(paramBuffer));
721 }
722 
CaptureLightModelxv(const State & glState,bool isCallValid,GLenum pname,const GLfixed * param)723 CallCapture CaptureLightModelxv(const State &glState,
724                                 bool isCallValid,
725                                 GLenum pname,
726                                 const GLfixed *param)
727 {
728     ParamBuffer paramBuffer;
729 
730     paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
731 
732     if (isCallValid)
733     {
734         ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
735         InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
736         CaptureLightModelxv_param(glState, isCallValid, pname, param, &paramParam);
737         paramBuffer.addParam(std::move(paramParam));
738     }
739     else
740     {
741         ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
742         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
743                        &paramParam.value);
744         paramBuffer.addParam(std::move(paramParam));
745     }
746 
747     return CallCapture(angle::EntryPoint::GLLightModelxv, std::move(paramBuffer));
748 }
749 
CaptureLightf(const State & glState,bool isCallValid,GLenum light,LightParameter pnamePacked,GLfloat param)750 CallCapture CaptureLightf(const State &glState,
751                           bool isCallValid,
752                           GLenum light,
753                           LightParameter pnamePacked,
754                           GLfloat param)
755 {
756     ParamBuffer paramBuffer;
757 
758     paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
759     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
760     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
761 
762     return CallCapture(angle::EntryPoint::GLLightf, std::move(paramBuffer));
763 }
764 
CaptureLightfv(const State & glState,bool isCallValid,GLenum light,LightParameter pnamePacked,const GLfloat * params)765 CallCapture CaptureLightfv(const State &glState,
766                            bool isCallValid,
767                            GLenum light,
768                            LightParameter pnamePacked,
769                            const GLfloat *params)
770 {
771     ParamBuffer paramBuffer;
772 
773     paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
774     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
775 
776     if (isCallValid)
777     {
778         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
779         InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
780         CaptureLightfv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
781         paramBuffer.addParam(std::move(paramsParam));
782     }
783     else
784     {
785         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
786         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
787                        &paramsParam.value);
788         paramBuffer.addParam(std::move(paramsParam));
789     }
790 
791     return CallCapture(angle::EntryPoint::GLLightfv, std::move(paramBuffer));
792 }
793 
CaptureLightx(const State & glState,bool isCallValid,GLenum light,LightParameter pnamePacked,GLfixed param)794 CallCapture CaptureLightx(const State &glState,
795                           bool isCallValid,
796                           GLenum light,
797                           LightParameter pnamePacked,
798                           GLfixed param)
799 {
800     ParamBuffer paramBuffer;
801 
802     paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
803     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
804     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
805 
806     return CallCapture(angle::EntryPoint::GLLightx, std::move(paramBuffer));
807 }
808 
CaptureLightxv(const State & glState,bool isCallValid,GLenum light,LightParameter pnamePacked,const GLfixed * params)809 CallCapture CaptureLightxv(const State &glState,
810                            bool isCallValid,
811                            GLenum light,
812                            LightParameter pnamePacked,
813                            const GLfixed *params)
814 {
815     ParamBuffer paramBuffer;
816 
817     paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
818     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
819 
820     if (isCallValid)
821     {
822         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
823         InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
824         CaptureLightxv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
825         paramBuffer.addParam(std::move(paramsParam));
826     }
827     else
828     {
829         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
830         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
831                        &paramsParam.value);
832         paramBuffer.addParam(std::move(paramsParam));
833     }
834 
835     return CallCapture(angle::EntryPoint::GLLightxv, std::move(paramBuffer));
836 }
837 
CaptureLineWidthx(const State & glState,bool isCallValid,GLfixed width)838 CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width)
839 {
840     ParamBuffer paramBuffer;
841 
842     paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
843 
844     return CallCapture(angle::EntryPoint::GLLineWidthx, std::move(paramBuffer));
845 }
846 
CaptureLoadIdentity(const State & glState,bool isCallValid)847 CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid)
848 {
849     ParamBuffer paramBuffer;
850 
851     return CallCapture(angle::EntryPoint::GLLoadIdentity, std::move(paramBuffer));
852 }
853 
CaptureLoadMatrixf(const State & glState,bool isCallValid,const GLfloat * m)854 CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m)
855 {
856     ParamBuffer paramBuffer;
857 
858     if (isCallValid)
859     {
860         ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
861         InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value);
862         CaptureLoadMatrixf_m(glState, isCallValid, m, &mParam);
863         paramBuffer.addParam(std::move(mParam));
864     }
865     else
866     {
867         ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
868         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
869                        &mParam.value);
870         paramBuffer.addParam(std::move(mParam));
871     }
872 
873     return CallCapture(angle::EntryPoint::GLLoadMatrixf, std::move(paramBuffer));
874 }
875 
CaptureLoadMatrixx(const State & glState,bool isCallValid,const GLfixed * m)876 CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m)
877 {
878     ParamBuffer paramBuffer;
879 
880     if (isCallValid)
881     {
882         ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
883         InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value);
884         CaptureLoadMatrixx_m(glState, isCallValid, m, &mParam);
885         paramBuffer.addParam(std::move(mParam));
886     }
887     else
888     {
889         ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
890         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
891                        &mParam.value);
892         paramBuffer.addParam(std::move(mParam));
893     }
894 
895     return CallCapture(angle::EntryPoint::GLLoadMatrixx, std::move(paramBuffer));
896 }
897 
CaptureLogicOp(const State & glState,bool isCallValid,LogicalOperation opcodePacked)898 CallCapture CaptureLogicOp(const State &glState, bool isCallValid, LogicalOperation opcodePacked)
899 {
900     ParamBuffer paramBuffer;
901 
902     paramBuffer.addValueParam("opcodePacked", ParamType::TLogicalOperation, opcodePacked);
903 
904     return CallCapture(angle::EntryPoint::GLLogicOp, std::move(paramBuffer));
905 }
906 
CaptureMaterialf(const State & glState,bool isCallValid,GLenum face,MaterialParameter pnamePacked,GLfloat param)907 CallCapture CaptureMaterialf(const State &glState,
908                              bool isCallValid,
909                              GLenum face,
910                              MaterialParameter pnamePacked,
911                              GLfloat param)
912 {
913     ParamBuffer paramBuffer;
914 
915     paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
916     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
917     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
918 
919     return CallCapture(angle::EntryPoint::GLMaterialf, std::move(paramBuffer));
920 }
921 
CaptureMaterialfv(const State & glState,bool isCallValid,GLenum face,MaterialParameter pnamePacked,const GLfloat * params)922 CallCapture CaptureMaterialfv(const State &glState,
923                               bool isCallValid,
924                               GLenum face,
925                               MaterialParameter pnamePacked,
926                               const GLfloat *params)
927 {
928     ParamBuffer paramBuffer;
929 
930     paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
931     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
932 
933     if (isCallValid)
934     {
935         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
936         InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
937         CaptureMaterialfv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
938         paramBuffer.addParam(std::move(paramsParam));
939     }
940     else
941     {
942         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
943         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
944                        &paramsParam.value);
945         paramBuffer.addParam(std::move(paramsParam));
946     }
947 
948     return CallCapture(angle::EntryPoint::GLMaterialfv, std::move(paramBuffer));
949 }
950 
CaptureMaterialx(const State & glState,bool isCallValid,GLenum face,MaterialParameter pnamePacked,GLfixed param)951 CallCapture CaptureMaterialx(const State &glState,
952                              bool isCallValid,
953                              GLenum face,
954                              MaterialParameter pnamePacked,
955                              GLfixed param)
956 {
957     ParamBuffer paramBuffer;
958 
959     paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
960     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
961     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
962 
963     return CallCapture(angle::EntryPoint::GLMaterialx, std::move(paramBuffer));
964 }
965 
CaptureMaterialxv(const State & glState,bool isCallValid,GLenum face,MaterialParameter pnamePacked,const GLfixed * param)966 CallCapture CaptureMaterialxv(const State &glState,
967                               bool isCallValid,
968                               GLenum face,
969                               MaterialParameter pnamePacked,
970                               const GLfixed *param)
971 {
972     ParamBuffer paramBuffer;
973 
974     paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
975     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
976 
977     if (isCallValid)
978     {
979         ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
980         InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
981         CaptureMaterialxv_param(glState, isCallValid, face, pnamePacked, param, &paramParam);
982         paramBuffer.addParam(std::move(paramParam));
983     }
984     else
985     {
986         ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
987         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
988                        &paramParam.value);
989         paramBuffer.addParam(std::move(paramParam));
990     }
991 
992     return CallCapture(angle::EntryPoint::GLMaterialxv, std::move(paramBuffer));
993 }
994 
CaptureMatrixMode(const State & glState,bool isCallValid,MatrixType modePacked)995 CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked)
996 {
997     ParamBuffer paramBuffer;
998 
999     paramBuffer.addValueParam("modePacked", ParamType::TMatrixType, modePacked);
1000 
1001     return CallCapture(angle::EntryPoint::GLMatrixMode, std::move(paramBuffer));
1002 }
1003 
CaptureMultMatrixf(const State & glState,bool isCallValid,const GLfloat * m)1004 CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m)
1005 {
1006     ParamBuffer paramBuffer;
1007 
1008     if (isCallValid)
1009     {
1010         ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
1011         InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value);
1012         CaptureMultMatrixf_m(glState, isCallValid, m, &mParam);
1013         paramBuffer.addParam(std::move(mParam));
1014     }
1015     else
1016     {
1017         ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
1018         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
1019                        &mParam.value);
1020         paramBuffer.addParam(std::move(mParam));
1021     }
1022 
1023     return CallCapture(angle::EntryPoint::GLMultMatrixf, std::move(paramBuffer));
1024 }
1025 
CaptureMultMatrixx(const State & glState,bool isCallValid,const GLfixed * m)1026 CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m)
1027 {
1028     ParamBuffer paramBuffer;
1029 
1030     if (isCallValid)
1031     {
1032         ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
1033         InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value);
1034         CaptureMultMatrixx_m(glState, isCallValid, m, &mParam);
1035         paramBuffer.addParam(std::move(mParam));
1036     }
1037     else
1038     {
1039         ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
1040         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
1041                        &mParam.value);
1042         paramBuffer.addParam(std::move(mParam));
1043     }
1044 
1045     return CallCapture(angle::EntryPoint::GLMultMatrixx, std::move(paramBuffer));
1046 }
1047 
CaptureMultiTexCoord4f(const State & glState,bool isCallValid,GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)1048 CallCapture CaptureMultiTexCoord4f(const State &glState,
1049                                    bool isCallValid,
1050                                    GLenum target,
1051                                    GLfloat s,
1052                                    GLfloat t,
1053                                    GLfloat r,
1054                                    GLfloat q)
1055 {
1056     ParamBuffer paramBuffer;
1057 
1058     paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target);
1059     paramBuffer.addValueParam("s", ParamType::TGLfloat, s);
1060     paramBuffer.addValueParam("t", ParamType::TGLfloat, t);
1061     paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
1062     paramBuffer.addValueParam("q", ParamType::TGLfloat, q);
1063 
1064     return CallCapture(angle::EntryPoint::GLMultiTexCoord4f, std::move(paramBuffer));
1065 }
1066 
CaptureMultiTexCoord4x(const State & glState,bool isCallValid,GLenum texture,GLfixed s,GLfixed t,GLfixed r,GLfixed q)1067 CallCapture CaptureMultiTexCoord4x(const State &glState,
1068                                    bool isCallValid,
1069                                    GLenum texture,
1070                                    GLfixed s,
1071                                    GLfixed t,
1072                                    GLfixed r,
1073                                    GLfixed q)
1074 {
1075     ParamBuffer paramBuffer;
1076 
1077     paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture);
1078     paramBuffer.addValueParam("s", ParamType::TGLfixed, s);
1079     paramBuffer.addValueParam("t", ParamType::TGLfixed, t);
1080     paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
1081     paramBuffer.addValueParam("q", ParamType::TGLfixed, q);
1082 
1083     return CallCapture(angle::EntryPoint::GLMultiTexCoord4x, std::move(paramBuffer));
1084 }
1085 
CaptureNormal3f(const State & glState,bool isCallValid,GLfloat nx,GLfloat ny,GLfloat nz)1086 CallCapture CaptureNormal3f(const State &glState,
1087                             bool isCallValid,
1088                             GLfloat nx,
1089                             GLfloat ny,
1090                             GLfloat nz)
1091 {
1092     ParamBuffer paramBuffer;
1093 
1094     paramBuffer.addValueParam("nx", ParamType::TGLfloat, nx);
1095     paramBuffer.addValueParam("ny", ParamType::TGLfloat, ny);
1096     paramBuffer.addValueParam("nz", ParamType::TGLfloat, nz);
1097 
1098     return CallCapture(angle::EntryPoint::GLNormal3f, std::move(paramBuffer));
1099 }
1100 
CaptureNormal3x(const State & glState,bool isCallValid,GLfixed nx,GLfixed ny,GLfixed nz)1101 CallCapture CaptureNormal3x(const State &glState,
1102                             bool isCallValid,
1103                             GLfixed nx,
1104                             GLfixed ny,
1105                             GLfixed nz)
1106 {
1107     ParamBuffer paramBuffer;
1108 
1109     paramBuffer.addValueParam("nx", ParamType::TGLfixed, nx);
1110     paramBuffer.addValueParam("ny", ParamType::TGLfixed, ny);
1111     paramBuffer.addValueParam("nz", ParamType::TGLfixed, nz);
1112 
1113     return CallCapture(angle::EntryPoint::GLNormal3x, std::move(paramBuffer));
1114 }
1115 
CaptureNormalPointer(const State & glState,bool isCallValid,VertexAttribType typePacked,GLsizei stride,const void * pointer)1116 CallCapture CaptureNormalPointer(const State &glState,
1117                                  bool isCallValid,
1118                                  VertexAttribType typePacked,
1119                                  GLsizei stride,
1120                                  const void *pointer)
1121 {
1122     ParamBuffer paramBuffer;
1123 
1124     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
1125     paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
1126 
1127     if (isCallValid)
1128     {
1129         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
1130         InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
1131         CaptureNormalPointer_pointer(glState, isCallValid, typePacked, stride, pointer,
1132                                      &pointerParam);
1133         paramBuffer.addParam(std::move(pointerParam));
1134     }
1135     else
1136     {
1137         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
1138         InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1139                        &pointerParam.value);
1140         paramBuffer.addParam(std::move(pointerParam));
1141     }
1142 
1143     return CallCapture(angle::EntryPoint::GLNormalPointer, std::move(paramBuffer));
1144 }
1145 
CaptureOrthof(const State & glState,bool isCallValid,GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f)1146 CallCapture CaptureOrthof(const State &glState,
1147                           bool isCallValid,
1148                           GLfloat l,
1149                           GLfloat r,
1150                           GLfloat b,
1151                           GLfloat t,
1152                           GLfloat n,
1153                           GLfloat f)
1154 {
1155     ParamBuffer paramBuffer;
1156 
1157     paramBuffer.addValueParam("l", ParamType::TGLfloat, l);
1158     paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
1159     paramBuffer.addValueParam("b", ParamType::TGLfloat, b);
1160     paramBuffer.addValueParam("t", ParamType::TGLfloat, t);
1161     paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
1162     paramBuffer.addValueParam("f", ParamType::TGLfloat, f);
1163 
1164     return CallCapture(angle::EntryPoint::GLOrthof, std::move(paramBuffer));
1165 }
1166 
CaptureOrthox(const State & glState,bool isCallValid,GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f)1167 CallCapture CaptureOrthox(const State &glState,
1168                           bool isCallValid,
1169                           GLfixed l,
1170                           GLfixed r,
1171                           GLfixed b,
1172                           GLfixed t,
1173                           GLfixed n,
1174                           GLfixed f)
1175 {
1176     ParamBuffer paramBuffer;
1177 
1178     paramBuffer.addValueParam("l", ParamType::TGLfixed, l);
1179     paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
1180     paramBuffer.addValueParam("b", ParamType::TGLfixed, b);
1181     paramBuffer.addValueParam("t", ParamType::TGLfixed, t);
1182     paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
1183     paramBuffer.addValueParam("f", ParamType::TGLfixed, f);
1184 
1185     return CallCapture(angle::EntryPoint::GLOrthox, std::move(paramBuffer));
1186 }
1187 
CapturePointParameterf(const State & glState,bool isCallValid,PointParameter pnamePacked,GLfloat param)1188 CallCapture CapturePointParameterf(const State &glState,
1189                                    bool isCallValid,
1190                                    PointParameter pnamePacked,
1191                                    GLfloat param)
1192 {
1193     ParamBuffer paramBuffer;
1194 
1195     paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
1196     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
1197 
1198     return CallCapture(angle::EntryPoint::GLPointParameterf, std::move(paramBuffer));
1199 }
1200 
CapturePointParameterfv(const State & glState,bool isCallValid,PointParameter pnamePacked,const GLfloat * params)1201 CallCapture CapturePointParameterfv(const State &glState,
1202                                     bool isCallValid,
1203                                     PointParameter pnamePacked,
1204                                     const GLfloat *params)
1205 {
1206     ParamBuffer paramBuffer;
1207 
1208     paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
1209 
1210     if (isCallValid)
1211     {
1212         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1213         InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
1214         CapturePointParameterfv_params(glState, isCallValid, pnamePacked, params, &paramsParam);
1215         paramBuffer.addParam(std::move(paramsParam));
1216     }
1217     else
1218     {
1219         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1220         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
1221                        &paramsParam.value);
1222         paramBuffer.addParam(std::move(paramsParam));
1223     }
1224 
1225     return CallCapture(angle::EntryPoint::GLPointParameterfv, std::move(paramBuffer));
1226 }
1227 
CapturePointParameterx(const State & glState,bool isCallValid,PointParameter pnamePacked,GLfixed param)1228 CallCapture CapturePointParameterx(const State &glState,
1229                                    bool isCallValid,
1230                                    PointParameter pnamePacked,
1231                                    GLfixed param)
1232 {
1233     ParamBuffer paramBuffer;
1234 
1235     paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
1236     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
1237 
1238     return CallCapture(angle::EntryPoint::GLPointParameterx, std::move(paramBuffer));
1239 }
1240 
CapturePointParameterxv(const State & glState,bool isCallValid,PointParameter pnamePacked,const GLfixed * params)1241 CallCapture CapturePointParameterxv(const State &glState,
1242                                     bool isCallValid,
1243                                     PointParameter pnamePacked,
1244                                     const GLfixed *params)
1245 {
1246     ParamBuffer paramBuffer;
1247 
1248     paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
1249 
1250     if (isCallValid)
1251     {
1252         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
1253         InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
1254         CapturePointParameterxv_params(glState, isCallValid, pnamePacked, params, &paramsParam);
1255         paramBuffer.addParam(std::move(paramsParam));
1256     }
1257     else
1258     {
1259         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
1260         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
1261                        &paramsParam.value);
1262         paramBuffer.addParam(std::move(paramsParam));
1263     }
1264 
1265     return CallCapture(angle::EntryPoint::GLPointParameterxv, std::move(paramBuffer));
1266 }
1267 
CapturePointSize(const State & glState,bool isCallValid,GLfloat size)1268 CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size)
1269 {
1270     ParamBuffer paramBuffer;
1271 
1272     paramBuffer.addValueParam("size", ParamType::TGLfloat, size);
1273 
1274     return CallCapture(angle::EntryPoint::GLPointSize, std::move(paramBuffer));
1275 }
1276 
CapturePointSizex(const State & glState,bool isCallValid,GLfixed size)1277 CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size)
1278 {
1279     ParamBuffer paramBuffer;
1280 
1281     paramBuffer.addValueParam("size", ParamType::TGLfixed, size);
1282 
1283     return CallCapture(angle::EntryPoint::GLPointSizex, std::move(paramBuffer));
1284 }
1285 
CapturePolygonOffsetx(const State & glState,bool isCallValid,GLfixed factor,GLfixed units)1286 CallCapture CapturePolygonOffsetx(const State &glState,
1287                                   bool isCallValid,
1288                                   GLfixed factor,
1289                                   GLfixed units)
1290 {
1291     ParamBuffer paramBuffer;
1292 
1293     paramBuffer.addValueParam("factor", ParamType::TGLfixed, factor);
1294     paramBuffer.addValueParam("units", ParamType::TGLfixed, units);
1295 
1296     return CallCapture(angle::EntryPoint::GLPolygonOffsetx, std::move(paramBuffer));
1297 }
1298 
CapturePopMatrix(const State & glState,bool isCallValid)1299 CallCapture CapturePopMatrix(const State &glState, bool isCallValid)
1300 {
1301     ParamBuffer paramBuffer;
1302 
1303     return CallCapture(angle::EntryPoint::GLPopMatrix, std::move(paramBuffer));
1304 }
1305 
CapturePushMatrix(const State & glState,bool isCallValid)1306 CallCapture CapturePushMatrix(const State &glState, bool isCallValid)
1307 {
1308     ParamBuffer paramBuffer;
1309 
1310     return CallCapture(angle::EntryPoint::GLPushMatrix, std::move(paramBuffer));
1311 }
1312 
CaptureRotatef(const State & glState,bool isCallValid,GLfloat angle,GLfloat x,GLfloat y,GLfloat z)1313 CallCapture CaptureRotatef(const State &glState,
1314                            bool isCallValid,
1315                            GLfloat angle,
1316                            GLfloat x,
1317                            GLfloat y,
1318                            GLfloat z)
1319 {
1320     ParamBuffer paramBuffer;
1321 
1322     paramBuffer.addValueParam("angle", ParamType::TGLfloat, angle);
1323     paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
1324     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
1325     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
1326 
1327     return CallCapture(angle::EntryPoint::GLRotatef, std::move(paramBuffer));
1328 }
1329 
CaptureRotatex(const State & glState,bool isCallValid,GLfixed angle,GLfixed x,GLfixed y,GLfixed z)1330 CallCapture CaptureRotatex(const State &glState,
1331                            bool isCallValid,
1332                            GLfixed angle,
1333                            GLfixed x,
1334                            GLfixed y,
1335                            GLfixed z)
1336 {
1337     ParamBuffer paramBuffer;
1338 
1339     paramBuffer.addValueParam("angle", ParamType::TGLfixed, angle);
1340     paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
1341     paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
1342     paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
1343 
1344     return CallCapture(angle::EntryPoint::GLRotatex, std::move(paramBuffer));
1345 }
1346 
CaptureSampleCoveragex(const State & glState,bool isCallValid,GLclampx value,GLboolean invert)1347 CallCapture CaptureSampleCoveragex(const State &glState,
1348                                    bool isCallValid,
1349                                    GLclampx value,
1350                                    GLboolean invert)
1351 {
1352     ParamBuffer paramBuffer;
1353 
1354     paramBuffer.addValueParam("value", ParamType::TGLclampx, value);
1355     paramBuffer.addValueParam("invert", ParamType::TGLboolean, invert);
1356 
1357     return CallCapture(angle::EntryPoint::GLSampleCoveragex, std::move(paramBuffer));
1358 }
1359 
CaptureScalef(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z)1360 CallCapture CaptureScalef(const State &glState, bool isCallValid, GLfloat x, GLfloat y, GLfloat z)
1361 {
1362     ParamBuffer paramBuffer;
1363 
1364     paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
1365     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
1366     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
1367 
1368     return CallCapture(angle::EntryPoint::GLScalef, std::move(paramBuffer));
1369 }
1370 
CaptureScalex(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z)1371 CallCapture CaptureScalex(const State &glState, bool isCallValid, GLfixed x, GLfixed y, GLfixed z)
1372 {
1373     ParamBuffer paramBuffer;
1374 
1375     paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
1376     paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
1377     paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
1378 
1379     return CallCapture(angle::EntryPoint::GLScalex, std::move(paramBuffer));
1380 }
1381 
CaptureShadeModel(const State & glState,bool isCallValid,ShadingModel modePacked)1382 CallCapture CaptureShadeModel(const State &glState, bool isCallValid, ShadingModel modePacked)
1383 {
1384     ParamBuffer paramBuffer;
1385 
1386     paramBuffer.addValueParam("modePacked", ParamType::TShadingModel, modePacked);
1387 
1388     return CallCapture(angle::EntryPoint::GLShadeModel, std::move(paramBuffer));
1389 }
1390 
CaptureTexCoordPointer(const State & glState,bool isCallValid,GLint size,VertexAttribType typePacked,GLsizei stride,const void * pointer)1391 CallCapture CaptureTexCoordPointer(const State &glState,
1392                                    bool isCallValid,
1393                                    GLint size,
1394                                    VertexAttribType typePacked,
1395                                    GLsizei stride,
1396                                    const void *pointer)
1397 {
1398     ParamBuffer paramBuffer;
1399 
1400     paramBuffer.addValueParam("size", ParamType::TGLint, size);
1401     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
1402     paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
1403 
1404     if (isCallValid)
1405     {
1406         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
1407         InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
1408         CaptureTexCoordPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer,
1409                                        &pointerParam);
1410         paramBuffer.addParam(std::move(pointerParam));
1411     }
1412     else
1413     {
1414         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
1415         InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1416                        &pointerParam.value);
1417         paramBuffer.addParam(std::move(pointerParam));
1418     }
1419 
1420     return CallCapture(angle::EntryPoint::GLTexCoordPointer, std::move(paramBuffer));
1421 }
1422 
CaptureTexEnvf(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,GLfloat param)1423 CallCapture CaptureTexEnvf(const State &glState,
1424                            bool isCallValid,
1425                            TextureEnvTarget targetPacked,
1426                            TextureEnvParameter pnamePacked,
1427                            GLfloat param)
1428 {
1429     ParamBuffer paramBuffer;
1430 
1431     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
1432     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
1433     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
1434 
1435     return CallCapture(angle::EntryPoint::GLTexEnvf, std::move(paramBuffer));
1436 }
1437 
CaptureTexEnvfv(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,const GLfloat * params)1438 CallCapture CaptureTexEnvfv(const State &glState,
1439                             bool isCallValid,
1440                             TextureEnvTarget targetPacked,
1441                             TextureEnvParameter pnamePacked,
1442                             const GLfloat *params)
1443 {
1444     ParamBuffer paramBuffer;
1445 
1446     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
1447     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
1448 
1449     if (isCallValid)
1450     {
1451         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1452         InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
1453         CaptureTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params,
1454                                &paramsParam);
1455         paramBuffer.addParam(std::move(paramsParam));
1456     }
1457     else
1458     {
1459         ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1460         InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
1461                        &paramsParam.value);
1462         paramBuffer.addParam(std::move(paramsParam));
1463     }
1464 
1465     return CallCapture(angle::EntryPoint::GLTexEnvfv, std::move(paramBuffer));
1466 }
1467 
CaptureTexEnvi(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,GLint param)1468 CallCapture CaptureTexEnvi(const State &glState,
1469                            bool isCallValid,
1470                            TextureEnvTarget targetPacked,
1471                            TextureEnvParameter pnamePacked,
1472                            GLint param)
1473 {
1474     ParamBuffer paramBuffer;
1475 
1476     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
1477     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
1478     paramBuffer.addValueParam("param", ParamType::TGLint, param);
1479 
1480     return CallCapture(angle::EntryPoint::GLTexEnvi, std::move(paramBuffer));
1481 }
1482 
CaptureTexEnviv(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,const GLint * params)1483 CallCapture CaptureTexEnviv(const State &glState,
1484                             bool isCallValid,
1485                             TextureEnvTarget targetPacked,
1486                             TextureEnvParameter pnamePacked,
1487                             const GLint *params)
1488 {
1489     ParamBuffer paramBuffer;
1490 
1491     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
1492     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
1493 
1494     if (isCallValid)
1495     {
1496         ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
1497         InitParamValue(ParamType::TGLintConstPointer, params, &paramsParam.value);
1498         CaptureTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params,
1499                                &paramsParam);
1500         paramBuffer.addParam(std::move(paramsParam));
1501     }
1502     else
1503     {
1504         ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
1505         InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
1506                        &paramsParam.value);
1507         paramBuffer.addParam(std::move(paramsParam));
1508     }
1509 
1510     return CallCapture(angle::EntryPoint::GLTexEnviv, std::move(paramBuffer));
1511 }
1512 
CaptureTexEnvx(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,GLfixed param)1513 CallCapture CaptureTexEnvx(const State &glState,
1514                            bool isCallValid,
1515                            TextureEnvTarget targetPacked,
1516                            TextureEnvParameter pnamePacked,
1517                            GLfixed param)
1518 {
1519     ParamBuffer paramBuffer;
1520 
1521     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
1522     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
1523     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
1524 
1525     return CallCapture(angle::EntryPoint::GLTexEnvx, std::move(paramBuffer));
1526 }
1527 
CaptureTexEnvxv(const State & glState,bool isCallValid,TextureEnvTarget targetPacked,TextureEnvParameter pnamePacked,const GLfixed * params)1528 CallCapture CaptureTexEnvxv(const State &glState,
1529                             bool isCallValid,
1530                             TextureEnvTarget targetPacked,
1531                             TextureEnvParameter pnamePacked,
1532                             const GLfixed *params)
1533 {
1534     ParamBuffer paramBuffer;
1535 
1536     paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
1537     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
1538 
1539     if (isCallValid)
1540     {
1541         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
1542         InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
1543         CaptureTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params,
1544                                &paramsParam);
1545         paramBuffer.addParam(std::move(paramsParam));
1546     }
1547     else
1548     {
1549         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
1550         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
1551                        &paramsParam.value);
1552         paramBuffer.addParam(std::move(paramsParam));
1553     }
1554 
1555     return CallCapture(angle::EntryPoint::GLTexEnvxv, std::move(paramBuffer));
1556 }
1557 
CaptureTexParameterx(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLfixed param)1558 CallCapture CaptureTexParameterx(const State &glState,
1559                                  bool isCallValid,
1560                                  TextureType targetPacked,
1561                                  GLenum pname,
1562                                  GLfixed param)
1563 {
1564     ParamBuffer paramBuffer;
1565 
1566     paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1567     paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
1568     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
1569 
1570     return CallCapture(angle::EntryPoint::GLTexParameterx, std::move(paramBuffer));
1571 }
1572 
CaptureTexParameterxv(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLfixed * params)1573 CallCapture CaptureTexParameterxv(const State &glState,
1574                                   bool isCallValid,
1575                                   TextureType targetPacked,
1576                                   GLenum pname,
1577                                   const GLfixed *params)
1578 {
1579     ParamBuffer paramBuffer;
1580 
1581     paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1582     paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
1583 
1584     if (isCallValid)
1585     {
1586         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
1587         InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
1588         CaptureTexParameterxv_params(glState, isCallValid, targetPacked, pname, params,
1589                                      &paramsParam);
1590         paramBuffer.addParam(std::move(paramsParam));
1591     }
1592     else
1593     {
1594         ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
1595         InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
1596                        &paramsParam.value);
1597         paramBuffer.addParam(std::move(paramsParam));
1598     }
1599 
1600     return CallCapture(angle::EntryPoint::GLTexParameterxv, std::move(paramBuffer));
1601 }
1602 
CaptureTranslatef(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z)1603 CallCapture CaptureTranslatef(const State &glState,
1604                               bool isCallValid,
1605                               GLfloat x,
1606                               GLfloat y,
1607                               GLfloat z)
1608 {
1609     ParamBuffer paramBuffer;
1610 
1611     paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
1612     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
1613     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
1614 
1615     return CallCapture(angle::EntryPoint::GLTranslatef, std::move(paramBuffer));
1616 }
1617 
CaptureTranslatex(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z)1618 CallCapture CaptureTranslatex(const State &glState,
1619                               bool isCallValid,
1620                               GLfixed x,
1621                               GLfixed y,
1622                               GLfixed z)
1623 {
1624     ParamBuffer paramBuffer;
1625 
1626     paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
1627     paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
1628     paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
1629 
1630     return CallCapture(angle::EntryPoint::GLTranslatex, std::move(paramBuffer));
1631 }
1632 
CaptureVertexPointer(const State & glState,bool isCallValid,GLint size,VertexAttribType typePacked,GLsizei stride,const void * pointer)1633 CallCapture CaptureVertexPointer(const State &glState,
1634                                  bool isCallValid,
1635                                  GLint size,
1636                                  VertexAttribType typePacked,
1637                                  GLsizei stride,
1638                                  const void *pointer)
1639 {
1640     ParamBuffer paramBuffer;
1641 
1642     paramBuffer.addValueParam("size", ParamType::TGLint, size);
1643     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
1644     paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
1645 
1646     if (isCallValid)
1647     {
1648         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
1649         InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
1650         CaptureVertexPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer,
1651                                      &pointerParam);
1652         paramBuffer.addParam(std::move(pointerParam));
1653     }
1654     else
1655     {
1656         ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
1657         InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1658                        &pointerParam.value);
1659         paramBuffer.addParam(std::move(pointerParam));
1660     }
1661 
1662     return CallCapture(angle::EntryPoint::GLVertexPointer, std::move(paramBuffer));
1663 }
1664 
1665 }  // namespace gl
1666