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