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_ext_autogen.cpp:
9 // Capture functions for the OpenGL ES extension entry points.
10
11 #include "libANGLE/capture/capture_gles_ext_autogen.h"
12
13 #include "common/gl_enum_utils.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 #include "libANGLE/validationESEXT.h"
17
18 using namespace angle;
19
20 namespace gl
21 {
CaptureBeginPerfMonitorAMD(const State & glState,bool isCallValid,GLuint monitor)22 CallCapture CaptureBeginPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor)
23 {
24 ParamBuffer paramBuffer;
25
26 paramBuffer.addValueParam("monitor", ParamType::TGLuint, monitor);
27
28 return CallCapture(angle::EntryPoint::GLBeginPerfMonitorAMD, std::move(paramBuffer));
29 }
30
CaptureDeletePerfMonitorsAMD(const State & glState,bool isCallValid,GLsizei n,GLuint * monitors)31 CallCapture CaptureDeletePerfMonitorsAMD(const State &glState,
32 bool isCallValid,
33 GLsizei n,
34 GLuint *monitors)
35 {
36 ParamBuffer paramBuffer;
37
38 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
39
40 if (isCallValid)
41 {
42 ParamCapture monitorsParam("monitors", ParamType::TGLuintPointer);
43 InitParamValue(ParamType::TGLuintPointer, monitors, &monitorsParam.value);
44 CaptureDeletePerfMonitorsAMD_monitors(glState, isCallValid, n, monitors, &monitorsParam);
45 paramBuffer.addParam(std::move(monitorsParam));
46 }
47 else
48 {
49 ParamCapture monitorsParam("monitors", ParamType::TGLuintPointer);
50 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
51 &monitorsParam.value);
52 paramBuffer.addParam(std::move(monitorsParam));
53 }
54
55 return CallCapture(angle::EntryPoint::GLDeletePerfMonitorsAMD, std::move(paramBuffer));
56 }
57
CaptureEndPerfMonitorAMD(const State & glState,bool isCallValid,GLuint monitor)58 CallCapture CaptureEndPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor)
59 {
60 ParamBuffer paramBuffer;
61
62 paramBuffer.addValueParam("monitor", ParamType::TGLuint, monitor);
63
64 return CallCapture(angle::EntryPoint::GLEndPerfMonitorAMD, std::move(paramBuffer));
65 }
66
CaptureGenPerfMonitorsAMD(const State & glState,bool isCallValid,GLsizei n,GLuint * monitors)67 CallCapture CaptureGenPerfMonitorsAMD(const State &glState,
68 bool isCallValid,
69 GLsizei n,
70 GLuint *monitors)
71 {
72 ParamBuffer paramBuffer;
73
74 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
75
76 if (isCallValid)
77 {
78 ParamCapture monitorsParam("monitors", ParamType::TGLuintPointer);
79 InitParamValue(ParamType::TGLuintPointer, monitors, &monitorsParam.value);
80 CaptureGenPerfMonitorsAMD_monitors(glState, isCallValid, n, monitors, &monitorsParam);
81 paramBuffer.addParam(std::move(monitorsParam));
82 }
83 else
84 {
85 ParamCapture monitorsParam("monitors", ParamType::TGLuintPointer);
86 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
87 &monitorsParam.value);
88 paramBuffer.addParam(std::move(monitorsParam));
89 }
90
91 return CallCapture(angle::EntryPoint::GLGenPerfMonitorsAMD, std::move(paramBuffer));
92 }
93
CaptureGetPerfMonitorCounterDataAMD(const State & glState,bool isCallValid,GLuint monitor,GLenum pname,GLsizei dataSize,GLuint * data,GLint * bytesWritten)94 CallCapture CaptureGetPerfMonitorCounterDataAMD(const State &glState,
95 bool isCallValid,
96 GLuint monitor,
97 GLenum pname,
98 GLsizei dataSize,
99 GLuint *data,
100 GLint *bytesWritten)
101 {
102 ParamBuffer paramBuffer;
103
104 paramBuffer.addValueParam("monitor", ParamType::TGLuint, monitor);
105 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
106 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
107
108 if (isCallValid)
109 {
110 ParamCapture dataParam("data", ParamType::TGLuintPointer);
111 InitParamValue(ParamType::TGLuintPointer, data, &dataParam.value);
112 CaptureGetPerfMonitorCounterDataAMD_data(glState, isCallValid, monitor, pname, dataSize,
113 data, bytesWritten, &dataParam);
114 paramBuffer.addParam(std::move(dataParam));
115 }
116 else
117 {
118 ParamCapture dataParam("data", ParamType::TGLuintPointer);
119 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &dataParam.value);
120 paramBuffer.addParam(std::move(dataParam));
121 }
122
123 if (isCallValid)
124 {
125 ParamCapture bytesWrittenParam("bytesWritten", ParamType::TGLintPointer);
126 InitParamValue(ParamType::TGLintPointer, bytesWritten, &bytesWrittenParam.value);
127 CaptureGetPerfMonitorCounterDataAMD_bytesWritten(
128 glState, isCallValid, monitor, pname, dataSize, data, bytesWritten, &bytesWrittenParam);
129 paramBuffer.addParam(std::move(bytesWrittenParam));
130 }
131 else
132 {
133 ParamCapture bytesWrittenParam("bytesWritten", ParamType::TGLintPointer);
134 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
135 &bytesWrittenParam.value);
136 paramBuffer.addParam(std::move(bytesWrittenParam));
137 }
138
139 return CallCapture(angle::EntryPoint::GLGetPerfMonitorCounterDataAMD, std::move(paramBuffer));
140 }
141
CaptureGetPerfMonitorCounterInfoAMD(const State & glState,bool isCallValid,GLuint group,GLuint counter,GLenum pname,void * data)142 CallCapture CaptureGetPerfMonitorCounterInfoAMD(const State &glState,
143 bool isCallValid,
144 GLuint group,
145 GLuint counter,
146 GLenum pname,
147 void *data)
148 {
149 ParamBuffer paramBuffer;
150
151 paramBuffer.addValueParam("group", ParamType::TGLuint, group);
152 paramBuffer.addValueParam("counter", ParamType::TGLuint, counter);
153 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
154
155 if (isCallValid)
156 {
157 ParamCapture dataParam("data", ParamType::TvoidPointer);
158 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
159 CaptureGetPerfMonitorCounterInfoAMD_data(glState, isCallValid, group, counter, pname, data,
160 &dataParam);
161 paramBuffer.addParam(std::move(dataParam));
162 }
163 else
164 {
165 ParamCapture dataParam("data", ParamType::TvoidPointer);
166 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
167 paramBuffer.addParam(std::move(dataParam));
168 }
169
170 return CallCapture(angle::EntryPoint::GLGetPerfMonitorCounterInfoAMD, std::move(paramBuffer));
171 }
172
CaptureGetPerfMonitorCounterStringAMD(const State & glState,bool isCallValid,GLuint group,GLuint counter,GLsizei bufSize,GLsizei * length,GLchar * counterString)173 CallCapture CaptureGetPerfMonitorCounterStringAMD(const State &glState,
174 bool isCallValid,
175 GLuint group,
176 GLuint counter,
177 GLsizei bufSize,
178 GLsizei *length,
179 GLchar *counterString)
180 {
181 ParamBuffer paramBuffer;
182
183 paramBuffer.addValueParam("group", ParamType::TGLuint, group);
184 paramBuffer.addValueParam("counter", ParamType::TGLuint, counter);
185 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
186
187 if (isCallValid)
188 {
189 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
190 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
191 CaptureGetPerfMonitorCounterStringAMD_length(glState, isCallValid, group, counter, bufSize,
192 length, counterString, &lengthParam);
193 paramBuffer.addParam(std::move(lengthParam));
194 }
195 else
196 {
197 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
198 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
199 &lengthParam.value);
200 paramBuffer.addParam(std::move(lengthParam));
201 }
202
203 if (isCallValid)
204 {
205 ParamCapture counterStringParam("counterString", ParamType::TGLcharPointer);
206 InitParamValue(ParamType::TGLcharPointer, counterString, &counterStringParam.value);
207 CaptureGetPerfMonitorCounterStringAMD_counterString(glState, isCallValid, group, counter,
208 bufSize, length, counterString,
209 &counterStringParam);
210 paramBuffer.addParam(std::move(counterStringParam));
211 }
212 else
213 {
214 ParamCapture counterStringParam("counterString", ParamType::TGLcharPointer);
215 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
216 &counterStringParam.value);
217 paramBuffer.addParam(std::move(counterStringParam));
218 }
219
220 return CallCapture(angle::EntryPoint::GLGetPerfMonitorCounterStringAMD, std::move(paramBuffer));
221 }
222
CaptureGetPerfMonitorCountersAMD(const State & glState,bool isCallValid,GLuint group,GLint * numCounters,GLint * maxActiveCounters,GLsizei counterSize,GLuint * counters)223 CallCapture CaptureGetPerfMonitorCountersAMD(const State &glState,
224 bool isCallValid,
225 GLuint group,
226 GLint *numCounters,
227 GLint *maxActiveCounters,
228 GLsizei counterSize,
229 GLuint *counters)
230 {
231 ParamBuffer paramBuffer;
232
233 paramBuffer.addValueParam("group", ParamType::TGLuint, group);
234
235 if (isCallValid)
236 {
237 ParamCapture numCountersParam("numCounters", ParamType::TGLintPointer);
238 InitParamValue(ParamType::TGLintPointer, numCounters, &numCountersParam.value);
239 CaptureGetPerfMonitorCountersAMD_numCounters(glState, isCallValid, group, numCounters,
240 maxActiveCounters, counterSize, counters,
241 &numCountersParam);
242 paramBuffer.addParam(std::move(numCountersParam));
243 }
244 else
245 {
246 ParamCapture numCountersParam("numCounters", ParamType::TGLintPointer);
247 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
248 &numCountersParam.value);
249 paramBuffer.addParam(std::move(numCountersParam));
250 }
251
252 if (isCallValid)
253 {
254 ParamCapture maxActiveCountersParam("maxActiveCounters", ParamType::TGLintPointer);
255 InitParamValue(ParamType::TGLintPointer, maxActiveCounters, &maxActiveCountersParam.value);
256 CaptureGetPerfMonitorCountersAMD_maxActiveCounters(glState, isCallValid, group, numCounters,
257 maxActiveCounters, counterSize, counters,
258 &maxActiveCountersParam);
259 paramBuffer.addParam(std::move(maxActiveCountersParam));
260 }
261 else
262 {
263 ParamCapture maxActiveCountersParam("maxActiveCounters", ParamType::TGLintPointer);
264 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
265 &maxActiveCountersParam.value);
266 paramBuffer.addParam(std::move(maxActiveCountersParam));
267 }
268
269 paramBuffer.addValueParam("counterSize", ParamType::TGLsizei, counterSize);
270
271 if (isCallValid)
272 {
273 ParamCapture countersParam("counters", ParamType::TGLuintPointer);
274 InitParamValue(ParamType::TGLuintPointer, counters, &countersParam.value);
275 CaptureGetPerfMonitorCountersAMD_counters(glState, isCallValid, group, numCounters,
276 maxActiveCounters, counterSize, counters,
277 &countersParam);
278 paramBuffer.addParam(std::move(countersParam));
279 }
280 else
281 {
282 ParamCapture countersParam("counters", ParamType::TGLuintPointer);
283 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
284 &countersParam.value);
285 paramBuffer.addParam(std::move(countersParam));
286 }
287
288 return CallCapture(angle::EntryPoint::GLGetPerfMonitorCountersAMD, std::move(paramBuffer));
289 }
290
CaptureGetPerfMonitorGroupStringAMD(const State & glState,bool isCallValid,GLuint group,GLsizei bufSize,GLsizei * length,GLchar * groupString)291 CallCapture CaptureGetPerfMonitorGroupStringAMD(const State &glState,
292 bool isCallValid,
293 GLuint group,
294 GLsizei bufSize,
295 GLsizei *length,
296 GLchar *groupString)
297 {
298 ParamBuffer paramBuffer;
299
300 paramBuffer.addValueParam("group", ParamType::TGLuint, group);
301 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
302
303 if (isCallValid)
304 {
305 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
306 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
307 CaptureGetPerfMonitorGroupStringAMD_length(glState, isCallValid, group, bufSize, length,
308 groupString, &lengthParam);
309 paramBuffer.addParam(std::move(lengthParam));
310 }
311 else
312 {
313 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
314 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
315 &lengthParam.value);
316 paramBuffer.addParam(std::move(lengthParam));
317 }
318
319 if (isCallValid)
320 {
321 ParamCapture groupStringParam("groupString", ParamType::TGLcharPointer);
322 InitParamValue(ParamType::TGLcharPointer, groupString, &groupStringParam.value);
323 CaptureGetPerfMonitorGroupStringAMD_groupString(glState, isCallValid, group, bufSize,
324 length, groupString, &groupStringParam);
325 paramBuffer.addParam(std::move(groupStringParam));
326 }
327 else
328 {
329 ParamCapture groupStringParam("groupString", ParamType::TGLcharPointer);
330 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
331 &groupStringParam.value);
332 paramBuffer.addParam(std::move(groupStringParam));
333 }
334
335 return CallCapture(angle::EntryPoint::GLGetPerfMonitorGroupStringAMD, std::move(paramBuffer));
336 }
337
CaptureGetPerfMonitorGroupsAMD(const State & glState,bool isCallValid,GLint * numGroups,GLsizei groupsSize,GLuint * groups)338 CallCapture CaptureGetPerfMonitorGroupsAMD(const State &glState,
339 bool isCallValid,
340 GLint *numGroups,
341 GLsizei groupsSize,
342 GLuint *groups)
343 {
344 ParamBuffer paramBuffer;
345
346 if (isCallValid)
347 {
348 ParamCapture numGroupsParam("numGroups", ParamType::TGLintPointer);
349 InitParamValue(ParamType::TGLintPointer, numGroups, &numGroupsParam.value);
350 CaptureGetPerfMonitorGroupsAMD_numGroups(glState, isCallValid, numGroups, groupsSize,
351 groups, &numGroupsParam);
352 paramBuffer.addParam(std::move(numGroupsParam));
353 }
354 else
355 {
356 ParamCapture numGroupsParam("numGroups", ParamType::TGLintPointer);
357 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
358 &numGroupsParam.value);
359 paramBuffer.addParam(std::move(numGroupsParam));
360 }
361
362 paramBuffer.addValueParam("groupsSize", ParamType::TGLsizei, groupsSize);
363
364 if (isCallValid)
365 {
366 ParamCapture groupsParam("groups", ParamType::TGLuintPointer);
367 InitParamValue(ParamType::TGLuintPointer, groups, &groupsParam.value);
368 CaptureGetPerfMonitorGroupsAMD_groups(glState, isCallValid, numGroups, groupsSize, groups,
369 &groupsParam);
370 paramBuffer.addParam(std::move(groupsParam));
371 }
372 else
373 {
374 ParamCapture groupsParam("groups", ParamType::TGLuintPointer);
375 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
376 &groupsParam.value);
377 paramBuffer.addParam(std::move(groupsParam));
378 }
379
380 return CallCapture(angle::EntryPoint::GLGetPerfMonitorGroupsAMD, std::move(paramBuffer));
381 }
382
CaptureSelectPerfMonitorCountersAMD(const State & glState,bool isCallValid,GLuint monitor,GLboolean enable,GLuint group,GLint numCounters,GLuint * counterList)383 CallCapture CaptureSelectPerfMonitorCountersAMD(const State &glState,
384 bool isCallValid,
385 GLuint monitor,
386 GLboolean enable,
387 GLuint group,
388 GLint numCounters,
389 GLuint *counterList)
390 {
391 ParamBuffer paramBuffer;
392
393 paramBuffer.addValueParam("monitor", ParamType::TGLuint, monitor);
394 paramBuffer.addValueParam("enable", ParamType::TGLboolean, enable);
395 paramBuffer.addValueParam("group", ParamType::TGLuint, group);
396 paramBuffer.addValueParam("numCounters", ParamType::TGLint, numCounters);
397
398 if (isCallValid)
399 {
400 ParamCapture counterListParam("counterList", ParamType::TGLuintPointer);
401 InitParamValue(ParamType::TGLuintPointer, counterList, &counterListParam.value);
402 CaptureSelectPerfMonitorCountersAMD_counterList(glState, isCallValid, monitor, enable,
403 group, numCounters, counterList,
404 &counterListParam);
405 paramBuffer.addParam(std::move(counterListParam));
406 }
407 else
408 {
409 ParamCapture counterListParam("counterList", ParamType::TGLuintPointer);
410 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
411 &counterListParam.value);
412 paramBuffer.addParam(std::move(counterListParam));
413 }
414
415 return CallCapture(angle::EntryPoint::GLSelectPerfMonitorCountersAMD, std::move(paramBuffer));
416 }
417
CaptureDrawArraysInstancedBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei instanceCount,GLuint baseInstance)418 CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const State &glState,
419 bool isCallValid,
420 PrimitiveMode modePacked,
421 GLint first,
422 GLsizei count,
423 GLsizei instanceCount,
424 GLuint baseInstance)
425 {
426 ParamBuffer paramBuffer;
427
428 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
429 paramBuffer.addValueParam("first", ParamType::TGLint, first);
430 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
431 paramBuffer.addValueParam("instanceCount", ParamType::TGLsizei, instanceCount);
432 paramBuffer.addValueParam("baseInstance", ParamType::TGLuint, baseInstance);
433
434 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedBaseInstanceANGLE,
435 std::move(paramBuffer));
436 }
437
CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instanceCount,GLint baseVertex,GLuint baseInstance)438 CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(const State &glState,
439 bool isCallValid,
440 PrimitiveMode modePacked,
441 GLsizei count,
442 DrawElementsType typePacked,
443 const void *indices,
444 GLsizei instanceCount,
445 GLint baseVertex,
446 GLuint baseInstance)
447 {
448 ParamBuffer paramBuffer;
449
450 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
451 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
452 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
453
454 if (isCallValid)
455 {
456 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
457 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
458 CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
459 glState, isCallValid, modePacked, count, typePacked, indices, instanceCount, baseVertex,
460 baseInstance, &indicesParam);
461 paramBuffer.addParam(std::move(indicesParam));
462 }
463 else
464 {
465 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
466 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
467 &indicesParam.value);
468 paramBuffer.addParam(std::move(indicesParam));
469 }
470
471 paramBuffer.addValueParam("instanceCount", ParamType::TGLsizei, instanceCount);
472 paramBuffer.addValueParam("baseVertex", ParamType::TGLint, baseVertex);
473 paramBuffer.addValueParam("baseInstance", ParamType::TGLuint, baseInstance);
474
475 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
476 std::move(paramBuffer));
477 }
478
CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)479 CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState,
480 bool isCallValid,
481 PrimitiveMode modePacked,
482 const GLint *firsts,
483 const GLsizei *counts,
484 const GLsizei *instanceCounts,
485 const GLuint *baseInstances,
486 GLsizei drawcount)
487 {
488 ParamBuffer paramBuffer;
489
490 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
491
492 if (isCallValid)
493 {
494 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
495 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
496 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(
497 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
498 drawcount, &firstsParam);
499 paramBuffer.addParam(std::move(firstsParam));
500 }
501 else
502 {
503 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
504 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
505 &firstsParam.value);
506 paramBuffer.addParam(std::move(firstsParam));
507 }
508
509 if (isCallValid)
510 {
511 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
512 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
513 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(
514 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
515 drawcount, &countsParam);
516 paramBuffer.addParam(std::move(countsParam));
517 }
518 else
519 {
520 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
521 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
522 &countsParam.value);
523 paramBuffer.addParam(std::move(countsParam));
524 }
525
526 if (isCallValid)
527 {
528 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
529 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
530 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
531 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
532 drawcount, &instanceCountsParam);
533 paramBuffer.addParam(std::move(instanceCountsParam));
534 }
535 else
536 {
537 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
538 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
539 &instanceCountsParam.value);
540 paramBuffer.addParam(std::move(instanceCountsParam));
541 }
542
543 if (isCallValid)
544 {
545 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
546 InitParamValue(ParamType::TGLuintConstPointer, baseInstances, &baseInstancesParam.value);
547 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
548 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
549 drawcount, &baseInstancesParam);
550 paramBuffer.addParam(std::move(baseInstancesParam));
551 }
552 else
553 {
554 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
555 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
556 &baseInstancesParam.value);
557 paramBuffer.addParam(std::move(baseInstancesParam));
558 }
559
560 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
561
562 return CallCapture(angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
563 std::move(paramBuffer));
564 }
565
CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const void * const * indices,const GLsizei * instanceCounts,const GLint * baseVertices,const GLuint * baseInstances,GLsizei drawcount)566 CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
567 const State &glState,
568 bool isCallValid,
569 PrimitiveMode modePacked,
570 const GLsizei *counts,
571 DrawElementsType typePacked,
572 const void *const *indices,
573 const GLsizei *instanceCounts,
574 const GLint *baseVertices,
575 const GLuint *baseInstances,
576 GLsizei drawcount)
577 {
578 ParamBuffer paramBuffer;
579
580 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
581
582 if (isCallValid)
583 {
584 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
585 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
586 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
587 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
588 baseVertices, baseInstances, drawcount, &countsParam);
589 paramBuffer.addParam(std::move(countsParam));
590 }
591 else
592 {
593 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
594 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
595 &countsParam.value);
596 paramBuffer.addParam(std::move(countsParam));
597 }
598
599 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
600
601 if (isCallValid)
602 {
603 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
604 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
605 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
606 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
607 baseVertices, baseInstances, drawcount, &indicesParam);
608 paramBuffer.addParam(std::move(indicesParam));
609 }
610 else
611 {
612 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
613 InitParamValue(ParamType::TvoidConstPointerPointer,
614 static_cast<const void *const *>(nullptr), &indicesParam.value);
615 paramBuffer.addParam(std::move(indicesParam));
616 }
617
618 if (isCallValid)
619 {
620 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
621 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
622 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
623 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
624 baseVertices, baseInstances, drawcount, &instanceCountsParam);
625 paramBuffer.addParam(std::move(instanceCountsParam));
626 }
627 else
628 {
629 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
630 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
631 &instanceCountsParam.value);
632 paramBuffer.addParam(std::move(instanceCountsParam));
633 }
634
635 if (isCallValid)
636 {
637 ParamCapture baseVerticesParam("baseVertices", ParamType::TGLintConstPointer);
638 InitParamValue(ParamType::TGLintConstPointer, baseVertices, &baseVerticesParam.value);
639 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
640 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
641 baseVertices, baseInstances, drawcount, &baseVerticesParam);
642 paramBuffer.addParam(std::move(baseVerticesParam));
643 }
644 else
645 {
646 ParamCapture baseVerticesParam("baseVertices", ParamType::TGLintConstPointer);
647 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
648 &baseVerticesParam.value);
649 paramBuffer.addParam(std::move(baseVerticesParam));
650 }
651
652 if (isCallValid)
653 {
654 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
655 InitParamValue(ParamType::TGLuintConstPointer, baseInstances, &baseInstancesParam.value);
656 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
657 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
658 baseVertices, baseInstances, drawcount, &baseInstancesParam);
659 paramBuffer.addParam(std::move(baseInstancesParam));
660 }
661 else
662 {
663 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
664 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
665 &baseInstancesParam.value);
666 paramBuffer.addParam(std::move(baseInstancesParam));
667 }
668
669 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
670
671 return CallCapture(angle::EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
672 std::move(paramBuffer));
673 }
674
CaptureCopyTexture3DANGLE(const State & glState,bool isCallValid,TextureID sourceIdPacked,GLint sourceLevel,TextureTarget destTargetPacked,TextureID destIdPacked,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)675 CallCapture CaptureCopyTexture3DANGLE(const State &glState,
676 bool isCallValid,
677 TextureID sourceIdPacked,
678 GLint sourceLevel,
679 TextureTarget destTargetPacked,
680 TextureID destIdPacked,
681 GLint destLevel,
682 GLint internalFormat,
683 GLenum destType,
684 GLboolean unpackFlipY,
685 GLboolean unpackPremultiplyAlpha,
686 GLboolean unpackUnmultiplyAlpha)
687 {
688 ParamBuffer paramBuffer;
689
690 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
691 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
692 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
693 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
694 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
695 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
696 paramBuffer.addEnumParam("destType", GLESEnum::AllEnums, ParamType::TGLenum, destType);
697 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
698 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
699 unpackPremultiplyAlpha);
700 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
701 unpackUnmultiplyAlpha);
702
703 return CallCapture(angle::EntryPoint::GLCopyTexture3DANGLE, std::move(paramBuffer));
704 }
705
CaptureCopySubTexture3DANGLE(const State & glState,bool isCallValid,TextureID sourceIdPacked,GLint sourceLevel,TextureTarget destTargetPacked,TextureID destIdPacked,GLint destLevel,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLint z,GLint width,GLint height,GLint depth,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)706 CallCapture CaptureCopySubTexture3DANGLE(const State &glState,
707 bool isCallValid,
708 TextureID sourceIdPacked,
709 GLint sourceLevel,
710 TextureTarget destTargetPacked,
711 TextureID destIdPacked,
712 GLint destLevel,
713 GLint xoffset,
714 GLint yoffset,
715 GLint zoffset,
716 GLint x,
717 GLint y,
718 GLint z,
719 GLint width,
720 GLint height,
721 GLint depth,
722 GLboolean unpackFlipY,
723 GLboolean unpackPremultiplyAlpha,
724 GLboolean unpackUnmultiplyAlpha)
725 {
726 ParamBuffer paramBuffer;
727
728 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
729 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
730 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
731 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
732 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
733 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
734 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
735 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
736 paramBuffer.addValueParam("x", ParamType::TGLint, x);
737 paramBuffer.addValueParam("y", ParamType::TGLint, y);
738 paramBuffer.addValueParam("z", ParamType::TGLint, z);
739 paramBuffer.addValueParam("width", ParamType::TGLint, width);
740 paramBuffer.addValueParam("height", ParamType::TGLint, height);
741 paramBuffer.addValueParam("depth", ParamType::TGLint, depth);
742 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
743 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
744 unpackPremultiplyAlpha);
745 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
746 unpackUnmultiplyAlpha);
747
748 return CallCapture(angle::EntryPoint::GLCopySubTexture3DANGLE, std::move(paramBuffer));
749 }
750
CaptureBlitFramebufferANGLE(const State & glState,bool isCallValid,GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)751 CallCapture CaptureBlitFramebufferANGLE(const State &glState,
752 bool isCallValid,
753 GLint srcX0,
754 GLint srcY0,
755 GLint srcX1,
756 GLint srcY1,
757 GLint dstX0,
758 GLint dstY0,
759 GLint dstX1,
760 GLint dstY1,
761 GLbitfield mask,
762 GLenum filter)
763 {
764 ParamBuffer paramBuffer;
765
766 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
767 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
768 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
769 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
770 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
771 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
772 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
773 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
774 paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask);
775 paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter);
776
777 return CallCapture(angle::EntryPoint::GLBlitFramebufferANGLE, std::move(paramBuffer));
778 }
779
CaptureRenderbufferStorageMultisampleANGLE(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)780 CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
781 bool isCallValid,
782 GLenum target,
783 GLsizei samples,
784 GLenum internalformat,
785 GLsizei width,
786 GLsizei height)
787 {
788 ParamBuffer paramBuffer;
789
790 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
791 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
792 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
793 internalformat);
794 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
795 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
796
797 return CallCapture(angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE,
798 std::move(paramBuffer));
799 }
800
CaptureGetTexImageANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum format,GLenum type,void * pixels)801 CallCapture CaptureGetTexImageANGLE(const State &glState,
802 bool isCallValid,
803 TextureTarget targetPacked,
804 GLint level,
805 GLenum format,
806 GLenum type,
807 void *pixels)
808 {
809 ParamBuffer paramBuffer;
810
811 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
812 paramBuffer.addValueParam("level", ParamType::TGLint, level);
813 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
814 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
815
816 if (isCallValid)
817 {
818 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
819 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
820 CaptureGetTexImageANGLE_pixels(glState, isCallValid, targetPacked, level, format, type,
821 pixels, &pixelsParam);
822 paramBuffer.addParam(std::move(pixelsParam));
823 }
824 else
825 {
826 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
827 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
828 paramBuffer.addParam(std::move(pixelsParam));
829 }
830
831 return CallCapture(angle::EntryPoint::GLGetTexImageANGLE, std::move(paramBuffer));
832 }
833
CaptureGetCompressedTexImageANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,void * pixels)834 CallCapture CaptureGetCompressedTexImageANGLE(const State &glState,
835 bool isCallValid,
836 TextureTarget targetPacked,
837 GLint level,
838 void *pixels)
839 {
840 ParamBuffer paramBuffer;
841
842 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
843 paramBuffer.addValueParam("level", ParamType::TGLint, level);
844
845 if (isCallValid)
846 {
847 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
848 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
849 CaptureGetCompressedTexImageANGLE_pixels(glState, isCallValid, targetPacked, level, pixels,
850 &pixelsParam);
851 paramBuffer.addParam(std::move(pixelsParam));
852 }
853 else
854 {
855 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
856 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
857 paramBuffer.addParam(std::move(pixelsParam));
858 }
859
860 return CallCapture(angle::EntryPoint::GLGetCompressedTexImageANGLE, std::move(paramBuffer));
861 }
862
CaptureGetRenderbufferImageANGLE(const State & glState,bool isCallValid,GLenum target,GLenum format,GLenum type,void * pixels)863 CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
864 bool isCallValid,
865 GLenum target,
866 GLenum format,
867 GLenum type,
868 void *pixels)
869 {
870 ParamBuffer paramBuffer;
871
872 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
873 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
874 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
875
876 if (isCallValid)
877 {
878 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
879 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
880 CaptureGetRenderbufferImageANGLE_pixels(glState, isCallValid, target, format, type, pixels,
881 &pixelsParam);
882 paramBuffer.addParam(std::move(pixelsParam));
883 }
884 else
885 {
886 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
887 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
888 paramBuffer.addParam(std::move(pixelsParam));
889 }
890
891 return CallCapture(angle::EntryPoint::GLGetRenderbufferImageANGLE, std::move(paramBuffer));
892 }
893
CaptureGetTexLevelParameterivANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLint * params)894 CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
895 bool isCallValid,
896 TextureTarget targetPacked,
897 GLint level,
898 GLenum pname,
899 GLint *params)
900 {
901 ParamBuffer paramBuffer;
902
903 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
904 paramBuffer.addValueParam("level", ParamType::TGLint, level);
905 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
906
907 if (isCallValid)
908 {
909 ParamCapture paramsParam("params", ParamType::TGLintPointer);
910 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
911 CaptureGetTexLevelParameterivANGLE_params(glState, isCallValid, targetPacked, level, pname,
912 params, ¶msParam);
913 paramBuffer.addParam(std::move(paramsParam));
914 }
915 else
916 {
917 ParamCapture paramsParam("params", ParamType::TGLintPointer);
918 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
919 paramBuffer.addParam(std::move(paramsParam));
920 }
921
922 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterivANGLE, std::move(paramBuffer));
923 }
924
CaptureGetTexLevelParameterfvANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLfloat * params)925 CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
926 bool isCallValid,
927 TextureTarget targetPacked,
928 GLint level,
929 GLenum pname,
930 GLfloat *params)
931 {
932 ParamBuffer paramBuffer;
933
934 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
935 paramBuffer.addValueParam("level", ParamType::TGLint, level);
936 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
937
938 if (isCallValid)
939 {
940 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
941 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
942 CaptureGetTexLevelParameterfvANGLE_params(glState, isCallValid, targetPacked, level, pname,
943 params, ¶msParam);
944 paramBuffer.addParam(std::move(paramsParam));
945 }
946 else
947 {
948 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
949 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
950 ¶msParam.value);
951 paramBuffer.addParam(std::move(paramsParam));
952 }
953
954 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterfvANGLE, std::move(paramBuffer));
955 }
956
CaptureDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei primcount)957 CallCapture CaptureDrawArraysInstancedANGLE(const State &glState,
958 bool isCallValid,
959 PrimitiveMode modePacked,
960 GLint first,
961 GLsizei count,
962 GLsizei primcount)
963 {
964 ParamBuffer paramBuffer;
965
966 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
967 paramBuffer.addValueParam("first", ParamType::TGLint, first);
968 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
969 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
970
971 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedANGLE, std::move(paramBuffer));
972 }
973
CaptureDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)974 CallCapture CaptureDrawElementsInstancedANGLE(const State &glState,
975 bool isCallValid,
976 PrimitiveMode modePacked,
977 GLsizei count,
978 DrawElementsType typePacked,
979 const void *indices,
980 GLsizei primcount)
981 {
982 ParamBuffer paramBuffer;
983
984 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
985 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
986 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
987
988 if (isCallValid)
989 {
990 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
991 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
992 CaptureDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, count,
993 typePacked, indices, primcount, &indicesParam);
994 paramBuffer.addParam(std::move(indicesParam));
995 }
996 else
997 {
998 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
999 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1000 &indicesParam.value);
1001 paramBuffer.addParam(std::move(indicesParam));
1002 }
1003
1004 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
1005
1006 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedANGLE, std::move(paramBuffer));
1007 }
1008
CaptureVertexAttribDivisorANGLE(const State & glState,bool isCallValid,GLuint index,GLuint divisor)1009 CallCapture CaptureVertexAttribDivisorANGLE(const State &glState,
1010 bool isCallValid,
1011 GLuint index,
1012 GLuint divisor)
1013 {
1014 ParamBuffer paramBuffer;
1015
1016 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1017 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
1018
1019 return CallCapture(angle::EntryPoint::GLVertexAttribDivisorANGLE, std::move(paramBuffer));
1020 }
1021
CaptureLogicOpANGLE(const State & glState,bool isCallValid,LogicalOperation opcodePacked)1022 CallCapture CaptureLogicOpANGLE(const State &glState,
1023 bool isCallValid,
1024 LogicalOperation opcodePacked)
1025 {
1026 ParamBuffer paramBuffer;
1027
1028 paramBuffer.addValueParam("opcodePacked", ParamType::TLogicalOperation, opcodePacked);
1029
1030 return CallCapture(angle::EntryPoint::GLLogicOpANGLE, std::move(paramBuffer));
1031 }
1032
CaptureTexStorageMemFlags2DANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,MemoryObjectID memoryPacked,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1033 CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState,
1034 bool isCallValid,
1035 TextureType targetPacked,
1036 GLsizei levels,
1037 GLenum internalFormat,
1038 GLsizei width,
1039 GLsizei height,
1040 MemoryObjectID memoryPacked,
1041 GLuint64 offset,
1042 GLbitfield createFlags,
1043 GLbitfield usageFlags,
1044 const void *imageCreateInfoPNext)
1045 {
1046 ParamBuffer paramBuffer;
1047
1048 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1049 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
1050 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1051 internalFormat);
1052 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1053 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1054 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1055 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1056 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1057 createFlags);
1058 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1059
1060 if (isCallValid)
1061 {
1062 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1063 ParamType::TvoidConstPointer);
1064 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1065 &imageCreateInfoPNextParam.value);
1066 CaptureTexStorageMemFlags2DANGLE_imageCreateInfoPNext(
1067 glState, isCallValid, targetPacked, levels, internalFormat, width, height, memoryPacked,
1068 offset, createFlags, usageFlags, imageCreateInfoPNext, &imageCreateInfoPNextParam);
1069 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1070 }
1071 else
1072 {
1073 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1074 ParamType::TvoidConstPointer);
1075 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1076 &imageCreateInfoPNextParam.value);
1077 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1078 }
1079
1080 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags2DANGLE, std::move(paramBuffer));
1081 }
1082
CaptureTexStorageMemFlags2DMultisampleANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1083 CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState,
1084 bool isCallValid,
1085 TextureType targetPacked,
1086 GLsizei samples,
1087 GLenum internalFormat,
1088 GLsizei width,
1089 GLsizei height,
1090 GLboolean fixedSampleLocations,
1091 MemoryObjectID memoryPacked,
1092 GLuint64 offset,
1093 GLbitfield createFlags,
1094 GLbitfield usageFlags,
1095 const void *imageCreateInfoPNext)
1096 {
1097 ParamBuffer paramBuffer;
1098
1099 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1100 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
1101 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1102 internalFormat);
1103 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1104 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1105 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
1106 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1107 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1108 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1109 createFlags);
1110 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1111
1112 if (isCallValid)
1113 {
1114 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1115 ParamType::TvoidConstPointer);
1116 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1117 &imageCreateInfoPNextParam.value);
1118 CaptureTexStorageMemFlags2DMultisampleANGLE_imageCreateInfoPNext(
1119 glState, isCallValid, targetPacked, samples, internalFormat, width, height,
1120 fixedSampleLocations, memoryPacked, offset, createFlags, usageFlags,
1121 imageCreateInfoPNext, &imageCreateInfoPNextParam);
1122 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1123 }
1124 else
1125 {
1126 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1127 ParamType::TvoidConstPointer);
1128 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1129 &imageCreateInfoPNextParam.value);
1130 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1131 }
1132
1133 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE,
1134 std::move(paramBuffer));
1135 }
1136
CaptureTexStorageMemFlags3DANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,MemoryObjectID memoryPacked,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1137 CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState,
1138 bool isCallValid,
1139 TextureType targetPacked,
1140 GLsizei levels,
1141 GLenum internalFormat,
1142 GLsizei width,
1143 GLsizei height,
1144 GLsizei depth,
1145 MemoryObjectID memoryPacked,
1146 GLuint64 offset,
1147 GLbitfield createFlags,
1148 GLbitfield usageFlags,
1149 const void *imageCreateInfoPNext)
1150 {
1151 ParamBuffer paramBuffer;
1152
1153 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1154 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
1155 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1156 internalFormat);
1157 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1158 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1159 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1160 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1161 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1162 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1163 createFlags);
1164 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1165
1166 if (isCallValid)
1167 {
1168 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1169 ParamType::TvoidConstPointer);
1170 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1171 &imageCreateInfoPNextParam.value);
1172 CaptureTexStorageMemFlags3DANGLE_imageCreateInfoPNext(
1173 glState, isCallValid, targetPacked, levels, internalFormat, width, height, depth,
1174 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext,
1175 &imageCreateInfoPNextParam);
1176 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1177 }
1178 else
1179 {
1180 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1181 ParamType::TvoidConstPointer);
1182 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1183 &imageCreateInfoPNextParam.value);
1184 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1185 }
1186
1187 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags3DANGLE, std::move(paramBuffer));
1188 }
1189
CaptureTexStorageMemFlags3DMultisampleANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1190 CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState,
1191 bool isCallValid,
1192 TextureType targetPacked,
1193 GLsizei samples,
1194 GLenum internalFormat,
1195 GLsizei width,
1196 GLsizei height,
1197 GLsizei depth,
1198 GLboolean fixedSampleLocations,
1199 MemoryObjectID memoryPacked,
1200 GLuint64 offset,
1201 GLbitfield createFlags,
1202 GLbitfield usageFlags,
1203 const void *imageCreateInfoPNext)
1204 {
1205 ParamBuffer paramBuffer;
1206
1207 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1208 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
1209 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1210 internalFormat);
1211 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1212 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1213 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1214 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
1215 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1216 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1217 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1218 createFlags);
1219 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1220
1221 if (isCallValid)
1222 {
1223 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1224 ParamType::TvoidConstPointer);
1225 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1226 &imageCreateInfoPNextParam.value);
1227 CaptureTexStorageMemFlags3DMultisampleANGLE_imageCreateInfoPNext(
1228 glState, isCallValid, targetPacked, samples, internalFormat, width, height, depth,
1229 fixedSampleLocations, memoryPacked, offset, createFlags, usageFlags,
1230 imageCreateInfoPNext, &imageCreateInfoPNextParam);
1231 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1232 }
1233 else
1234 {
1235 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1236 ParamType::TvoidConstPointer);
1237 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1238 &imageCreateInfoPNextParam.value);
1239 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1240 }
1241
1242 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE,
1243 std::move(paramBuffer));
1244 }
1245
CaptureImportMemoryZirconHandleANGLE(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLuint handle)1246 CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
1247 bool isCallValid,
1248 MemoryObjectID memoryPacked,
1249 GLuint64 size,
1250 HandleType handleTypePacked,
1251 GLuint handle)
1252 {
1253 ParamBuffer paramBuffer;
1254
1255 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1256 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
1257 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
1258 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
1259
1260 return CallCapture(angle::EntryPoint::GLImportMemoryZirconHandleANGLE, std::move(paramBuffer));
1261 }
1262
CaptureMultiDrawArraysANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)1263 CallCapture CaptureMultiDrawArraysANGLE(const State &glState,
1264 bool isCallValid,
1265 PrimitiveMode modePacked,
1266 const GLint *firsts,
1267 const GLsizei *counts,
1268 GLsizei drawcount)
1269 {
1270 ParamBuffer paramBuffer;
1271
1272 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1273
1274 if (isCallValid)
1275 {
1276 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1277 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
1278 CaptureMultiDrawArraysANGLE_firsts(glState, isCallValid, modePacked, firsts, counts,
1279 drawcount, &firstsParam);
1280 paramBuffer.addParam(std::move(firstsParam));
1281 }
1282 else
1283 {
1284 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1285 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
1286 &firstsParam.value);
1287 paramBuffer.addParam(std::move(firstsParam));
1288 }
1289
1290 if (isCallValid)
1291 {
1292 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1293 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1294 CaptureMultiDrawArraysANGLE_counts(glState, isCallValid, modePacked, firsts, counts,
1295 drawcount, &countsParam);
1296 paramBuffer.addParam(std::move(countsParam));
1297 }
1298 else
1299 {
1300 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1301 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1302 &countsParam.value);
1303 paramBuffer.addParam(std::move(countsParam));
1304 }
1305
1306 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1307
1308 return CallCapture(angle::EntryPoint::GLMultiDrawArraysANGLE, std::move(paramBuffer));
1309 }
1310
CaptureMultiDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)1311 CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState,
1312 bool isCallValid,
1313 PrimitiveMode modePacked,
1314 const GLint *firsts,
1315 const GLsizei *counts,
1316 const GLsizei *instanceCounts,
1317 GLsizei drawcount)
1318 {
1319 ParamBuffer paramBuffer;
1320
1321 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1322
1323 if (isCallValid)
1324 {
1325 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1326 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
1327 CaptureMultiDrawArraysInstancedANGLE_firsts(glState, isCallValid, modePacked, firsts,
1328 counts, instanceCounts, drawcount,
1329 &firstsParam);
1330 paramBuffer.addParam(std::move(firstsParam));
1331 }
1332 else
1333 {
1334 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1335 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
1336 &firstsParam.value);
1337 paramBuffer.addParam(std::move(firstsParam));
1338 }
1339
1340 if (isCallValid)
1341 {
1342 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1343 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1344 CaptureMultiDrawArraysInstancedANGLE_counts(glState, isCallValid, modePacked, firsts,
1345 counts, instanceCounts, drawcount,
1346 &countsParam);
1347 paramBuffer.addParam(std::move(countsParam));
1348 }
1349 else
1350 {
1351 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1352 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1353 &countsParam.value);
1354 paramBuffer.addParam(std::move(countsParam));
1355 }
1356
1357 if (isCallValid)
1358 {
1359 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1360 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
1361 CaptureMultiDrawArraysInstancedANGLE_instanceCounts(glState, isCallValid, modePacked,
1362 firsts, counts, instanceCounts,
1363 drawcount, &instanceCountsParam);
1364 paramBuffer.addParam(std::move(instanceCountsParam));
1365 }
1366 else
1367 {
1368 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1369 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1370 &instanceCountsParam.value);
1371 paramBuffer.addParam(std::move(instanceCountsParam));
1372 }
1373
1374 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1375
1376 return CallCapture(angle::EntryPoint::GLMultiDrawArraysInstancedANGLE, std::move(paramBuffer));
1377 }
1378
CaptureMultiDrawElementsANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount)1379 CallCapture CaptureMultiDrawElementsANGLE(const State &glState,
1380 bool isCallValid,
1381 PrimitiveMode modePacked,
1382 const GLsizei *counts,
1383 DrawElementsType typePacked,
1384 const void *const *indices,
1385 GLsizei drawcount)
1386 {
1387 ParamBuffer paramBuffer;
1388
1389 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1390
1391 if (isCallValid)
1392 {
1393 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1394 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1395 CaptureMultiDrawElementsANGLE_counts(glState, isCallValid, modePacked, counts, typePacked,
1396 indices, drawcount, &countsParam);
1397 paramBuffer.addParam(std::move(countsParam));
1398 }
1399 else
1400 {
1401 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1402 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1403 &countsParam.value);
1404 paramBuffer.addParam(std::move(countsParam));
1405 }
1406
1407 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
1408
1409 if (isCallValid)
1410 {
1411 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1412 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
1413 CaptureMultiDrawElementsANGLE_indices(glState, isCallValid, modePacked, counts, typePacked,
1414 indices, drawcount, &indicesParam);
1415 paramBuffer.addParam(std::move(indicesParam));
1416 }
1417 else
1418 {
1419 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1420 InitParamValue(ParamType::TvoidConstPointerPointer,
1421 static_cast<const void *const *>(nullptr), &indicesParam.value);
1422 paramBuffer.addParam(std::move(indicesParam));
1423 }
1424
1425 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1426
1427 return CallCapture(angle::EntryPoint::GLMultiDrawElementsANGLE, std::move(paramBuffer));
1428 }
1429
CaptureMultiDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const void * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)1430 CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
1431 bool isCallValid,
1432 PrimitiveMode modePacked,
1433 const GLsizei *counts,
1434 DrawElementsType typePacked,
1435 const void *const *indices,
1436 const GLsizei *instanceCounts,
1437 GLsizei drawcount)
1438 {
1439 ParamBuffer paramBuffer;
1440
1441 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1442
1443 if (isCallValid)
1444 {
1445 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1446 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1447 CaptureMultiDrawElementsInstancedANGLE_counts(glState, isCallValid, modePacked, counts,
1448 typePacked, indices, instanceCounts,
1449 drawcount, &countsParam);
1450 paramBuffer.addParam(std::move(countsParam));
1451 }
1452 else
1453 {
1454 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1455 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1456 &countsParam.value);
1457 paramBuffer.addParam(std::move(countsParam));
1458 }
1459
1460 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
1461
1462 if (isCallValid)
1463 {
1464 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1465 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
1466 CaptureMultiDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, counts,
1467 typePacked, indices, instanceCounts,
1468 drawcount, &indicesParam);
1469 paramBuffer.addParam(std::move(indicesParam));
1470 }
1471 else
1472 {
1473 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1474 InitParamValue(ParamType::TvoidConstPointerPointer,
1475 static_cast<const void *const *>(nullptr), &indicesParam.value);
1476 paramBuffer.addParam(std::move(indicesParam));
1477 }
1478
1479 if (isCallValid)
1480 {
1481 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1482 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
1483 CaptureMultiDrawElementsInstancedANGLE_instanceCounts(
1484 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
1485 drawcount, &instanceCountsParam);
1486 paramBuffer.addParam(std::move(instanceCountsParam));
1487 }
1488 else
1489 {
1490 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1491 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1492 &instanceCountsParam.value);
1493 paramBuffer.addParam(std::move(instanceCountsParam));
1494 }
1495
1496 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1497
1498 return CallCapture(angle::EntryPoint::GLMultiDrawElementsInstancedANGLE,
1499 std::move(paramBuffer));
1500 }
1501
CapturePolygonModeANGLE(const State & glState,bool isCallValid,GLenum face,PolygonMode modePacked)1502 CallCapture CapturePolygonModeANGLE(const State &glState,
1503 bool isCallValid,
1504 GLenum face,
1505 PolygonMode modePacked)
1506 {
1507 ParamBuffer paramBuffer;
1508
1509 paramBuffer.addEnumParam("face", GLESEnum::TriangleFace, ParamType::TGLenum, face);
1510 paramBuffer.addValueParam("modePacked", ParamType::TPolygonMode, modePacked);
1511
1512 return CallCapture(angle::EntryPoint::GLPolygonModeANGLE, std::move(paramBuffer));
1513 }
1514
CaptureProvokingVertexANGLE(const State & glState,bool isCallValid,ProvokingVertexConvention provokeModePacked)1515 CallCapture CaptureProvokingVertexANGLE(const State &glState,
1516 bool isCallValid,
1517 ProvokingVertexConvention provokeModePacked)
1518 {
1519 ParamBuffer paramBuffer;
1520
1521 paramBuffer.addValueParam("provokeModePacked", ParamType::TProvokingVertexConvention,
1522 provokeModePacked);
1523
1524 return CallCapture(angle::EntryPoint::GLProvokingVertexANGLE, std::move(paramBuffer));
1525 }
1526
CaptureRequestExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)1527 CallCapture CaptureRequestExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
1528 {
1529 ParamBuffer paramBuffer;
1530
1531 if (isCallValid)
1532 {
1533 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1534 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
1535 CaptureRequestExtensionANGLE_name(glState, isCallValid, name, &nameParam);
1536 paramBuffer.addParam(std::move(nameParam));
1537 }
1538 else
1539 {
1540 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1541 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
1542 &nameParam.value);
1543 paramBuffer.addParam(std::move(nameParam));
1544 }
1545
1546 return CallCapture(angle::EntryPoint::GLRequestExtensionANGLE, std::move(paramBuffer));
1547 }
1548
CaptureDisableExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)1549 CallCapture CaptureDisableExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
1550 {
1551 ParamBuffer paramBuffer;
1552
1553 if (isCallValid)
1554 {
1555 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1556 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
1557 CaptureDisableExtensionANGLE_name(glState, isCallValid, name, &nameParam);
1558 paramBuffer.addParam(std::move(nameParam));
1559 }
1560 else
1561 {
1562 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1563 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
1564 &nameParam.value);
1565 paramBuffer.addParam(std::move(nameParam));
1566 }
1567
1568 return CallCapture(angle::EntryPoint::GLDisableExtensionANGLE, std::move(paramBuffer));
1569 }
1570
CaptureGetBooleanvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)1571 CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
1572 bool isCallValid,
1573 GLenum pname,
1574 GLsizei bufSize,
1575 GLsizei *length,
1576 GLboolean *params)
1577 {
1578 ParamBuffer paramBuffer;
1579
1580 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1581 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1582
1583 if (isCallValid)
1584 {
1585 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1586 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1587 CaptureGetBooleanvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
1588 &lengthParam);
1589 paramBuffer.addParam(std::move(lengthParam));
1590 }
1591 else
1592 {
1593 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1594 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1595 &lengthParam.value);
1596 paramBuffer.addParam(std::move(lengthParam));
1597 }
1598
1599 if (isCallValid)
1600 {
1601 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
1602 InitParamValue(ParamType::TGLbooleanPointer, params, ¶msParam.value);
1603 CaptureGetBooleanvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
1604 ¶msParam);
1605 paramBuffer.addParam(std::move(paramsParam));
1606 }
1607 else
1608 {
1609 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
1610 InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
1611 ¶msParam.value);
1612 paramBuffer.addParam(std::move(paramsParam));
1613 }
1614
1615 return CallCapture(angle::EntryPoint::GLGetBooleanvRobustANGLE, std::move(paramBuffer));
1616 }
1617
CaptureGetBufferParameterivRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1618 CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
1619 bool isCallValid,
1620 BufferBinding targetPacked,
1621 GLenum pname,
1622 GLsizei bufSize,
1623 GLsizei *length,
1624 GLint *params)
1625 {
1626 ParamBuffer paramBuffer;
1627
1628 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1629 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1630 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1631
1632 if (isCallValid)
1633 {
1634 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1635 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1636 CaptureGetBufferParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1637 bufSize, length, params, &lengthParam);
1638 paramBuffer.addParam(std::move(lengthParam));
1639 }
1640 else
1641 {
1642 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1643 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1644 &lengthParam.value);
1645 paramBuffer.addParam(std::move(lengthParam));
1646 }
1647
1648 if (isCallValid)
1649 {
1650 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1651 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1652 CaptureGetBufferParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1653 bufSize, length, params, ¶msParam);
1654 paramBuffer.addParam(std::move(paramsParam));
1655 }
1656 else
1657 {
1658 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1659 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1660 paramBuffer.addParam(std::move(paramsParam));
1661 }
1662
1663 return CallCapture(angle::EntryPoint::GLGetBufferParameterivRobustANGLE,
1664 std::move(paramBuffer));
1665 }
1666
CaptureGetFloatvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1667 CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
1668 bool isCallValid,
1669 GLenum pname,
1670 GLsizei bufSize,
1671 GLsizei *length,
1672 GLfloat *params)
1673 {
1674 ParamBuffer paramBuffer;
1675
1676 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1677 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1678
1679 if (isCallValid)
1680 {
1681 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1682 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1683 CaptureGetFloatvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
1684 &lengthParam);
1685 paramBuffer.addParam(std::move(lengthParam));
1686 }
1687 else
1688 {
1689 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1690 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1691 &lengthParam.value);
1692 paramBuffer.addParam(std::move(lengthParam));
1693 }
1694
1695 if (isCallValid)
1696 {
1697 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1698 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1699 CaptureGetFloatvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
1700 ¶msParam);
1701 paramBuffer.addParam(std::move(paramsParam));
1702 }
1703 else
1704 {
1705 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1706 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1707 ¶msParam.value);
1708 paramBuffer.addParam(std::move(paramsParam));
1709 }
1710
1711 return CallCapture(angle::EntryPoint::GLGetFloatvRobustANGLE, std::move(paramBuffer));
1712 }
1713
CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1714 CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
1715 bool isCallValid,
1716 GLenum target,
1717 GLenum attachment,
1718 GLenum pname,
1719 GLsizei bufSize,
1720 GLsizei *length,
1721 GLint *params)
1722 {
1723 ParamBuffer paramBuffer;
1724
1725 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
1726 paramBuffer.addEnumParam("attachment", GLESEnum::AllEnums, ParamType::TGLenum, attachment);
1727 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1728 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1729
1730 if (isCallValid)
1731 {
1732 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1733 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1734 CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
1735 glState, isCallValid, target, attachment, pname, bufSize, length, params, &lengthParam);
1736 paramBuffer.addParam(std::move(lengthParam));
1737 }
1738 else
1739 {
1740 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1741 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1742 &lengthParam.value);
1743 paramBuffer.addParam(std::move(lengthParam));
1744 }
1745
1746 if (isCallValid)
1747 {
1748 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1749 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1750 CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
1751 glState, isCallValid, target, attachment, pname, bufSize, length, params, ¶msParam);
1752 paramBuffer.addParam(std::move(paramsParam));
1753 }
1754 else
1755 {
1756 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1757 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1758 paramBuffer.addParam(std::move(paramsParam));
1759 }
1760
1761 return CallCapture(angle::EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
1762 std::move(paramBuffer));
1763 }
1764
CaptureGetIntegervRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)1765 CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
1766 bool isCallValid,
1767 GLenum pname,
1768 GLsizei bufSize,
1769 GLsizei *length,
1770 GLint *data)
1771 {
1772 ParamBuffer paramBuffer;
1773
1774 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1775 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1776
1777 if (isCallValid)
1778 {
1779 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1780 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1781 CaptureGetIntegervRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
1782 &lengthParam);
1783 paramBuffer.addParam(std::move(lengthParam));
1784 }
1785 else
1786 {
1787 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1788 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1789 &lengthParam.value);
1790 paramBuffer.addParam(std::move(lengthParam));
1791 }
1792
1793 if (isCallValid)
1794 {
1795 ParamCapture dataParam("data", ParamType::TGLintPointer);
1796 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
1797 CaptureGetIntegervRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
1798 &dataParam);
1799 paramBuffer.addParam(std::move(dataParam));
1800 }
1801 else
1802 {
1803 ParamCapture dataParam("data", ParamType::TGLintPointer);
1804 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
1805 paramBuffer.addParam(std::move(dataParam));
1806 }
1807
1808 return CallCapture(angle::EntryPoint::GLGetIntegervRobustANGLE, std::move(paramBuffer));
1809 }
1810
CaptureGetProgramivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1811 CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
1812 bool isCallValid,
1813 ShaderProgramID programPacked,
1814 GLenum pname,
1815 GLsizei bufSize,
1816 GLsizei *length,
1817 GLint *params)
1818 {
1819 ParamBuffer paramBuffer;
1820
1821 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1822 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1823 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1824
1825 if (isCallValid)
1826 {
1827 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1828 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1829 CaptureGetProgramivRobustANGLE_length(glState, isCallValid, programPacked, pname, bufSize,
1830 length, params, &lengthParam);
1831 paramBuffer.addParam(std::move(lengthParam));
1832 }
1833 else
1834 {
1835 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1836 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1837 &lengthParam.value);
1838 paramBuffer.addParam(std::move(lengthParam));
1839 }
1840
1841 if (isCallValid)
1842 {
1843 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1844 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1845 CaptureGetProgramivRobustANGLE_params(glState, isCallValid, programPacked, pname, bufSize,
1846 length, params, ¶msParam);
1847 paramBuffer.addParam(std::move(paramsParam));
1848 }
1849 else
1850 {
1851 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1852 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1853 paramBuffer.addParam(std::move(paramsParam));
1854 }
1855
1856 return CallCapture(angle::EntryPoint::GLGetProgramivRobustANGLE, std::move(paramBuffer));
1857 }
1858
CaptureGetRenderbufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1859 CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
1860 bool isCallValid,
1861 GLenum target,
1862 GLenum pname,
1863 GLsizei bufSize,
1864 GLsizei *length,
1865 GLint *params)
1866 {
1867 ParamBuffer paramBuffer;
1868
1869 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
1870 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1871 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1872
1873 if (isCallValid)
1874 {
1875 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1876 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1877 CaptureGetRenderbufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
1878 bufSize, length, params, &lengthParam);
1879 paramBuffer.addParam(std::move(lengthParam));
1880 }
1881 else
1882 {
1883 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1884 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1885 &lengthParam.value);
1886 paramBuffer.addParam(std::move(lengthParam));
1887 }
1888
1889 if (isCallValid)
1890 {
1891 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1892 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1893 CaptureGetRenderbufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
1894 bufSize, length, params, ¶msParam);
1895 paramBuffer.addParam(std::move(paramsParam));
1896 }
1897 else
1898 {
1899 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1900 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1901 paramBuffer.addParam(std::move(paramsParam));
1902 }
1903
1904 return CallCapture(angle::EntryPoint::GLGetRenderbufferParameterivRobustANGLE,
1905 std::move(paramBuffer));
1906 }
1907
CaptureGetShaderivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1908 CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
1909 bool isCallValid,
1910 ShaderProgramID shaderPacked,
1911 GLenum pname,
1912 GLsizei bufSize,
1913 GLsizei *length,
1914 GLint *params)
1915 {
1916 ParamBuffer paramBuffer;
1917
1918 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
1919 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1920 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1921
1922 if (isCallValid)
1923 {
1924 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1925 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1926 CaptureGetShaderivRobustANGLE_length(glState, isCallValid, shaderPacked, pname, bufSize,
1927 length, params, &lengthParam);
1928 paramBuffer.addParam(std::move(lengthParam));
1929 }
1930 else
1931 {
1932 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1933 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1934 &lengthParam.value);
1935 paramBuffer.addParam(std::move(lengthParam));
1936 }
1937
1938 if (isCallValid)
1939 {
1940 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1941 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1942 CaptureGetShaderivRobustANGLE_params(glState, isCallValid, shaderPacked, pname, bufSize,
1943 length, params, ¶msParam);
1944 paramBuffer.addParam(std::move(paramsParam));
1945 }
1946 else
1947 {
1948 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1949 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1950 paramBuffer.addParam(std::move(paramsParam));
1951 }
1952
1953 return CallCapture(angle::EntryPoint::GLGetShaderivRobustANGLE, std::move(paramBuffer));
1954 }
1955
CaptureGetTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1956 CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
1957 bool isCallValid,
1958 TextureType targetPacked,
1959 GLenum pname,
1960 GLsizei bufSize,
1961 GLsizei *length,
1962 GLfloat *params)
1963 {
1964 ParamBuffer paramBuffer;
1965
1966 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1967 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1968 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1969
1970 if (isCallValid)
1971 {
1972 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1973 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1974 CaptureGetTexParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1975 bufSize, length, params, &lengthParam);
1976 paramBuffer.addParam(std::move(lengthParam));
1977 }
1978 else
1979 {
1980 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1981 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1982 &lengthParam.value);
1983 paramBuffer.addParam(std::move(lengthParam));
1984 }
1985
1986 if (isCallValid)
1987 {
1988 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1989 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1990 CaptureGetTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1991 bufSize, length, params, ¶msParam);
1992 paramBuffer.addParam(std::move(paramsParam));
1993 }
1994 else
1995 {
1996 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1997 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1998 ¶msParam.value);
1999 paramBuffer.addParam(std::move(paramsParam));
2000 }
2001
2002 return CallCapture(angle::EntryPoint::GLGetTexParameterfvRobustANGLE, std::move(paramBuffer));
2003 }
2004
CaptureGetTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2005 CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
2006 bool isCallValid,
2007 TextureType targetPacked,
2008 GLenum pname,
2009 GLsizei bufSize,
2010 GLsizei *length,
2011 GLint *params)
2012 {
2013 ParamBuffer paramBuffer;
2014
2015 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2016 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2017 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2018
2019 if (isCallValid)
2020 {
2021 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2022 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2023 CaptureGetTexParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2024 bufSize, length, params, &lengthParam);
2025 paramBuffer.addParam(std::move(lengthParam));
2026 }
2027 else
2028 {
2029 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2030 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2031 &lengthParam.value);
2032 paramBuffer.addParam(std::move(lengthParam));
2033 }
2034
2035 if (isCallValid)
2036 {
2037 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2038 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2039 CaptureGetTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
2040 bufSize, length, params, ¶msParam);
2041 paramBuffer.addParam(std::move(paramsParam));
2042 }
2043 else
2044 {
2045 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2046 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2047 paramBuffer.addParam(std::move(paramsParam));
2048 }
2049
2050 return CallCapture(angle::EntryPoint::GLGetTexParameterivRobustANGLE, std::move(paramBuffer));
2051 }
2052
CaptureGetUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)2053 CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
2054 bool isCallValid,
2055 ShaderProgramID programPacked,
2056 UniformLocation locationPacked,
2057 GLsizei bufSize,
2058 GLsizei *length,
2059 GLfloat *params)
2060 {
2061 ParamBuffer paramBuffer;
2062
2063 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2064 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2065 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2066
2067 if (isCallValid)
2068 {
2069 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2070 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2071 CaptureGetUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2072 bufSize, length, params, &lengthParam);
2073 paramBuffer.addParam(std::move(lengthParam));
2074 }
2075 else
2076 {
2077 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2078 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2079 &lengthParam.value);
2080 paramBuffer.addParam(std::move(lengthParam));
2081 }
2082
2083 if (isCallValid)
2084 {
2085 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2086 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2087 CaptureGetUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2088 bufSize, length, params, ¶msParam);
2089 paramBuffer.addParam(std::move(paramsParam));
2090 }
2091 else
2092 {
2093 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2094 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
2095 ¶msParam.value);
2096 paramBuffer.addParam(std::move(paramsParam));
2097 }
2098
2099 return CallCapture(angle::EntryPoint::GLGetUniformfvRobustANGLE, std::move(paramBuffer));
2100 }
2101
CaptureGetUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)2102 CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
2103 bool isCallValid,
2104 ShaderProgramID programPacked,
2105 UniformLocation locationPacked,
2106 GLsizei bufSize,
2107 GLsizei *length,
2108 GLint *params)
2109 {
2110 ParamBuffer paramBuffer;
2111
2112 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2113 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2114 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2115
2116 if (isCallValid)
2117 {
2118 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2119 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2120 CaptureGetUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2121 bufSize, length, params, &lengthParam);
2122 paramBuffer.addParam(std::move(lengthParam));
2123 }
2124 else
2125 {
2126 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2127 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2128 &lengthParam.value);
2129 paramBuffer.addParam(std::move(lengthParam));
2130 }
2131
2132 if (isCallValid)
2133 {
2134 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2135 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2136 CaptureGetUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2137 bufSize, length, params, ¶msParam);
2138 paramBuffer.addParam(std::move(paramsParam));
2139 }
2140 else
2141 {
2142 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2143 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2144 paramBuffer.addParam(std::move(paramsParam));
2145 }
2146
2147 return CallCapture(angle::EntryPoint::GLGetUniformivRobustANGLE, std::move(paramBuffer));
2148 }
2149
CaptureGetVertexAttribfvRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2150 CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
2151 bool isCallValid,
2152 GLuint index,
2153 GLenum pname,
2154 GLsizei bufSize,
2155 GLsizei *length,
2156 GLfloat *params)
2157 {
2158 ParamBuffer paramBuffer;
2159
2160 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2161 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2162 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2163
2164 if (isCallValid)
2165 {
2166 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2167 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2168 CaptureGetVertexAttribfvRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
2169 length, params, &lengthParam);
2170 paramBuffer.addParam(std::move(lengthParam));
2171 }
2172 else
2173 {
2174 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2175 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2176 &lengthParam.value);
2177 paramBuffer.addParam(std::move(lengthParam));
2178 }
2179
2180 if (isCallValid)
2181 {
2182 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2183 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2184 CaptureGetVertexAttribfvRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
2185 length, params, ¶msParam);
2186 paramBuffer.addParam(std::move(paramsParam));
2187 }
2188 else
2189 {
2190 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2191 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
2192 ¶msParam.value);
2193 paramBuffer.addParam(std::move(paramsParam));
2194 }
2195
2196 return CallCapture(angle::EntryPoint::GLGetVertexAttribfvRobustANGLE, std::move(paramBuffer));
2197 }
2198
CaptureGetVertexAttribivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2199 CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
2200 bool isCallValid,
2201 GLuint index,
2202 GLenum pname,
2203 GLsizei bufSize,
2204 GLsizei *length,
2205 GLint *params)
2206 {
2207 ParamBuffer paramBuffer;
2208
2209 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2210 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2211 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2212
2213 if (isCallValid)
2214 {
2215 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2216 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2217 CaptureGetVertexAttribivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
2218 length, params, &lengthParam);
2219 paramBuffer.addParam(std::move(lengthParam));
2220 }
2221 else
2222 {
2223 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2224 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2225 &lengthParam.value);
2226 paramBuffer.addParam(std::move(lengthParam));
2227 }
2228
2229 if (isCallValid)
2230 {
2231 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2232 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2233 CaptureGetVertexAttribivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
2234 length, params, ¶msParam);
2235 paramBuffer.addParam(std::move(paramsParam));
2236 }
2237 else
2238 {
2239 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2240 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2241 paramBuffer.addParam(std::move(paramsParam));
2242 }
2243
2244 return CallCapture(angle::EntryPoint::GLGetVertexAttribivRobustANGLE, std::move(paramBuffer));
2245 }
2246
CaptureGetVertexAttribPointervRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)2247 CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
2248 bool isCallValid,
2249 GLuint index,
2250 GLenum pname,
2251 GLsizei bufSize,
2252 GLsizei *length,
2253 void **pointer)
2254 {
2255 ParamBuffer paramBuffer;
2256
2257 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2258 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2259 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2260
2261 if (isCallValid)
2262 {
2263 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2264 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2265 CaptureGetVertexAttribPointervRobustANGLE_length(glState, isCallValid, index, pname,
2266 bufSize, length, pointer, &lengthParam);
2267 paramBuffer.addParam(std::move(lengthParam));
2268 }
2269 else
2270 {
2271 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2272 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2273 &lengthParam.value);
2274 paramBuffer.addParam(std::move(lengthParam));
2275 }
2276
2277 if (isCallValid)
2278 {
2279 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
2280 InitParamValue(ParamType::TvoidPointerPointer, pointer, &pointerParam.value);
2281 CaptureGetVertexAttribPointervRobustANGLE_pointer(glState, isCallValid, index, pname,
2282 bufSize, length, pointer, &pointerParam);
2283 paramBuffer.addParam(std::move(pointerParam));
2284 }
2285 else
2286 {
2287 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
2288 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
2289 &pointerParam.value);
2290 paramBuffer.addParam(std::move(pointerParam));
2291 }
2292
2293 return CallCapture(angle::EntryPoint::GLGetVertexAttribPointervRobustANGLE,
2294 std::move(paramBuffer));
2295 }
2296
CaptureReadPixelsRobustANGLE(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * pixels)2297 CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
2298 bool isCallValid,
2299 GLint x,
2300 GLint y,
2301 GLsizei width,
2302 GLsizei height,
2303 GLenum format,
2304 GLenum type,
2305 GLsizei bufSize,
2306 GLsizei *length,
2307 GLsizei *columns,
2308 GLsizei *rows,
2309 void *pixels)
2310 {
2311 ParamBuffer paramBuffer;
2312
2313 paramBuffer.addValueParam("x", ParamType::TGLint, x);
2314 paramBuffer.addValueParam("y", ParamType::TGLint, y);
2315 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2316 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2317 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2318 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2319 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2320
2321 if (isCallValid)
2322 {
2323 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2324 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2325 CaptureReadPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format, type,
2326 bufSize, length, columns, rows, pixels, &lengthParam);
2327 paramBuffer.addParam(std::move(lengthParam));
2328 }
2329 else
2330 {
2331 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2332 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2333 &lengthParam.value);
2334 paramBuffer.addParam(std::move(lengthParam));
2335 }
2336
2337 if (isCallValid)
2338 {
2339 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
2340 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
2341 CaptureReadPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format,
2342 type, bufSize, length, columns, rows, pixels,
2343 &columnsParam);
2344 paramBuffer.addParam(std::move(columnsParam));
2345 }
2346 else
2347 {
2348 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
2349 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2350 &columnsParam.value);
2351 paramBuffer.addParam(std::move(columnsParam));
2352 }
2353
2354 if (isCallValid)
2355 {
2356 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
2357 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
2358 CaptureReadPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
2359 bufSize, length, columns, rows, pixels, &rowsParam);
2360 paramBuffer.addParam(std::move(rowsParam));
2361 }
2362 else
2363 {
2364 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
2365 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2366 &rowsParam.value);
2367 paramBuffer.addParam(std::move(rowsParam));
2368 }
2369
2370 if (isCallValid)
2371 {
2372 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
2373 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
2374 CaptureReadPixelsRobustANGLE_pixels(glState, isCallValid, x, y, width, height, format, type,
2375 bufSize, length, columns, rows, pixels, &pixelsParam);
2376 paramBuffer.addParam(std::move(pixelsParam));
2377 }
2378 else
2379 {
2380 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
2381 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
2382 paramBuffer.addParam(std::move(pixelsParam));
2383 }
2384
2385 return CallCapture(angle::EntryPoint::GLReadPixelsRobustANGLE, std::move(paramBuffer));
2386 }
2387
CaptureTexImage2DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2388 CallCapture CaptureTexImage2DRobustANGLE(const State &glState,
2389 bool isCallValid,
2390 TextureTarget targetPacked,
2391 GLint level,
2392 GLint internalformat,
2393 GLsizei width,
2394 GLsizei height,
2395 GLint border,
2396 GLenum format,
2397 GLenum type,
2398 GLsizei bufSize,
2399 const void *pixels)
2400 {
2401 ParamBuffer paramBuffer;
2402
2403 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2404 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2405 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
2406 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2407 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2408 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2409 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2410 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2411 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2412
2413 if (isCallValid)
2414 {
2415 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2416 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2417 CaptureTexImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level,
2418 internalformat, width, height, border, format, type,
2419 bufSize, pixels, &pixelsParam);
2420 paramBuffer.addParam(std::move(pixelsParam));
2421 }
2422 else
2423 {
2424 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2425 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2426 &pixelsParam.value);
2427 paramBuffer.addParam(std::move(pixelsParam));
2428 }
2429
2430 return CallCapture(angle::EntryPoint::GLTexImage2DRobustANGLE, std::move(paramBuffer));
2431 }
2432
CaptureTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLfloat * params)2433 CallCapture CaptureTexParameterfvRobustANGLE(const State &glState,
2434 bool isCallValid,
2435 TextureType targetPacked,
2436 GLenum pname,
2437 GLsizei bufSize,
2438 const GLfloat *params)
2439 {
2440 ParamBuffer paramBuffer;
2441
2442 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2443 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2444 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2445
2446 if (isCallValid)
2447 {
2448 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
2449 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
2450 CaptureTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2451 params, ¶msParam);
2452 paramBuffer.addParam(std::move(paramsParam));
2453 }
2454 else
2455 {
2456 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
2457 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
2458 ¶msParam.value);
2459 paramBuffer.addParam(std::move(paramsParam));
2460 }
2461
2462 return CallCapture(angle::EntryPoint::GLTexParameterfvRobustANGLE, std::move(paramBuffer));
2463 }
2464
CaptureTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)2465 CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
2466 bool isCallValid,
2467 TextureType targetPacked,
2468 GLenum pname,
2469 GLsizei bufSize,
2470 const GLint *params)
2471 {
2472 ParamBuffer paramBuffer;
2473
2474 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2475 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2476 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2477
2478 if (isCallValid)
2479 {
2480 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
2481 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
2482 CaptureTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2483 params, ¶msParam);
2484 paramBuffer.addParam(std::move(paramsParam));
2485 }
2486 else
2487 {
2488 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
2489 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
2490 ¶msParam.value);
2491 paramBuffer.addParam(std::move(paramsParam));
2492 }
2493
2494 return CallCapture(angle::EntryPoint::GLTexParameterivRobustANGLE, std::move(paramBuffer));
2495 }
2496
CaptureTexSubImage2DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2497 CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
2498 bool isCallValid,
2499 TextureTarget targetPacked,
2500 GLint level,
2501 GLint xoffset,
2502 GLint yoffset,
2503 GLsizei width,
2504 GLsizei height,
2505 GLenum format,
2506 GLenum type,
2507 GLsizei bufSize,
2508 const void *pixels)
2509 {
2510 ParamBuffer paramBuffer;
2511
2512 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2513 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2514 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2515 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2516 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2517 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2518 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2519 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2520 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2521
2522 if (isCallValid)
2523 {
2524 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2525 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2526 CaptureTexSubImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
2527 yoffset, width, height, format, type, bufSize,
2528 pixels, &pixelsParam);
2529 paramBuffer.addParam(std::move(pixelsParam));
2530 }
2531 else
2532 {
2533 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2534 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2535 &pixelsParam.value);
2536 paramBuffer.addParam(std::move(pixelsParam));
2537 }
2538
2539 return CallCapture(angle::EntryPoint::GLTexSubImage2DRobustANGLE, std::move(paramBuffer));
2540 }
2541
CaptureTexImage3DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2542 CallCapture CaptureTexImage3DRobustANGLE(const State &glState,
2543 bool isCallValid,
2544 TextureTarget targetPacked,
2545 GLint level,
2546 GLint internalformat,
2547 GLsizei width,
2548 GLsizei height,
2549 GLsizei depth,
2550 GLint border,
2551 GLenum format,
2552 GLenum type,
2553 GLsizei bufSize,
2554 const void *pixels)
2555 {
2556 ParamBuffer paramBuffer;
2557
2558 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2559 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2560 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
2561 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2562 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2563 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2564 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2565 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2566 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2567 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2568
2569 if (isCallValid)
2570 {
2571 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2572 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2573 CaptureTexImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level,
2574 internalformat, width, height, depth, border, format,
2575 type, bufSize, pixels, &pixelsParam);
2576 paramBuffer.addParam(std::move(pixelsParam));
2577 }
2578 else
2579 {
2580 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2581 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2582 &pixelsParam.value);
2583 paramBuffer.addParam(std::move(pixelsParam));
2584 }
2585
2586 return CallCapture(angle::EntryPoint::GLTexImage3DRobustANGLE, std::move(paramBuffer));
2587 }
2588
CaptureTexSubImage3DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2589 CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState,
2590 bool isCallValid,
2591 TextureTarget targetPacked,
2592 GLint level,
2593 GLint xoffset,
2594 GLint yoffset,
2595 GLint zoffset,
2596 GLsizei width,
2597 GLsizei height,
2598 GLsizei depth,
2599 GLenum format,
2600 GLenum type,
2601 GLsizei bufSize,
2602 const void *pixels)
2603 {
2604 ParamBuffer paramBuffer;
2605
2606 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2607 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2608 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2609 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2610 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
2611 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2612 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2613 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2614 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2615 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2616 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2617
2618 if (isCallValid)
2619 {
2620 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2621 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2622 CaptureTexSubImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
2623 yoffset, zoffset, width, height, depth, format, type,
2624 bufSize, pixels, &pixelsParam);
2625 paramBuffer.addParam(std::move(pixelsParam));
2626 }
2627 else
2628 {
2629 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2630 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2631 &pixelsParam.value);
2632 paramBuffer.addParam(std::move(pixelsParam));
2633 }
2634
2635 return CallCapture(angle::EntryPoint::GLTexSubImage3DRobustANGLE, std::move(paramBuffer));
2636 }
2637
CaptureCompressedTexImage2DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const void * data)2638 CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState,
2639 bool isCallValid,
2640 TextureTarget targetPacked,
2641 GLint level,
2642 GLenum internalformat,
2643 GLsizei width,
2644 GLsizei height,
2645 GLint border,
2646 GLsizei imageSize,
2647 GLsizei dataSize,
2648 const void *data)
2649 {
2650 ParamBuffer paramBuffer;
2651
2652 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2653 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2654 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
2655 internalformat);
2656 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2657 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2658 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2659 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2660 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2661
2662 if (isCallValid)
2663 {
2664 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2665 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2666 CaptureCompressedTexImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2667 internalformat, width, height, border,
2668 imageSize, dataSize, data, &dataParam);
2669 paramBuffer.addParam(std::move(dataParam));
2670 }
2671 else
2672 {
2673 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2674 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2675 &dataParam.value);
2676 paramBuffer.addParam(std::move(dataParam));
2677 }
2678
2679 return CallCapture(angle::EntryPoint::GLCompressedTexImage2DRobustANGLE,
2680 std::move(paramBuffer));
2681 }
2682
CaptureCompressedTexSubImage2DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLsizei xoffset,GLsizei yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,GLsizei dataSize,const void * data)2683 CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState,
2684 bool isCallValid,
2685 TextureTarget targetPacked,
2686 GLint level,
2687 GLsizei xoffset,
2688 GLsizei yoffset,
2689 GLsizei width,
2690 GLsizei height,
2691 GLenum format,
2692 GLsizei imageSize,
2693 GLsizei dataSize,
2694 const void *data)
2695 {
2696 ParamBuffer paramBuffer;
2697
2698 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2699 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2700 paramBuffer.addValueParam("xoffset", ParamType::TGLsizei, xoffset);
2701 paramBuffer.addValueParam("yoffset", ParamType::TGLsizei, yoffset);
2702 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2703 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2704 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2705 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2706 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2707
2708 if (isCallValid)
2709 {
2710 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2711 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2712 CaptureCompressedTexSubImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2713 xoffset, yoffset, width, height, format,
2714 imageSize, dataSize, data, &dataParam);
2715 paramBuffer.addParam(std::move(dataParam));
2716 }
2717 else
2718 {
2719 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2720 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2721 &dataParam.value);
2722 paramBuffer.addParam(std::move(dataParam));
2723 }
2724
2725 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE,
2726 std::move(paramBuffer));
2727 }
2728
CaptureCompressedTexImage3DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,GLsizei dataSize,const void * data)2729 CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState,
2730 bool isCallValid,
2731 TextureTarget targetPacked,
2732 GLint level,
2733 GLenum internalformat,
2734 GLsizei width,
2735 GLsizei height,
2736 GLsizei depth,
2737 GLint border,
2738 GLsizei imageSize,
2739 GLsizei dataSize,
2740 const void *data)
2741 {
2742 ParamBuffer paramBuffer;
2743
2744 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2745 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2746 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
2747 internalformat);
2748 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2749 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2750 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2751 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2752 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2753 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2754
2755 if (isCallValid)
2756 {
2757 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2758 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2759 CaptureCompressedTexImage3DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2760 internalformat, width, height, depth, border,
2761 imageSize, dataSize, data, &dataParam);
2762 paramBuffer.addParam(std::move(dataParam));
2763 }
2764 else
2765 {
2766 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2767 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2768 &dataParam.value);
2769 paramBuffer.addParam(std::move(dataParam));
2770 }
2771
2772 return CallCapture(angle::EntryPoint::GLCompressedTexImage3DRobustANGLE,
2773 std::move(paramBuffer));
2774 }
2775
CaptureCompressedTexSubImage3DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,GLsizei dataSize,const void * data)2776 CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState,
2777 bool isCallValid,
2778 TextureTarget targetPacked,
2779 GLint level,
2780 GLint xoffset,
2781 GLint yoffset,
2782 GLint zoffset,
2783 GLsizei width,
2784 GLsizei height,
2785 GLsizei depth,
2786 GLenum format,
2787 GLsizei imageSize,
2788 GLsizei dataSize,
2789 const void *data)
2790 {
2791 ParamBuffer paramBuffer;
2792
2793 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2794 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2795 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2796 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2797 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
2798 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2799 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2800 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2801 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2802 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2803 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2804
2805 if (isCallValid)
2806 {
2807 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2808 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2809 CaptureCompressedTexSubImage3DRobustANGLE_data(
2810 glState, isCallValid, targetPacked, level, xoffset, yoffset, zoffset, width, height,
2811 depth, format, imageSize, dataSize, data, &dataParam);
2812 paramBuffer.addParam(std::move(dataParam));
2813 }
2814 else
2815 {
2816 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2817 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2818 &dataParam.value);
2819 paramBuffer.addParam(std::move(dataParam));
2820 }
2821
2822 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE,
2823 std::move(paramBuffer));
2824 }
2825
CaptureGetQueryivRobustANGLE(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2826 CallCapture CaptureGetQueryivRobustANGLE(const State &glState,
2827 bool isCallValid,
2828 QueryType targetPacked,
2829 GLenum pname,
2830 GLsizei bufSize,
2831 GLsizei *length,
2832 GLint *params)
2833 {
2834 ParamBuffer paramBuffer;
2835
2836 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
2837 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2838 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2839
2840 if (isCallValid)
2841 {
2842 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2843 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2844 CaptureGetQueryivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
2845 length, params, &lengthParam);
2846 paramBuffer.addParam(std::move(lengthParam));
2847 }
2848 else
2849 {
2850 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2851 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2852 &lengthParam.value);
2853 paramBuffer.addParam(std::move(lengthParam));
2854 }
2855
2856 if (isCallValid)
2857 {
2858 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2859 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2860 CaptureGetQueryivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2861 length, params, ¶msParam);
2862 paramBuffer.addParam(std::move(paramsParam));
2863 }
2864 else
2865 {
2866 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2867 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2868 paramBuffer.addParam(std::move(paramsParam));
2869 }
2870
2871 return CallCapture(angle::EntryPoint::GLGetQueryivRobustANGLE, std::move(paramBuffer));
2872 }
2873
CaptureGetQueryObjectuivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2874 CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
2875 bool isCallValid,
2876 QueryID idPacked,
2877 GLenum pname,
2878 GLsizei bufSize,
2879 GLsizei *length,
2880 GLuint *params)
2881 {
2882 ParamBuffer paramBuffer;
2883
2884 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2885 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2886 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2887
2888 if (isCallValid)
2889 {
2890 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2891 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2892 CaptureGetQueryObjectuivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
2893 length, params, &lengthParam);
2894 paramBuffer.addParam(std::move(lengthParam));
2895 }
2896 else
2897 {
2898 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2899 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2900 &lengthParam.value);
2901 paramBuffer.addParam(std::move(lengthParam));
2902 }
2903
2904 if (isCallValid)
2905 {
2906 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2907 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2908 CaptureGetQueryObjectuivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
2909 length, params, ¶msParam);
2910 paramBuffer.addParam(std::move(paramsParam));
2911 }
2912 else
2913 {
2914 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2915 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
2916 ¶msParam.value);
2917 paramBuffer.addParam(std::move(paramsParam));
2918 }
2919
2920 return CallCapture(angle::EntryPoint::GLGetQueryObjectuivRobustANGLE, std::move(paramBuffer));
2921 }
2922
CaptureGetBufferPointervRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2923 CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
2924 bool isCallValid,
2925 BufferBinding targetPacked,
2926 GLenum pname,
2927 GLsizei bufSize,
2928 GLsizei *length,
2929 void **params)
2930 {
2931 ParamBuffer paramBuffer;
2932
2933 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
2934 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2935 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2936
2937 if (isCallValid)
2938 {
2939 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2940 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2941 CaptureGetBufferPointervRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2942 bufSize, length, params, &lengthParam);
2943 paramBuffer.addParam(std::move(lengthParam));
2944 }
2945 else
2946 {
2947 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2948 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2949 &lengthParam.value);
2950 paramBuffer.addParam(std::move(lengthParam));
2951 }
2952
2953 if (isCallValid)
2954 {
2955 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
2956 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
2957 CaptureGetBufferPointervRobustANGLE_params(glState, isCallValid, targetPacked, pname,
2958 bufSize, length, params, ¶msParam);
2959 paramBuffer.addParam(std::move(paramsParam));
2960 }
2961 else
2962 {
2963 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
2964 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
2965 ¶msParam.value);
2966 paramBuffer.addParam(std::move(paramsParam));
2967 }
2968
2969 return CallCapture(angle::EntryPoint::GLGetBufferPointervRobustANGLE, std::move(paramBuffer));
2970 }
2971
CaptureGetIntegeri_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)2972 CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
2973 bool isCallValid,
2974 GLenum target,
2975 GLuint index,
2976 GLsizei bufSize,
2977 GLsizei *length,
2978 GLint *data)
2979 {
2980 ParamBuffer paramBuffer;
2981
2982 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
2983 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2984 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2985
2986 if (isCallValid)
2987 {
2988 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2989 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2990 CaptureGetIntegeri_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
2991 data, &lengthParam);
2992 paramBuffer.addParam(std::move(lengthParam));
2993 }
2994 else
2995 {
2996 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2997 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2998 &lengthParam.value);
2999 paramBuffer.addParam(std::move(lengthParam));
3000 }
3001
3002 if (isCallValid)
3003 {
3004 ParamCapture dataParam("data", ParamType::TGLintPointer);
3005 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
3006 CaptureGetIntegeri_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3007 data, &dataParam);
3008 paramBuffer.addParam(std::move(dataParam));
3009 }
3010 else
3011 {
3012 ParamCapture dataParam("data", ParamType::TGLintPointer);
3013 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
3014 paramBuffer.addParam(std::move(dataParam));
3015 }
3016
3017 return CallCapture(angle::EntryPoint::GLGetIntegeri_vRobustANGLE, std::move(paramBuffer));
3018 }
3019
CaptureGetInternalformativRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3020 CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
3021 bool isCallValid,
3022 GLenum target,
3023 GLenum internalformat,
3024 GLenum pname,
3025 GLsizei bufSize,
3026 GLsizei *length,
3027 GLint *params)
3028 {
3029 ParamBuffer paramBuffer;
3030
3031 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3032 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
3033 internalformat);
3034 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3035 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3036
3037 if (isCallValid)
3038 {
3039 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3040 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3041 CaptureGetInternalformativRobustANGLE_length(glState, isCallValid, target, internalformat,
3042 pname, bufSize, length, params, &lengthParam);
3043 paramBuffer.addParam(std::move(lengthParam));
3044 }
3045 else
3046 {
3047 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3048 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3049 &lengthParam.value);
3050 paramBuffer.addParam(std::move(lengthParam));
3051 }
3052
3053 if (isCallValid)
3054 {
3055 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3056 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3057 CaptureGetInternalformativRobustANGLE_params(glState, isCallValid, target, internalformat,
3058 pname, bufSize, length, params, ¶msParam);
3059 paramBuffer.addParam(std::move(paramsParam));
3060 }
3061 else
3062 {
3063 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3064 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3065 paramBuffer.addParam(std::move(paramsParam));
3066 }
3067
3068 return CallCapture(angle::EntryPoint::GLGetInternalformativRobustANGLE, std::move(paramBuffer));
3069 }
3070
CaptureGetVertexAttribIivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3071 CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
3072 bool isCallValid,
3073 GLuint index,
3074 GLenum pname,
3075 GLsizei bufSize,
3076 GLsizei *length,
3077 GLint *params)
3078 {
3079 ParamBuffer paramBuffer;
3080
3081 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3082 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3083 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3084
3085 if (isCallValid)
3086 {
3087 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3088 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3089 CaptureGetVertexAttribIivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
3090 length, params, &lengthParam);
3091 paramBuffer.addParam(std::move(lengthParam));
3092 }
3093 else
3094 {
3095 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3096 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3097 &lengthParam.value);
3098 paramBuffer.addParam(std::move(lengthParam));
3099 }
3100
3101 if (isCallValid)
3102 {
3103 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3104 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3105 CaptureGetVertexAttribIivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
3106 length, params, ¶msParam);
3107 paramBuffer.addParam(std::move(paramsParam));
3108 }
3109 else
3110 {
3111 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3112 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3113 paramBuffer.addParam(std::move(paramsParam));
3114 }
3115
3116 return CallCapture(angle::EntryPoint::GLGetVertexAttribIivRobustANGLE, std::move(paramBuffer));
3117 }
3118
CaptureGetVertexAttribIuivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3119 CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
3120 bool isCallValid,
3121 GLuint index,
3122 GLenum pname,
3123 GLsizei bufSize,
3124 GLsizei *length,
3125 GLuint *params)
3126 {
3127 ParamBuffer paramBuffer;
3128
3129 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3130 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3131 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3132
3133 if (isCallValid)
3134 {
3135 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3136 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3137 CaptureGetVertexAttribIuivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
3138 length, params, &lengthParam);
3139 paramBuffer.addParam(std::move(lengthParam));
3140 }
3141 else
3142 {
3143 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3144 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3145 &lengthParam.value);
3146 paramBuffer.addParam(std::move(lengthParam));
3147 }
3148
3149 if (isCallValid)
3150 {
3151 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3152 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3153 CaptureGetVertexAttribIuivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
3154 length, params, ¶msParam);
3155 paramBuffer.addParam(std::move(paramsParam));
3156 }
3157 else
3158 {
3159 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3160 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3161 ¶msParam.value);
3162 paramBuffer.addParam(std::move(paramsParam));
3163 }
3164
3165 return CallCapture(angle::EntryPoint::GLGetVertexAttribIuivRobustANGLE, std::move(paramBuffer));
3166 }
3167
CaptureGetUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)3168 CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
3169 bool isCallValid,
3170 ShaderProgramID programPacked,
3171 UniformLocation locationPacked,
3172 GLsizei bufSize,
3173 GLsizei *length,
3174 GLuint *params)
3175 {
3176 ParamBuffer paramBuffer;
3177
3178 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3179 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3180 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3181
3182 if (isCallValid)
3183 {
3184 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3185 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3186 CaptureGetUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
3187 bufSize, length, params, &lengthParam);
3188 paramBuffer.addParam(std::move(lengthParam));
3189 }
3190 else
3191 {
3192 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3193 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3194 &lengthParam.value);
3195 paramBuffer.addParam(std::move(lengthParam));
3196 }
3197
3198 if (isCallValid)
3199 {
3200 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3201 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3202 CaptureGetUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
3203 bufSize, length, params, ¶msParam);
3204 paramBuffer.addParam(std::move(paramsParam));
3205 }
3206 else
3207 {
3208 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3209 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3210 ¶msParam.value);
3211 paramBuffer.addParam(std::move(paramsParam));
3212 }
3213
3214 return CallCapture(angle::EntryPoint::GLGetUniformuivRobustANGLE, std::move(paramBuffer));
3215 }
3216
CaptureGetActiveUniformBlockivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformBlockIndex uniformBlockIndexPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3217 CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState,
3218 bool isCallValid,
3219 ShaderProgramID programPacked,
3220 UniformBlockIndex uniformBlockIndexPacked,
3221 GLenum pname,
3222 GLsizei bufSize,
3223 GLsizei *length,
3224 GLint *params)
3225 {
3226 ParamBuffer paramBuffer;
3227
3228 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3229 paramBuffer.addValueParam("uniformBlockIndexPacked", ParamType::TUniformBlockIndex,
3230 uniformBlockIndexPacked);
3231 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3232 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3233
3234 if (isCallValid)
3235 {
3236 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3237 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3238 CaptureGetActiveUniformBlockivRobustANGLE_length(glState, isCallValid, programPacked,
3239 uniformBlockIndexPacked, pname, bufSize,
3240 length, params, &lengthParam);
3241 paramBuffer.addParam(std::move(lengthParam));
3242 }
3243 else
3244 {
3245 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3246 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3247 &lengthParam.value);
3248 paramBuffer.addParam(std::move(lengthParam));
3249 }
3250
3251 if (isCallValid)
3252 {
3253 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3254 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3255 CaptureGetActiveUniformBlockivRobustANGLE_params(glState, isCallValid, programPacked,
3256 uniformBlockIndexPacked, pname, bufSize,
3257 length, params, ¶msParam);
3258 paramBuffer.addParam(std::move(paramsParam));
3259 }
3260 else
3261 {
3262 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3263 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3264 paramBuffer.addParam(std::move(paramsParam));
3265 }
3266
3267 return CallCapture(angle::EntryPoint::GLGetActiveUniformBlockivRobustANGLE,
3268 std::move(paramBuffer));
3269 }
3270
CaptureGetInteger64vRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)3271 CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
3272 bool isCallValid,
3273 GLenum pname,
3274 GLsizei bufSize,
3275 GLsizei *length,
3276 GLint64 *data)
3277 {
3278 ParamBuffer paramBuffer;
3279
3280 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3281 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3282
3283 if (isCallValid)
3284 {
3285 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3286 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3287 CaptureGetInteger64vRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
3288 &lengthParam);
3289 paramBuffer.addParam(std::move(lengthParam));
3290 }
3291 else
3292 {
3293 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3294 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3295 &lengthParam.value);
3296 paramBuffer.addParam(std::move(lengthParam));
3297 }
3298
3299 if (isCallValid)
3300 {
3301 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3302 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
3303 CaptureGetInteger64vRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
3304 &dataParam);
3305 paramBuffer.addParam(std::move(dataParam));
3306 }
3307 else
3308 {
3309 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3310 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
3311 &dataParam.value);
3312 paramBuffer.addParam(std::move(dataParam));
3313 }
3314
3315 return CallCapture(angle::EntryPoint::GLGetInteger64vRobustANGLE, std::move(paramBuffer));
3316 }
3317
CaptureGetInteger64i_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)3318 CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
3319 bool isCallValid,
3320 GLenum target,
3321 GLuint index,
3322 GLsizei bufSize,
3323 GLsizei *length,
3324 GLint64 *data)
3325 {
3326 ParamBuffer paramBuffer;
3327
3328 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3329 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3330 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3331
3332 if (isCallValid)
3333 {
3334 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3335 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3336 CaptureGetInteger64i_vRobustANGLE_length(glState, isCallValid, target, index, bufSize,
3337 length, data, &lengthParam);
3338 paramBuffer.addParam(std::move(lengthParam));
3339 }
3340 else
3341 {
3342 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3343 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3344 &lengthParam.value);
3345 paramBuffer.addParam(std::move(lengthParam));
3346 }
3347
3348 if (isCallValid)
3349 {
3350 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3351 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
3352 CaptureGetInteger64i_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3353 data, &dataParam);
3354 paramBuffer.addParam(std::move(dataParam));
3355 }
3356 else
3357 {
3358 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3359 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
3360 &dataParam.value);
3361 paramBuffer.addParam(std::move(dataParam));
3362 }
3363
3364 return CallCapture(angle::EntryPoint::GLGetInteger64i_vRobustANGLE, std::move(paramBuffer));
3365 }
3366
CaptureGetBufferParameteri64vRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3367 CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
3368 bool isCallValid,
3369 BufferBinding targetPacked,
3370 GLenum pname,
3371 GLsizei bufSize,
3372 GLsizei *length,
3373 GLint64 *params)
3374 {
3375 ParamBuffer paramBuffer;
3376
3377 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
3378 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3379 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3380
3381 if (isCallValid)
3382 {
3383 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3384 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3385 CaptureGetBufferParameteri64vRobustANGLE_length(glState, isCallValid, targetPacked, pname,
3386 bufSize, length, params, &lengthParam);
3387 paramBuffer.addParam(std::move(lengthParam));
3388 }
3389 else
3390 {
3391 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3392 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3393 &lengthParam.value);
3394 paramBuffer.addParam(std::move(lengthParam));
3395 }
3396
3397 if (isCallValid)
3398 {
3399 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
3400 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
3401 CaptureGetBufferParameteri64vRobustANGLE_params(glState, isCallValid, targetPacked, pname,
3402 bufSize, length, params, ¶msParam);
3403 paramBuffer.addParam(std::move(paramsParam));
3404 }
3405 else
3406 {
3407 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
3408 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
3409 ¶msParam.value);
3410 paramBuffer.addParam(std::move(paramsParam));
3411 }
3412
3413 return CallCapture(angle::EntryPoint::GLGetBufferParameteri64vRobustANGLE,
3414 std::move(paramBuffer));
3415 }
3416
CaptureSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLuint pname,GLsizei bufSize,const GLint * param)3417 CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
3418 bool isCallValid,
3419 SamplerID samplerPacked,
3420 GLuint pname,
3421 GLsizei bufSize,
3422 const GLint *param)
3423 {
3424 ParamBuffer paramBuffer;
3425
3426 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3427 paramBuffer.addValueParam("pname", ParamType::TGLuint, pname);
3428 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3429
3430 if (isCallValid)
3431 {
3432 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
3433 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
3434 CaptureSamplerParameterivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
3435 bufSize, param, ¶mParam);
3436 paramBuffer.addParam(std::move(paramParam));
3437 }
3438 else
3439 {
3440 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
3441 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
3442 ¶mParam.value);
3443 paramBuffer.addParam(std::move(paramParam));
3444 }
3445
3446 return CallCapture(angle::EntryPoint::GLSamplerParameterivRobustANGLE, std::move(paramBuffer));
3447 }
3448
CaptureSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLfloat * param)3449 CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
3450 bool isCallValid,
3451 SamplerID samplerPacked,
3452 GLenum pname,
3453 GLsizei bufSize,
3454 const GLfloat *param)
3455 {
3456 ParamBuffer paramBuffer;
3457
3458 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3459 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3460 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3461
3462 if (isCallValid)
3463 {
3464 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
3465 InitParamValue(ParamType::TGLfloatConstPointer, param, ¶mParam.value);
3466 CaptureSamplerParameterfvRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
3467 bufSize, param, ¶mParam);
3468 paramBuffer.addParam(std::move(paramParam));
3469 }
3470 else
3471 {
3472 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
3473 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
3474 ¶mParam.value);
3475 paramBuffer.addParam(std::move(paramParam));
3476 }
3477
3478 return CallCapture(angle::EntryPoint::GLSamplerParameterfvRobustANGLE, std::move(paramBuffer));
3479 }
3480
CaptureGetSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3481 CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
3482 bool isCallValid,
3483 SamplerID samplerPacked,
3484 GLenum pname,
3485 GLsizei bufSize,
3486 GLsizei *length,
3487 GLint *params)
3488 {
3489 ParamBuffer paramBuffer;
3490
3491 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3492 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3493 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3494
3495 if (isCallValid)
3496 {
3497 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3498 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3499 CaptureGetSamplerParameterivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3500 bufSize, length, params, &lengthParam);
3501 paramBuffer.addParam(std::move(lengthParam));
3502 }
3503 else
3504 {
3505 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3506 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3507 &lengthParam.value);
3508 paramBuffer.addParam(std::move(lengthParam));
3509 }
3510
3511 if (isCallValid)
3512 {
3513 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3514 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3515 CaptureGetSamplerParameterivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3516 bufSize, length, params, ¶msParam);
3517 paramBuffer.addParam(std::move(paramsParam));
3518 }
3519 else
3520 {
3521 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3522 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3523 paramBuffer.addParam(std::move(paramsParam));
3524 }
3525
3526 return CallCapture(angle::EntryPoint::GLGetSamplerParameterivRobustANGLE,
3527 std::move(paramBuffer));
3528 }
3529
CaptureGetSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3530 CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
3531 bool isCallValid,
3532 SamplerID samplerPacked,
3533 GLenum pname,
3534 GLsizei bufSize,
3535 GLsizei *length,
3536 GLfloat *params)
3537 {
3538 ParamBuffer paramBuffer;
3539
3540 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3541 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3542 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3543
3544 if (isCallValid)
3545 {
3546 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3547 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3548 CaptureGetSamplerParameterfvRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3549 bufSize, length, params, &lengthParam);
3550 paramBuffer.addParam(std::move(lengthParam));
3551 }
3552 else
3553 {
3554 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3555 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3556 &lengthParam.value);
3557 paramBuffer.addParam(std::move(lengthParam));
3558 }
3559
3560 if (isCallValid)
3561 {
3562 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3563 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3564 CaptureGetSamplerParameterfvRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3565 bufSize, length, params, ¶msParam);
3566 paramBuffer.addParam(std::move(paramsParam));
3567 }
3568 else
3569 {
3570 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3571 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3572 ¶msParam.value);
3573 paramBuffer.addParam(std::move(paramsParam));
3574 }
3575
3576 return CallCapture(angle::EntryPoint::GLGetSamplerParameterfvRobustANGLE,
3577 std::move(paramBuffer));
3578 }
3579
CaptureGetFramebufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3580 CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
3581 bool isCallValid,
3582 GLenum target,
3583 GLenum pname,
3584 GLsizei bufSize,
3585 GLsizei *length,
3586 GLint *params)
3587 {
3588 ParamBuffer paramBuffer;
3589
3590 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3591 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3592 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3593
3594 if (isCallValid)
3595 {
3596 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3597 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3598 CaptureGetFramebufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
3599 bufSize, length, params, &lengthParam);
3600 paramBuffer.addParam(std::move(lengthParam));
3601 }
3602 else
3603 {
3604 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3605 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3606 &lengthParam.value);
3607 paramBuffer.addParam(std::move(lengthParam));
3608 }
3609
3610 if (isCallValid)
3611 {
3612 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3613 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3614 CaptureGetFramebufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
3615 bufSize, length, params, ¶msParam);
3616 paramBuffer.addParam(std::move(paramsParam));
3617 }
3618 else
3619 {
3620 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3621 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3622 paramBuffer.addParam(std::move(paramsParam));
3623 }
3624
3625 return CallCapture(angle::EntryPoint::GLGetFramebufferParameterivRobustANGLE,
3626 std::move(paramBuffer));
3627 }
3628
CaptureGetProgramInterfaceivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3629 CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
3630 bool isCallValid,
3631 ShaderProgramID programPacked,
3632 GLenum programInterface,
3633 GLenum pname,
3634 GLsizei bufSize,
3635 GLsizei *length,
3636 GLint *params)
3637 {
3638 ParamBuffer paramBuffer;
3639
3640 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3641 paramBuffer.addEnumParam("programInterface", GLESEnum::AllEnums, ParamType::TGLenum,
3642 programInterface);
3643 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3644 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3645
3646 if (isCallValid)
3647 {
3648 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3649 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3650 CaptureGetProgramInterfaceivRobustANGLE_length(glState, isCallValid, programPacked,
3651 programInterface, pname, bufSize, length,
3652 params, &lengthParam);
3653 paramBuffer.addParam(std::move(lengthParam));
3654 }
3655 else
3656 {
3657 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3658 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3659 &lengthParam.value);
3660 paramBuffer.addParam(std::move(lengthParam));
3661 }
3662
3663 if (isCallValid)
3664 {
3665 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3666 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3667 CaptureGetProgramInterfaceivRobustANGLE_params(glState, isCallValid, programPacked,
3668 programInterface, pname, bufSize, length,
3669 params, ¶msParam);
3670 paramBuffer.addParam(std::move(paramsParam));
3671 }
3672 else
3673 {
3674 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3675 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3676 paramBuffer.addParam(std::move(paramsParam));
3677 }
3678
3679 return CallCapture(angle::EntryPoint::GLGetProgramInterfaceivRobustANGLE,
3680 std::move(paramBuffer));
3681 }
3682
CaptureGetBooleani_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)3683 CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
3684 bool isCallValid,
3685 GLenum target,
3686 GLuint index,
3687 GLsizei bufSize,
3688 GLsizei *length,
3689 GLboolean *data)
3690 {
3691 ParamBuffer paramBuffer;
3692
3693 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3694 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3695 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3696
3697 if (isCallValid)
3698 {
3699 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3700 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3701 CaptureGetBooleani_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
3702 data, &lengthParam);
3703 paramBuffer.addParam(std::move(lengthParam));
3704 }
3705 else
3706 {
3707 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3708 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3709 &lengthParam.value);
3710 paramBuffer.addParam(std::move(lengthParam));
3711 }
3712
3713 if (isCallValid)
3714 {
3715 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
3716 InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
3717 CaptureGetBooleani_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3718 data, &dataParam);
3719 paramBuffer.addParam(std::move(dataParam));
3720 }
3721 else
3722 {
3723 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
3724 InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
3725 &dataParam.value);
3726 paramBuffer.addParam(std::move(dataParam));
3727 }
3728
3729 return CallCapture(angle::EntryPoint::GLGetBooleani_vRobustANGLE, std::move(paramBuffer));
3730 }
3731
CaptureGetMultisamplefvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)3732 CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
3733 bool isCallValid,
3734 GLenum pname,
3735 GLuint index,
3736 GLsizei bufSize,
3737 GLsizei *length,
3738 GLfloat *val)
3739 {
3740 ParamBuffer paramBuffer;
3741
3742 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3743 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3744 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3745
3746 if (isCallValid)
3747 {
3748 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3749 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3750 CaptureGetMultisamplefvRobustANGLE_length(glState, isCallValid, pname, index, bufSize,
3751 length, val, &lengthParam);
3752 paramBuffer.addParam(std::move(lengthParam));
3753 }
3754 else
3755 {
3756 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3757 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3758 &lengthParam.value);
3759 paramBuffer.addParam(std::move(lengthParam));
3760 }
3761
3762 if (isCallValid)
3763 {
3764 ParamCapture valParam("val", ParamType::TGLfloatPointer);
3765 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
3766 CaptureGetMultisamplefvRobustANGLE_val(glState, isCallValid, pname, index, bufSize, length,
3767 val, &valParam);
3768 paramBuffer.addParam(std::move(valParam));
3769 }
3770 else
3771 {
3772 ParamCapture valParam("val", ParamType::TGLfloatPointer);
3773 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3774 &valParam.value);
3775 paramBuffer.addParam(std::move(valParam));
3776 }
3777
3778 return CallCapture(angle::EntryPoint::GLGetMultisamplefvRobustANGLE, std::move(paramBuffer));
3779 }
3780
CaptureGetTexLevelParameterivRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3781 CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
3782 bool isCallValid,
3783 TextureTarget targetPacked,
3784 GLint level,
3785 GLenum pname,
3786 GLsizei bufSize,
3787 GLsizei *length,
3788 GLint *params)
3789 {
3790 ParamBuffer paramBuffer;
3791
3792 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
3793 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3794 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3795 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3796
3797 if (isCallValid)
3798 {
3799 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3800 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3801 CaptureGetTexLevelParameterivRobustANGLE_length(glState, isCallValid, targetPacked, level,
3802 pname, bufSize, length, params,
3803 &lengthParam);
3804 paramBuffer.addParam(std::move(lengthParam));
3805 }
3806 else
3807 {
3808 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3809 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3810 &lengthParam.value);
3811 paramBuffer.addParam(std::move(lengthParam));
3812 }
3813
3814 if (isCallValid)
3815 {
3816 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3817 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3818 CaptureGetTexLevelParameterivRobustANGLE_params(glState, isCallValid, targetPacked, level,
3819 pname, bufSize, length, params,
3820 ¶msParam);
3821 paramBuffer.addParam(std::move(paramsParam));
3822 }
3823 else
3824 {
3825 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3826 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3827 paramBuffer.addParam(std::move(paramsParam));
3828 }
3829
3830 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterivRobustANGLE,
3831 std::move(paramBuffer));
3832 }
3833
CaptureGetTexLevelParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3834 CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
3835 bool isCallValid,
3836 TextureTarget targetPacked,
3837 GLint level,
3838 GLenum pname,
3839 GLsizei bufSize,
3840 GLsizei *length,
3841 GLfloat *params)
3842 {
3843 ParamBuffer paramBuffer;
3844
3845 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
3846 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3847 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3848 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3849
3850 if (isCallValid)
3851 {
3852 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3853 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3854 CaptureGetTexLevelParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, level,
3855 pname, bufSize, length, params,
3856 &lengthParam);
3857 paramBuffer.addParam(std::move(lengthParam));
3858 }
3859 else
3860 {
3861 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3862 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3863 &lengthParam.value);
3864 paramBuffer.addParam(std::move(lengthParam));
3865 }
3866
3867 if (isCallValid)
3868 {
3869 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3870 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3871 CaptureGetTexLevelParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, level,
3872 pname, bufSize, length, params,
3873 ¶msParam);
3874 paramBuffer.addParam(std::move(paramsParam));
3875 }
3876 else
3877 {
3878 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3879 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3880 ¶msParam.value);
3881 paramBuffer.addParam(std::move(paramsParam));
3882 }
3883
3884 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterfvRobustANGLE,
3885 std::move(paramBuffer));
3886 }
3887
CaptureGetPointervRobustANGLERobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)3888 CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
3889 bool isCallValid,
3890 GLenum pname,
3891 GLsizei bufSize,
3892 GLsizei *length,
3893 void **params)
3894 {
3895 ParamBuffer paramBuffer;
3896
3897 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3898 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3899
3900 if (isCallValid)
3901 {
3902 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3903 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3904 CaptureGetPointervRobustANGLERobustANGLE_length(glState, isCallValid, pname, bufSize,
3905 length, params, &lengthParam);
3906 paramBuffer.addParam(std::move(lengthParam));
3907 }
3908 else
3909 {
3910 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3911 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3912 &lengthParam.value);
3913 paramBuffer.addParam(std::move(lengthParam));
3914 }
3915
3916 if (isCallValid)
3917 {
3918 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3919 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
3920 CaptureGetPointervRobustANGLERobustANGLE_params(glState, isCallValid, pname, bufSize,
3921 length, params, ¶msParam);
3922 paramBuffer.addParam(std::move(paramsParam));
3923 }
3924 else
3925 {
3926 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3927 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
3928 ¶msParam.value);
3929 paramBuffer.addParam(std::move(paramsParam));
3930 }
3931
3932 return CallCapture(angle::EntryPoint::GLGetPointervRobustANGLERobustANGLE,
3933 std::move(paramBuffer));
3934 }
3935
CaptureReadnPixelsRobustANGLE(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * data)3936 CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
3937 bool isCallValid,
3938 GLint x,
3939 GLint y,
3940 GLsizei width,
3941 GLsizei height,
3942 GLenum format,
3943 GLenum type,
3944 GLsizei bufSize,
3945 GLsizei *length,
3946 GLsizei *columns,
3947 GLsizei *rows,
3948 void *data)
3949 {
3950 ParamBuffer paramBuffer;
3951
3952 paramBuffer.addValueParam("x", ParamType::TGLint, x);
3953 paramBuffer.addValueParam("y", ParamType::TGLint, y);
3954 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3955 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3956 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
3957 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
3958 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3959
3960 if (isCallValid)
3961 {
3962 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3963 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3964 CaptureReadnPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format,
3965 type, bufSize, length, columns, rows, data,
3966 &lengthParam);
3967 paramBuffer.addParam(std::move(lengthParam));
3968 }
3969 else
3970 {
3971 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3972 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3973 &lengthParam.value);
3974 paramBuffer.addParam(std::move(lengthParam));
3975 }
3976
3977 if (isCallValid)
3978 {
3979 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
3980 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
3981 CaptureReadnPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format,
3982 type, bufSize, length, columns, rows, data,
3983 &columnsParam);
3984 paramBuffer.addParam(std::move(columnsParam));
3985 }
3986 else
3987 {
3988 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
3989 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3990 &columnsParam.value);
3991 paramBuffer.addParam(std::move(columnsParam));
3992 }
3993
3994 if (isCallValid)
3995 {
3996 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
3997 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
3998 CaptureReadnPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
3999 bufSize, length, columns, rows, data, &rowsParam);
4000 paramBuffer.addParam(std::move(rowsParam));
4001 }
4002 else
4003 {
4004 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
4005 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4006 &rowsParam.value);
4007 paramBuffer.addParam(std::move(rowsParam));
4008 }
4009
4010 if (isCallValid)
4011 {
4012 ParamCapture dataParam("data", ParamType::TvoidPointer);
4013 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
4014 CaptureReadnPixelsRobustANGLE_data(glState, isCallValid, x, y, width, height, format, type,
4015 bufSize, length, columns, rows, data, &dataParam);
4016 paramBuffer.addParam(std::move(dataParam));
4017 }
4018 else
4019 {
4020 ParamCapture dataParam("data", ParamType::TvoidPointer);
4021 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
4022 paramBuffer.addParam(std::move(dataParam));
4023 }
4024
4025 return CallCapture(angle::EntryPoint::GLReadnPixelsRobustANGLE, std::move(paramBuffer));
4026 }
4027
CaptureGetnUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)4028 CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
4029 bool isCallValid,
4030 ShaderProgramID programPacked,
4031 UniformLocation locationPacked,
4032 GLsizei bufSize,
4033 GLsizei *length,
4034 GLfloat *params)
4035 {
4036 ParamBuffer paramBuffer;
4037
4038 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4039 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4040 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4041
4042 if (isCallValid)
4043 {
4044 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4045 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4046 CaptureGetnUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
4047 bufSize, length, params, &lengthParam);
4048 paramBuffer.addParam(std::move(lengthParam));
4049 }
4050 else
4051 {
4052 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4053 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4054 &lengthParam.value);
4055 paramBuffer.addParam(std::move(lengthParam));
4056 }
4057
4058 if (isCallValid)
4059 {
4060 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4061 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
4062 CaptureGetnUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
4063 bufSize, length, params, ¶msParam);
4064 paramBuffer.addParam(std::move(paramsParam));
4065 }
4066 else
4067 {
4068 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4069 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
4070 ¶msParam.value);
4071 paramBuffer.addParam(std::move(paramsParam));
4072 }
4073
4074 return CallCapture(angle::EntryPoint::GLGetnUniformfvRobustANGLE, std::move(paramBuffer));
4075 }
4076
CaptureGetnUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)4077 CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
4078 bool isCallValid,
4079 ShaderProgramID programPacked,
4080 UniformLocation locationPacked,
4081 GLsizei bufSize,
4082 GLsizei *length,
4083 GLint *params)
4084 {
4085 ParamBuffer paramBuffer;
4086
4087 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4088 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4089 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4090
4091 if (isCallValid)
4092 {
4093 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4094 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4095 CaptureGetnUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
4096 bufSize, length, params, &lengthParam);
4097 paramBuffer.addParam(std::move(lengthParam));
4098 }
4099 else
4100 {
4101 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4102 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4103 &lengthParam.value);
4104 paramBuffer.addParam(std::move(lengthParam));
4105 }
4106
4107 if (isCallValid)
4108 {
4109 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4110 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4111 CaptureGetnUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
4112 bufSize, length, params, ¶msParam);
4113 paramBuffer.addParam(std::move(paramsParam));
4114 }
4115 else
4116 {
4117 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4118 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4119 paramBuffer.addParam(std::move(paramsParam));
4120 }
4121
4122 return CallCapture(angle::EntryPoint::GLGetnUniformivRobustANGLE, std::move(paramBuffer));
4123 }
4124
CaptureGetnUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)4125 CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
4126 bool isCallValid,
4127 ShaderProgramID programPacked,
4128 UniformLocation locationPacked,
4129 GLsizei bufSize,
4130 GLsizei *length,
4131 GLuint *params)
4132 {
4133 ParamBuffer paramBuffer;
4134
4135 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4136 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4137 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4138
4139 if (isCallValid)
4140 {
4141 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4142 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4143 CaptureGetnUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
4144 bufSize, length, params, &lengthParam);
4145 paramBuffer.addParam(std::move(lengthParam));
4146 }
4147 else
4148 {
4149 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4150 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4151 &lengthParam.value);
4152 paramBuffer.addParam(std::move(lengthParam));
4153 }
4154
4155 if (isCallValid)
4156 {
4157 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4158 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4159 CaptureGetnUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
4160 bufSize, length, params, ¶msParam);
4161 paramBuffer.addParam(std::move(paramsParam));
4162 }
4163 else
4164 {
4165 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4166 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4167 ¶msParam.value);
4168 paramBuffer.addParam(std::move(paramsParam));
4169 }
4170
4171 return CallCapture(angle::EntryPoint::GLGetnUniformuivRobustANGLE, std::move(paramBuffer));
4172 }
4173
CaptureTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)4174 CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
4175 bool isCallValid,
4176 TextureType targetPacked,
4177 GLenum pname,
4178 GLsizei bufSize,
4179 const GLint *params)
4180 {
4181 ParamBuffer paramBuffer;
4182
4183 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4184 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4185 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4186
4187 if (isCallValid)
4188 {
4189 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
4190 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
4191 CaptureTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
4192 params, ¶msParam);
4193 paramBuffer.addParam(std::move(paramsParam));
4194 }
4195 else
4196 {
4197 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
4198 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
4199 ¶msParam.value);
4200 paramBuffer.addParam(std::move(paramsParam));
4201 }
4202
4203 return CallCapture(angle::EntryPoint::GLTexParameterIivRobustANGLE, std::move(paramBuffer));
4204 }
4205
CaptureTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLuint * params)4206 CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
4207 bool isCallValid,
4208 TextureType targetPacked,
4209 GLenum pname,
4210 GLsizei bufSize,
4211 const GLuint *params)
4212 {
4213 ParamBuffer paramBuffer;
4214
4215 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4216 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4217 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4218
4219 if (isCallValid)
4220 {
4221 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
4222 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
4223 CaptureTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
4224 bufSize, params, ¶msParam);
4225 paramBuffer.addParam(std::move(paramsParam));
4226 }
4227 else
4228 {
4229 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
4230 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
4231 ¶msParam.value);
4232 paramBuffer.addParam(std::move(paramsParam));
4233 }
4234
4235 return CallCapture(angle::EntryPoint::GLTexParameterIuivRobustANGLE, std::move(paramBuffer));
4236 }
4237
CaptureGetTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4238 CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
4239 bool isCallValid,
4240 TextureType targetPacked,
4241 GLenum pname,
4242 GLsizei bufSize,
4243 GLsizei *length,
4244 GLint *params)
4245 {
4246 ParamBuffer paramBuffer;
4247
4248 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4249 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4250 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4251
4252 if (isCallValid)
4253 {
4254 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4255 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4256 CaptureGetTexParameterIivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
4257 bufSize, length, params, &lengthParam);
4258 paramBuffer.addParam(std::move(lengthParam));
4259 }
4260 else
4261 {
4262 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4263 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4264 &lengthParam.value);
4265 paramBuffer.addParam(std::move(lengthParam));
4266 }
4267
4268 if (isCallValid)
4269 {
4270 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4271 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4272 CaptureGetTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
4273 bufSize, length, params, ¶msParam);
4274 paramBuffer.addParam(std::move(paramsParam));
4275 }
4276 else
4277 {
4278 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4279 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4280 paramBuffer.addParam(std::move(paramsParam));
4281 }
4282
4283 return CallCapture(angle::EntryPoint::GLGetTexParameterIivRobustANGLE, std::move(paramBuffer));
4284 }
4285
CaptureGetTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)4286 CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
4287 bool isCallValid,
4288 TextureType targetPacked,
4289 GLenum pname,
4290 GLsizei bufSize,
4291 GLsizei *length,
4292 GLuint *params)
4293 {
4294 ParamBuffer paramBuffer;
4295
4296 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4297 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4298 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4299
4300 if (isCallValid)
4301 {
4302 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4303 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4304 CaptureGetTexParameterIuivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
4305 bufSize, length, params, &lengthParam);
4306 paramBuffer.addParam(std::move(lengthParam));
4307 }
4308 else
4309 {
4310 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4311 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4312 &lengthParam.value);
4313 paramBuffer.addParam(std::move(lengthParam));
4314 }
4315
4316 if (isCallValid)
4317 {
4318 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4319 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4320 CaptureGetTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
4321 bufSize, length, params, ¶msParam);
4322 paramBuffer.addParam(std::move(paramsParam));
4323 }
4324 else
4325 {
4326 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4327 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4328 ¶msParam.value);
4329 paramBuffer.addParam(std::move(paramsParam));
4330 }
4331
4332 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivRobustANGLE, std::move(paramBuffer));
4333 }
4334
CaptureSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLint * param)4335 CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
4336 bool isCallValid,
4337 SamplerID samplerPacked,
4338 GLenum pname,
4339 GLsizei bufSize,
4340 const GLint *param)
4341 {
4342 ParamBuffer paramBuffer;
4343
4344 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4345 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4346 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4347
4348 if (isCallValid)
4349 {
4350 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
4351 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
4352 CaptureSamplerParameterIivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
4353 bufSize, param, ¶mParam);
4354 paramBuffer.addParam(std::move(paramParam));
4355 }
4356 else
4357 {
4358 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
4359 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
4360 ¶mParam.value);
4361 paramBuffer.addParam(std::move(paramParam));
4362 }
4363
4364 return CallCapture(angle::EntryPoint::GLSamplerParameterIivRobustANGLE, std::move(paramBuffer));
4365 }
4366
CaptureSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLuint * param)4367 CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
4368 bool isCallValid,
4369 SamplerID samplerPacked,
4370 GLenum pname,
4371 GLsizei bufSize,
4372 const GLuint *param)
4373 {
4374 ParamBuffer paramBuffer;
4375
4376 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4377 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4378 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4379
4380 if (isCallValid)
4381 {
4382 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
4383 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
4384 CaptureSamplerParameterIuivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
4385 bufSize, param, ¶mParam);
4386 paramBuffer.addParam(std::move(paramParam));
4387 }
4388 else
4389 {
4390 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
4391 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
4392 ¶mParam.value);
4393 paramBuffer.addParam(std::move(paramParam));
4394 }
4395
4396 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivRobustANGLE,
4397 std::move(paramBuffer));
4398 }
4399
CaptureGetSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4400 CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
4401 bool isCallValid,
4402 SamplerID samplerPacked,
4403 GLenum pname,
4404 GLsizei bufSize,
4405 GLsizei *length,
4406 GLint *params)
4407 {
4408 ParamBuffer paramBuffer;
4409
4410 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4411 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4412 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4413
4414 if (isCallValid)
4415 {
4416 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4417 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4418 CaptureGetSamplerParameterIivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
4419 bufSize, length, params, &lengthParam);
4420 paramBuffer.addParam(std::move(lengthParam));
4421 }
4422 else
4423 {
4424 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4425 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4426 &lengthParam.value);
4427 paramBuffer.addParam(std::move(lengthParam));
4428 }
4429
4430 if (isCallValid)
4431 {
4432 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4433 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4434 CaptureGetSamplerParameterIivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
4435 bufSize, length, params, ¶msParam);
4436 paramBuffer.addParam(std::move(paramsParam));
4437 }
4438 else
4439 {
4440 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4441 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4442 paramBuffer.addParam(std::move(paramsParam));
4443 }
4444
4445 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivRobustANGLE,
4446 std::move(paramBuffer));
4447 }
4448
CaptureGetSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)4449 CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
4450 bool isCallValid,
4451 SamplerID samplerPacked,
4452 GLenum pname,
4453 GLsizei bufSize,
4454 GLsizei *length,
4455 GLuint *params)
4456 {
4457 ParamBuffer paramBuffer;
4458
4459 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4460 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4461 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4462
4463 if (isCallValid)
4464 {
4465 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4466 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4467 CaptureGetSamplerParameterIuivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
4468 bufSize, length, params, &lengthParam);
4469 paramBuffer.addParam(std::move(lengthParam));
4470 }
4471 else
4472 {
4473 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4474 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4475 &lengthParam.value);
4476 paramBuffer.addParam(std::move(lengthParam));
4477 }
4478
4479 if (isCallValid)
4480 {
4481 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4482 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4483 CaptureGetSamplerParameterIuivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
4484 bufSize, length, params, ¶msParam);
4485 paramBuffer.addParam(std::move(paramsParam));
4486 }
4487 else
4488 {
4489 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4490 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4491 ¶msParam.value);
4492 paramBuffer.addParam(std::move(paramsParam));
4493 }
4494
4495 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivRobustANGLE,
4496 std::move(paramBuffer));
4497 }
4498
CaptureGetQueryObjectivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4499 CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
4500 bool isCallValid,
4501 QueryID idPacked,
4502 GLenum pname,
4503 GLsizei bufSize,
4504 GLsizei *length,
4505 GLint *params)
4506 {
4507 ParamBuffer paramBuffer;
4508
4509 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4510 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4511 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4512
4513 if (isCallValid)
4514 {
4515 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4516 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4517 CaptureGetQueryObjectivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4518 length, params, &lengthParam);
4519 paramBuffer.addParam(std::move(lengthParam));
4520 }
4521 else
4522 {
4523 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4524 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4525 &lengthParam.value);
4526 paramBuffer.addParam(std::move(lengthParam));
4527 }
4528
4529 if (isCallValid)
4530 {
4531 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4532 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4533 CaptureGetQueryObjectivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4534 length, params, ¶msParam);
4535 paramBuffer.addParam(std::move(paramsParam));
4536 }
4537 else
4538 {
4539 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4540 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4541 paramBuffer.addParam(std::move(paramsParam));
4542 }
4543
4544 return CallCapture(angle::EntryPoint::GLGetQueryObjectivRobustANGLE, std::move(paramBuffer));
4545 }
4546
CaptureGetQueryObjecti64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)4547 CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
4548 bool isCallValid,
4549 QueryID idPacked,
4550 GLenum pname,
4551 GLsizei bufSize,
4552 GLsizei *length,
4553 GLint64 *params)
4554 {
4555 ParamBuffer paramBuffer;
4556
4557 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4558 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4559 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4560
4561 if (isCallValid)
4562 {
4563 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4564 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4565 CaptureGetQueryObjecti64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4566 length, params, &lengthParam);
4567 paramBuffer.addParam(std::move(lengthParam));
4568 }
4569 else
4570 {
4571 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4572 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4573 &lengthParam.value);
4574 paramBuffer.addParam(std::move(lengthParam));
4575 }
4576
4577 if (isCallValid)
4578 {
4579 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4580 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
4581 CaptureGetQueryObjecti64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4582 length, params, ¶msParam);
4583 paramBuffer.addParam(std::move(paramsParam));
4584 }
4585 else
4586 {
4587 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4588 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
4589 ¶msParam.value);
4590 paramBuffer.addParam(std::move(paramsParam));
4591 }
4592
4593 return CallCapture(angle::EntryPoint::GLGetQueryObjecti64vRobustANGLE, std::move(paramBuffer));
4594 }
4595
CaptureGetQueryObjectui64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)4596 CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
4597 bool isCallValid,
4598 QueryID idPacked,
4599 GLenum pname,
4600 GLsizei bufSize,
4601 GLsizei *length,
4602 GLuint64 *params)
4603 {
4604 ParamBuffer paramBuffer;
4605
4606 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4607 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4608 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4609
4610 if (isCallValid)
4611 {
4612 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4613 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4614 CaptureGetQueryObjectui64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4615 length, params, &lengthParam);
4616 paramBuffer.addParam(std::move(lengthParam));
4617 }
4618 else
4619 {
4620 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4621 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4622 &lengthParam.value);
4623 paramBuffer.addParam(std::move(lengthParam));
4624 }
4625
4626 if (isCallValid)
4627 {
4628 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4629 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
4630 CaptureGetQueryObjectui64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4631 length, params, ¶msParam);
4632 paramBuffer.addParam(std::move(paramsParam));
4633 }
4634 else
4635 {
4636 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4637 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
4638 ¶msParam.value);
4639 paramBuffer.addParam(std::move(paramsParam));
4640 }
4641
4642 return CallCapture(angle::EntryPoint::GLGetQueryObjectui64vRobustANGLE, std::move(paramBuffer));
4643 }
4644
CaptureImportSemaphoreZirconHandleANGLE(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLuint handle)4645 CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
4646 bool isCallValid,
4647 SemaphoreID semaphorePacked,
4648 HandleType handleTypePacked,
4649 GLuint handle)
4650 {
4651 ParamBuffer paramBuffer;
4652
4653 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4654 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
4655 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
4656
4657 return CallCapture(angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE,
4658 std::move(paramBuffer));
4659 }
4660
CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State & glState,bool isCallValid,GLint plane,GLenum internalformat)4661 CallCapture CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State &glState,
4662 bool isCallValid,
4663 GLint plane,
4664 GLenum internalformat)
4665 {
4666 ParamBuffer paramBuffer;
4667
4668 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4669 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
4670 internalformat);
4671
4672 return CallCapture(angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE,
4673 std::move(paramBuffer));
4674 }
4675
CaptureFramebufferTexturePixelLocalStorageANGLE(const State & glState,bool isCallValid,GLint plane,TextureID backingtexturePacked,GLint level,GLint layer)4676 CallCapture CaptureFramebufferTexturePixelLocalStorageANGLE(const State &glState,
4677 bool isCallValid,
4678 GLint plane,
4679 TextureID backingtexturePacked,
4680 GLint level,
4681 GLint layer)
4682 {
4683 ParamBuffer paramBuffer;
4684
4685 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4686 paramBuffer.addValueParam("backingtexturePacked", ParamType::TTextureID, backingtexturePacked);
4687 paramBuffer.addValueParam("level", ParamType::TGLint, level);
4688 paramBuffer.addValueParam("layer", ParamType::TGLint, layer);
4689
4690 return CallCapture(angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE,
4691 std::move(paramBuffer));
4692 }
4693
CaptureFramebufferPixelLocalClearValuefvANGLE(const State & glState,bool isCallValid,GLint plane,const GLfloat * value)4694 CallCapture CaptureFramebufferPixelLocalClearValuefvANGLE(const State &glState,
4695 bool isCallValid,
4696 GLint plane,
4697 const GLfloat *value)
4698 {
4699 ParamBuffer paramBuffer;
4700
4701 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4702
4703 if (isCallValid)
4704 {
4705 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
4706 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
4707 CaptureFramebufferPixelLocalClearValuefvANGLE_value(glState, isCallValid, plane, value,
4708 &valueParam);
4709 paramBuffer.addParam(std::move(valueParam));
4710 }
4711 else
4712 {
4713 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
4714 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
4715 &valueParam.value);
4716 paramBuffer.addParam(std::move(valueParam));
4717 }
4718
4719 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE,
4720 std::move(paramBuffer));
4721 }
4722
CaptureFramebufferPixelLocalClearValueivANGLE(const State & glState,bool isCallValid,GLint plane,const GLint * value)4723 CallCapture CaptureFramebufferPixelLocalClearValueivANGLE(const State &glState,
4724 bool isCallValid,
4725 GLint plane,
4726 const GLint *value)
4727 {
4728 ParamBuffer paramBuffer;
4729
4730 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4731
4732 if (isCallValid)
4733 {
4734 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
4735 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
4736 CaptureFramebufferPixelLocalClearValueivANGLE_value(glState, isCallValid, plane, value,
4737 &valueParam);
4738 paramBuffer.addParam(std::move(valueParam));
4739 }
4740 else
4741 {
4742 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
4743 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
4744 &valueParam.value);
4745 paramBuffer.addParam(std::move(valueParam));
4746 }
4747
4748 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE,
4749 std::move(paramBuffer));
4750 }
4751
CaptureFramebufferPixelLocalClearValueuivANGLE(const State & glState,bool isCallValid,GLint plane,const GLuint * value)4752 CallCapture CaptureFramebufferPixelLocalClearValueuivANGLE(const State &glState,
4753 bool isCallValid,
4754 GLint plane,
4755 const GLuint *value)
4756 {
4757 ParamBuffer paramBuffer;
4758
4759 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4760
4761 if (isCallValid)
4762 {
4763 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
4764 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
4765 CaptureFramebufferPixelLocalClearValueuivANGLE_value(glState, isCallValid, plane, value,
4766 &valueParam);
4767 paramBuffer.addParam(std::move(valueParam));
4768 }
4769 else
4770 {
4771 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
4772 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
4773 &valueParam.value);
4774 paramBuffer.addParam(std::move(valueParam));
4775 }
4776
4777 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE,
4778 std::move(paramBuffer));
4779 }
4780
CaptureBeginPixelLocalStorageANGLE(const State & glState,bool isCallValid,GLsizei n,const GLenum * loadops)4781 CallCapture CaptureBeginPixelLocalStorageANGLE(const State &glState,
4782 bool isCallValid,
4783 GLsizei n,
4784 const GLenum *loadops)
4785 {
4786 ParamBuffer paramBuffer;
4787
4788 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4789
4790 if (isCallValid)
4791 {
4792 ParamCapture loadopsParam("loadops", ParamType::TGLenumConstPointer);
4793 InitParamValue(ParamType::TGLenumConstPointer, loadops, &loadopsParam.value);
4794 CaptureBeginPixelLocalStorageANGLE_loadops(glState, isCallValid, n, loadops, &loadopsParam);
4795 paramBuffer.addParam(std::move(loadopsParam));
4796 }
4797 else
4798 {
4799 ParamCapture loadopsParam("loadops", ParamType::TGLenumConstPointer);
4800 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
4801 &loadopsParam.value);
4802 paramBuffer.addParam(std::move(loadopsParam));
4803 }
4804
4805 return CallCapture(angle::EntryPoint::GLBeginPixelLocalStorageANGLE, std::move(paramBuffer));
4806 }
4807
CaptureEndPixelLocalStorageANGLE(const State & glState,bool isCallValid,GLsizei n,const GLenum * storeops)4808 CallCapture CaptureEndPixelLocalStorageANGLE(const State &glState,
4809 bool isCallValid,
4810 GLsizei n,
4811 const GLenum *storeops)
4812 {
4813 ParamBuffer paramBuffer;
4814
4815 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4816
4817 if (isCallValid)
4818 {
4819 ParamCapture storeopsParam("storeops", ParamType::TGLenumConstPointer);
4820 InitParamValue(ParamType::TGLenumConstPointer, storeops, &storeopsParam.value);
4821 CaptureEndPixelLocalStorageANGLE_storeops(glState, isCallValid, n, storeops,
4822 &storeopsParam);
4823 paramBuffer.addParam(std::move(storeopsParam));
4824 }
4825 else
4826 {
4827 ParamCapture storeopsParam("storeops", ParamType::TGLenumConstPointer);
4828 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
4829 &storeopsParam.value);
4830 paramBuffer.addParam(std::move(storeopsParam));
4831 }
4832
4833 return CallCapture(angle::EntryPoint::GLEndPixelLocalStorageANGLE, std::move(paramBuffer));
4834 }
4835
CapturePixelLocalStorageBarrierANGLE(const State & glState,bool isCallValid)4836 CallCapture CapturePixelLocalStorageBarrierANGLE(const State &glState, bool isCallValid)
4837 {
4838 ParamBuffer paramBuffer;
4839
4840 return CallCapture(angle::EntryPoint::GLPixelLocalStorageBarrierANGLE, std::move(paramBuffer));
4841 }
4842
CaptureFramebufferPixelLocalStorageInterruptANGLE(const State & glState,bool isCallValid)4843 CallCapture CaptureFramebufferPixelLocalStorageInterruptANGLE(const State &glState,
4844 bool isCallValid)
4845 {
4846 ParamBuffer paramBuffer;
4847
4848 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalStorageInterruptANGLE,
4849 std::move(paramBuffer));
4850 }
4851
CaptureFramebufferPixelLocalStorageRestoreANGLE(const State & glState,bool isCallValid)4852 CallCapture CaptureFramebufferPixelLocalStorageRestoreANGLE(const State &glState, bool isCallValid)
4853 {
4854 ParamBuffer paramBuffer;
4855
4856 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE,
4857 std::move(paramBuffer));
4858 }
4859
CaptureGetFramebufferPixelLocalStorageParameterfvANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLfloat * params)4860 CallCapture CaptureGetFramebufferPixelLocalStorageParameterfvANGLE(const State &glState,
4861 bool isCallValid,
4862 GLint plane,
4863 GLenum pname,
4864 GLfloat *params)
4865 {
4866 ParamBuffer paramBuffer;
4867
4868 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4869 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryFloat, ParamType::TGLenum, pname);
4870
4871 if (isCallValid)
4872 {
4873 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4874 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
4875 CaptureGetFramebufferPixelLocalStorageParameterfvANGLE_params(glState, isCallValid, plane,
4876 pname, params, ¶msParam);
4877 paramBuffer.addParam(std::move(paramsParam));
4878 }
4879 else
4880 {
4881 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4882 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
4883 ¶msParam.value);
4884 paramBuffer.addParam(std::move(paramsParam));
4885 }
4886
4887 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvANGLE,
4888 std::move(paramBuffer));
4889 }
4890
CaptureGetFramebufferPixelLocalStorageParameterivANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLint * params)4891 CallCapture CaptureGetFramebufferPixelLocalStorageParameterivANGLE(const State &glState,
4892 bool isCallValid,
4893 GLint plane,
4894 GLenum pname,
4895 GLint *params)
4896 {
4897 ParamBuffer paramBuffer;
4898
4899 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4900 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryInt, ParamType::TGLenum, pname);
4901
4902 if (isCallValid)
4903 {
4904 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4905 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4906 CaptureGetFramebufferPixelLocalStorageParameterivANGLE_params(glState, isCallValid, plane,
4907 pname, params, ¶msParam);
4908 paramBuffer.addParam(std::move(paramsParam));
4909 }
4910 else
4911 {
4912 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4913 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4914 paramBuffer.addParam(std::move(paramsParam));
4915 }
4916
4917 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterivANGLE,
4918 std::move(paramBuffer));
4919 }
4920
CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)4921 CallCapture CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE(const State &glState,
4922 bool isCallValid,
4923 GLint plane,
4924 GLenum pname,
4925 GLsizei bufSize,
4926 GLsizei *length,
4927 GLfloat *params)
4928 {
4929 ParamBuffer paramBuffer;
4930
4931 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4932 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryFloat, ParamType::TGLenum, pname);
4933 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4934
4935 if (isCallValid)
4936 {
4937 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4938 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4939 CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE_length(
4940 glState, isCallValid, plane, pname, bufSize, length, params, &lengthParam);
4941 paramBuffer.addParam(std::move(lengthParam));
4942 }
4943 else
4944 {
4945 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4946 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4947 &lengthParam.value);
4948 paramBuffer.addParam(std::move(lengthParam));
4949 }
4950
4951 if (isCallValid)
4952 {
4953 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4954 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
4955 CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE_params(
4956 glState, isCallValid, plane, pname, bufSize, length, params, ¶msParam);
4957 paramBuffer.addParam(std::move(paramsParam));
4958 }
4959 else
4960 {
4961 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4962 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
4963 ¶msParam.value);
4964 paramBuffer.addParam(std::move(paramsParam));
4965 }
4966
4967 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE,
4968 std::move(paramBuffer));
4969 }
4970
CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4971 CallCapture CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE(const State &glState,
4972 bool isCallValid,
4973 GLint plane,
4974 GLenum pname,
4975 GLsizei bufSize,
4976 GLsizei *length,
4977 GLint *params)
4978 {
4979 ParamBuffer paramBuffer;
4980
4981 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4982 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryInt, ParamType::TGLenum, pname);
4983 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4984
4985 if (isCallValid)
4986 {
4987 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4988 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4989 CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE_length(
4990 glState, isCallValid, plane, pname, bufSize, length, params, &lengthParam);
4991 paramBuffer.addParam(std::move(lengthParam));
4992 }
4993 else
4994 {
4995 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4996 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4997 &lengthParam.value);
4998 paramBuffer.addParam(std::move(lengthParam));
4999 }
5000
5001 if (isCallValid)
5002 {
5003 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5004 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5005 CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE_params(
5006 glState, isCallValid, plane, pname, bufSize, length, params, ¶msParam);
5007 paramBuffer.addParam(std::move(paramsParam));
5008 }
5009 else
5010 {
5011 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5012 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
5013 paramBuffer.addParam(std::move(paramsParam));
5014 }
5015
5016 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterivRobustANGLE,
5017 std::move(paramBuffer));
5018 }
5019
CaptureTexImage2DExternalANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)5020 CallCapture CaptureTexImage2DExternalANGLE(const State &glState,
5021 bool isCallValid,
5022 TextureTarget targetPacked,
5023 GLint level,
5024 GLint internalformat,
5025 GLsizei width,
5026 GLsizei height,
5027 GLint border,
5028 GLenum format,
5029 GLenum type)
5030 {
5031 ParamBuffer paramBuffer;
5032
5033 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5034 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5035 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
5036 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5037 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5038 paramBuffer.addValueParam("border", ParamType::TGLint, border);
5039 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
5040 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
5041
5042 return CallCapture(angle::EntryPoint::GLTexImage2DExternalANGLE, std::move(paramBuffer));
5043 }
5044
CaptureInvalidateTextureANGLE(const State & glState,bool isCallValid,TextureType targetPacked)5045 CallCapture CaptureInvalidateTextureANGLE(const State &glState,
5046 bool isCallValid,
5047 TextureType targetPacked)
5048 {
5049 ParamBuffer paramBuffer;
5050
5051 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5052
5053 return CallCapture(angle::EntryPoint::GLInvalidateTextureANGLE, std::move(paramBuffer));
5054 }
5055
CaptureTexStorage2DMultisampleANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)5056 CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
5057 bool isCallValid,
5058 TextureType targetPacked,
5059 GLsizei samples,
5060 GLenum internalformat,
5061 GLsizei width,
5062 GLsizei height,
5063 GLboolean fixedsamplelocations)
5064 {
5065 ParamBuffer paramBuffer;
5066
5067 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5068 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5069 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
5070 internalformat);
5071 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5072 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5073 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
5074
5075 return CallCapture(angle::EntryPoint::GLTexStorage2DMultisampleANGLE, std::move(paramBuffer));
5076 }
5077
CaptureGetMultisamplefvANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLfloat * val)5078 CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
5079 bool isCallValid,
5080 GLenum pname,
5081 GLuint index,
5082 GLfloat *val)
5083 {
5084 ParamBuffer paramBuffer;
5085
5086 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
5087 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5088
5089 if (isCallValid)
5090 {
5091 ParamCapture valParam("val", ParamType::TGLfloatPointer);
5092 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
5093 CaptureGetMultisamplefvANGLE_val(glState, isCallValid, pname, index, val, &valParam);
5094 paramBuffer.addParam(std::move(valParam));
5095 }
5096 else
5097 {
5098 ParamCapture valParam("val", ParamType::TGLfloatPointer);
5099 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
5100 &valParam.value);
5101 paramBuffer.addParam(std::move(valParam));
5102 }
5103
5104 return CallCapture(angle::EntryPoint::GLGetMultisamplefvANGLE, std::move(paramBuffer));
5105 }
5106
CaptureSampleMaskiANGLE(const State & glState,bool isCallValid,GLuint maskNumber,GLbitfield mask)5107 CallCapture CaptureSampleMaskiANGLE(const State &glState,
5108 bool isCallValid,
5109 GLuint maskNumber,
5110 GLbitfield mask)
5111 {
5112 ParamBuffer paramBuffer;
5113
5114 paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber);
5115 paramBuffer.addEnumParam("mask", GLESEnum::AllEnums, ParamType::TGLbitfield, mask);
5116
5117 return CallCapture(angle::EntryPoint::GLSampleMaskiANGLE, std::move(paramBuffer));
5118 }
5119
CaptureGetTranslatedShaderSourceANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLsizei bufSize,GLsizei * length,GLchar * source)5120 CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
5121 bool isCallValid,
5122 ShaderProgramID shaderPacked,
5123 GLsizei bufSize,
5124 GLsizei *length,
5125 GLchar *source)
5126 {
5127 ParamBuffer paramBuffer;
5128
5129 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
5130 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5131
5132 if (isCallValid)
5133 {
5134 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5135 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
5136 CaptureGetTranslatedShaderSourceANGLE_length(glState, isCallValid, shaderPacked, bufSize,
5137 length, source, &lengthParam);
5138 paramBuffer.addParam(std::move(lengthParam));
5139 }
5140 else
5141 {
5142 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5143 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
5144 &lengthParam.value);
5145 paramBuffer.addParam(std::move(lengthParam));
5146 }
5147
5148 if (isCallValid)
5149 {
5150 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
5151 InitParamValue(ParamType::TGLcharPointer, source, &sourceParam.value);
5152 CaptureGetTranslatedShaderSourceANGLE_source(glState, isCallValid, shaderPacked, bufSize,
5153 length, source, &sourceParam);
5154 paramBuffer.addParam(std::move(sourceParam));
5155 }
5156 else
5157 {
5158 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
5159 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
5160 &sourceParam.value);
5161 paramBuffer.addParam(std::move(sourceParam));
5162 }
5163
5164 return CallCapture(angle::EntryPoint::GLGetTranslatedShaderSourceANGLE, std::move(paramBuffer));
5165 }
5166
CaptureAcquireTexturesANGLE(const State & glState,bool isCallValid,GLuint numTextures,const TextureID * texturesPacked,const GLenum * layouts)5167 CallCapture CaptureAcquireTexturesANGLE(const State &glState,
5168 bool isCallValid,
5169 GLuint numTextures,
5170 const TextureID *texturesPacked,
5171 const GLenum *layouts)
5172 {
5173 ParamBuffer paramBuffer;
5174
5175 paramBuffer.addValueParam("numTextures", ParamType::TGLuint, numTextures);
5176
5177 if (isCallValid)
5178 {
5179 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5180 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
5181 &texturesPackedParam.value);
5182 CaptureAcquireTexturesANGLE_texturesPacked(glState, isCallValid, numTextures,
5183 texturesPacked, layouts, &texturesPackedParam);
5184 paramBuffer.addParam(std::move(texturesPackedParam));
5185 }
5186 else
5187 {
5188 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5189 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
5190 &texturesPackedParam.value);
5191 paramBuffer.addParam(std::move(texturesPackedParam));
5192 }
5193
5194 if (isCallValid)
5195 {
5196 ParamCapture layoutsParam("layouts", ParamType::TGLenumConstPointer);
5197 InitParamValue(ParamType::TGLenumConstPointer, layouts, &layoutsParam.value);
5198 CaptureAcquireTexturesANGLE_layouts(glState, isCallValid, numTextures, texturesPacked,
5199 layouts, &layoutsParam);
5200 paramBuffer.addParam(std::move(layoutsParam));
5201 }
5202 else
5203 {
5204 ParamCapture layoutsParam("layouts", ParamType::TGLenumConstPointer);
5205 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
5206 &layoutsParam.value);
5207 paramBuffer.addParam(std::move(layoutsParam));
5208 }
5209
5210 return CallCapture(angle::EntryPoint::GLAcquireTexturesANGLE, std::move(paramBuffer));
5211 }
5212
CaptureReleaseTexturesANGLE(const State & glState,bool isCallValid,GLuint numTextures,const TextureID * texturesPacked,GLenum * layouts)5213 CallCapture CaptureReleaseTexturesANGLE(const State &glState,
5214 bool isCallValid,
5215 GLuint numTextures,
5216 const TextureID *texturesPacked,
5217 GLenum *layouts)
5218 {
5219 ParamBuffer paramBuffer;
5220
5221 paramBuffer.addValueParam("numTextures", ParamType::TGLuint, numTextures);
5222
5223 if (isCallValid)
5224 {
5225 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5226 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
5227 &texturesPackedParam.value);
5228 CaptureReleaseTexturesANGLE_texturesPacked(glState, isCallValid, numTextures,
5229 texturesPacked, layouts, &texturesPackedParam);
5230 paramBuffer.addParam(std::move(texturesPackedParam));
5231 }
5232 else
5233 {
5234 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5235 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
5236 &texturesPackedParam.value);
5237 paramBuffer.addParam(std::move(texturesPackedParam));
5238 }
5239
5240 if (isCallValid)
5241 {
5242 ParamCapture layoutsParam("layouts", ParamType::TGLenumPointer);
5243 InitParamValue(ParamType::TGLenumPointer, layouts, &layoutsParam.value);
5244 CaptureReleaseTexturesANGLE_layouts(glState, isCallValid, numTextures, texturesPacked,
5245 layouts, &layoutsParam);
5246 paramBuffer.addParam(std::move(layoutsParam));
5247 }
5248 else
5249 {
5250 ParamCapture layoutsParam("layouts", ParamType::TGLenumPointer);
5251 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
5252 &layoutsParam.value);
5253 paramBuffer.addParam(std::move(layoutsParam));
5254 }
5255
5256 return CallCapture(angle::EntryPoint::GLReleaseTexturesANGLE, std::move(paramBuffer));
5257 }
5258
CaptureBindUniformLocationCHROMIUM(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,const GLchar * name)5259 CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
5260 bool isCallValid,
5261 ShaderProgramID programPacked,
5262 UniformLocation locationPacked,
5263 const GLchar *name)
5264 {
5265 ParamBuffer paramBuffer;
5266
5267 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5268 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
5269
5270 if (isCallValid)
5271 {
5272 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5273 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5274 CaptureBindUniformLocationCHROMIUM_name(glState, isCallValid, programPacked, locationPacked,
5275 name, &nameParam);
5276 paramBuffer.addParam(std::move(nameParam));
5277 }
5278 else
5279 {
5280 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5281 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5282 &nameParam.value);
5283 paramBuffer.addParam(std::move(nameParam));
5284 }
5285
5286 return CallCapture(angle::EntryPoint::GLBindUniformLocationCHROMIUM, std::move(paramBuffer));
5287 }
5288
CaptureCompressedCopyTextureCHROMIUM(const State & glState,bool isCallValid,TextureID sourceIdPacked,TextureID destIdPacked)5289 CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
5290 bool isCallValid,
5291 TextureID sourceIdPacked,
5292 TextureID destIdPacked)
5293 {
5294 ParamBuffer paramBuffer;
5295
5296 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
5297 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
5298
5299 return CallCapture(angle::EntryPoint::GLCompressedCopyTextureCHROMIUM, std::move(paramBuffer));
5300 }
5301
CaptureCopyTextureCHROMIUM(const State & glState,bool isCallValid,TextureID sourceIdPacked,GLint sourceLevel,TextureTarget destTargetPacked,TextureID destIdPacked,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)5302 CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
5303 bool isCallValid,
5304 TextureID sourceIdPacked,
5305 GLint sourceLevel,
5306 TextureTarget destTargetPacked,
5307 TextureID destIdPacked,
5308 GLint destLevel,
5309 GLint internalFormat,
5310 GLenum destType,
5311 GLboolean unpackFlipY,
5312 GLboolean unpackPremultiplyAlpha,
5313 GLboolean unpackUnmultiplyAlpha)
5314 {
5315 ParamBuffer paramBuffer;
5316
5317 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
5318 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
5319 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
5320 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
5321 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
5322 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
5323 paramBuffer.addEnumParam("destType", GLESEnum::AllEnums, ParamType::TGLenum, destType);
5324 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
5325 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
5326 unpackPremultiplyAlpha);
5327 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
5328 unpackUnmultiplyAlpha);
5329
5330 return CallCapture(angle::EntryPoint::GLCopyTextureCHROMIUM, std::move(paramBuffer));
5331 }
5332
CaptureCopySubTextureCHROMIUM(const State & glState,bool isCallValid,TextureID sourceIdPacked,GLint sourceLevel,TextureTarget destTargetPacked,TextureID destIdPacked,GLint destLevel,GLint xoffset,GLint yoffset,GLint x,GLint y,GLint width,GLint height,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)5333 CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
5334 bool isCallValid,
5335 TextureID sourceIdPacked,
5336 GLint sourceLevel,
5337 TextureTarget destTargetPacked,
5338 TextureID destIdPacked,
5339 GLint destLevel,
5340 GLint xoffset,
5341 GLint yoffset,
5342 GLint x,
5343 GLint y,
5344 GLint width,
5345 GLint height,
5346 GLboolean unpackFlipY,
5347 GLboolean unpackPremultiplyAlpha,
5348 GLboolean unpackUnmultiplyAlpha)
5349 {
5350 ParamBuffer paramBuffer;
5351
5352 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
5353 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
5354 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
5355 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
5356 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
5357 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
5358 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
5359 paramBuffer.addValueParam("x", ParamType::TGLint, x);
5360 paramBuffer.addValueParam("y", ParamType::TGLint, y);
5361 paramBuffer.addValueParam("width", ParamType::TGLint, width);
5362 paramBuffer.addValueParam("height", ParamType::TGLint, height);
5363 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
5364 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
5365 unpackPremultiplyAlpha);
5366 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
5367 unpackUnmultiplyAlpha);
5368
5369 return CallCapture(angle::EntryPoint::GLCopySubTextureCHROMIUM, std::move(paramBuffer));
5370 }
5371
CaptureCoverageModulationCHROMIUM(const State & glState,bool isCallValid,GLenum components)5372 CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
5373 bool isCallValid,
5374 GLenum components)
5375 {
5376 ParamBuffer paramBuffer;
5377
5378 paramBuffer.addEnumParam("components", GLESEnum::AllEnums, ParamType::TGLenum, components);
5379
5380 return CallCapture(angle::EntryPoint::GLCoverageModulationCHROMIUM, std::move(paramBuffer));
5381 }
5382
CaptureLoseContextCHROMIUM(const State & glState,bool isCallValid,GraphicsResetStatus currentPacked,GraphicsResetStatus otherPacked)5383 CallCapture CaptureLoseContextCHROMIUM(const State &glState,
5384 bool isCallValid,
5385 GraphicsResetStatus currentPacked,
5386 GraphicsResetStatus otherPacked)
5387 {
5388 ParamBuffer paramBuffer;
5389
5390 paramBuffer.addValueParam("currentPacked", ParamType::TGraphicsResetStatus, currentPacked);
5391 paramBuffer.addValueParam("otherPacked", ParamType::TGraphicsResetStatus, otherPacked);
5392
5393 return CallCapture(angle::EntryPoint::GLLoseContextCHROMIUM, std::move(paramBuffer));
5394 }
5395
CaptureEGLImageTargetTexStorageEXT(const State & glState,bool isCallValid,GLenum target,egl::ImageID imagePacked,const GLint * attrib_list)5396 CallCapture CaptureEGLImageTargetTexStorageEXT(const State &glState,
5397 bool isCallValid,
5398 GLenum target,
5399 egl::ImageID imagePacked,
5400 const GLint *attrib_list)
5401 {
5402 ParamBuffer paramBuffer;
5403
5404 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
5405 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
5406
5407 if (isCallValid)
5408 {
5409 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5410 InitParamValue(ParamType::TGLintConstPointer, attrib_list, &attrib_listParam.value);
5411 CaptureEGLImageTargetTexStorageEXT_attrib_list(glState, isCallValid, target, imagePacked,
5412 attrib_list, &attrib_listParam);
5413 paramBuffer.addParam(std::move(attrib_listParam));
5414 }
5415 else
5416 {
5417 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5418 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
5419 &attrib_listParam.value);
5420 paramBuffer.addParam(std::move(attrib_listParam));
5421 }
5422
5423 return CallCapture(angle::EntryPoint::GLEGLImageTargetTexStorageEXT, std::move(paramBuffer));
5424 }
5425
CaptureEGLImageTargetTextureStorageEXT(const State & glState,bool isCallValid,GLuint texture,egl::ImageID imagePacked,const GLint * attrib_list)5426 CallCapture CaptureEGLImageTargetTextureStorageEXT(const State &glState,
5427 bool isCallValid,
5428 GLuint texture,
5429 egl::ImageID imagePacked,
5430 const GLint *attrib_list)
5431 {
5432 ParamBuffer paramBuffer;
5433
5434 paramBuffer.addValueParam("texture", ParamType::TGLuint, texture);
5435 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
5436
5437 if (isCallValid)
5438 {
5439 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5440 InitParamValue(ParamType::TGLintConstPointer, attrib_list, &attrib_listParam.value);
5441 CaptureEGLImageTargetTextureStorageEXT_attrib_list(
5442 glState, isCallValid, texture, imagePacked, attrib_list, &attrib_listParam);
5443 paramBuffer.addParam(std::move(attrib_listParam));
5444 }
5445 else
5446 {
5447 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5448 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
5449 &attrib_listParam.value);
5450 paramBuffer.addParam(std::move(attrib_listParam));
5451 }
5452
5453 return CallCapture(angle::EntryPoint::GLEGLImageTargetTextureStorageEXT,
5454 std::move(paramBuffer));
5455 }
5456
CaptureDrawArraysInstancedBaseInstanceEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei instancecount,GLuint baseinstance)5457 CallCapture CaptureDrawArraysInstancedBaseInstanceEXT(const State &glState,
5458 bool isCallValid,
5459 PrimitiveMode modePacked,
5460 GLint first,
5461 GLsizei count,
5462 GLsizei instancecount,
5463 GLuint baseinstance)
5464 {
5465 ParamBuffer paramBuffer;
5466
5467 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5468 paramBuffer.addValueParam("first", ParamType::TGLint, first);
5469 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5470 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5471 paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
5472
5473 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedBaseInstanceEXT,
5474 std::move(paramBuffer));
5475 }
5476
CaptureDrawElementsInstancedBaseInstanceEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLuint baseinstance)5477 CallCapture CaptureDrawElementsInstancedBaseInstanceEXT(const State &glState,
5478 bool isCallValid,
5479 PrimitiveMode modePacked,
5480 GLsizei count,
5481 DrawElementsType typePacked,
5482 const void *indices,
5483 GLsizei instancecount,
5484 GLuint baseinstance)
5485 {
5486 ParamBuffer paramBuffer;
5487
5488 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5489 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5490 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5491
5492 if (isCallValid)
5493 {
5494 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5495 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5496 CaptureDrawElementsInstancedBaseInstanceEXT_indices(glState, isCallValid, modePacked, count,
5497 typePacked, indices, instancecount,
5498 baseinstance, &indicesParam);
5499 paramBuffer.addParam(std::move(indicesParam));
5500 }
5501 else
5502 {
5503 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5504 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5505 &indicesParam.value);
5506 paramBuffer.addParam(std::move(indicesParam));
5507 }
5508
5509 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5510 paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
5511
5512 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseInstanceEXT,
5513 std::move(paramBuffer));
5514 }
5515
CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex,GLuint baseinstance)5516 CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT(const State &glState,
5517 bool isCallValid,
5518 PrimitiveMode modePacked,
5519 GLsizei count,
5520 DrawElementsType typePacked,
5521 const void *indices,
5522 GLsizei instancecount,
5523 GLint basevertex,
5524 GLuint baseinstance)
5525 {
5526 ParamBuffer paramBuffer;
5527
5528 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5529 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5530 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5531
5532 if (isCallValid)
5533 {
5534 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5535 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5536 CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT_indices(
5537 glState, isCallValid, modePacked, count, typePacked, indices, instancecount, basevertex,
5538 baseinstance, &indicesParam);
5539 paramBuffer.addParam(std::move(indicesParam));
5540 }
5541 else
5542 {
5543 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5544 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5545 &indicesParam.value);
5546 paramBuffer.addParam(std::move(indicesParam));
5547 }
5548
5549 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5550 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
5551 paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
5552
5553 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceEXT,
5554 std::move(paramBuffer));
5555 }
5556
CaptureBindFragDataLocationEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint color,const GLchar * name)5557 CallCapture CaptureBindFragDataLocationEXT(const State &glState,
5558 bool isCallValid,
5559 ShaderProgramID programPacked,
5560 GLuint color,
5561 const GLchar *name)
5562 {
5563 ParamBuffer paramBuffer;
5564
5565 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5566 paramBuffer.addValueParam("color", ParamType::TGLuint, color);
5567
5568 if (isCallValid)
5569 {
5570 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5571 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5572 CaptureBindFragDataLocationEXT_name(glState, isCallValid, programPacked, color, name,
5573 &nameParam);
5574 paramBuffer.addParam(std::move(nameParam));
5575 }
5576 else
5577 {
5578 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5579 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5580 &nameParam.value);
5581 paramBuffer.addParam(std::move(nameParam));
5582 }
5583
5584 return CallCapture(angle::EntryPoint::GLBindFragDataLocationEXT, std::move(paramBuffer));
5585 }
5586
CaptureBindFragDataLocationIndexedEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint colorNumber,GLuint index,const GLchar * name)5587 CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
5588 bool isCallValid,
5589 ShaderProgramID programPacked,
5590 GLuint colorNumber,
5591 GLuint index,
5592 const GLchar *name)
5593 {
5594 ParamBuffer paramBuffer;
5595
5596 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5597 paramBuffer.addValueParam("colorNumber", ParamType::TGLuint, colorNumber);
5598 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5599
5600 if (isCallValid)
5601 {
5602 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5603 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5604 CaptureBindFragDataLocationIndexedEXT_name(glState, isCallValid, programPacked, colorNumber,
5605 index, name, &nameParam);
5606 paramBuffer.addParam(std::move(nameParam));
5607 }
5608 else
5609 {
5610 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5611 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5612 &nameParam.value);
5613 paramBuffer.addParam(std::move(nameParam));
5614 }
5615
5616 return CallCapture(angle::EntryPoint::GLBindFragDataLocationIndexedEXT, std::move(paramBuffer));
5617 }
5618
CaptureGetFragDataIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,const GLchar * name,GLint returnValue)5619 CallCapture CaptureGetFragDataIndexEXT(const State &glState,
5620 bool isCallValid,
5621 ShaderProgramID programPacked,
5622 const GLchar *name,
5623 GLint returnValue)
5624 {
5625 ParamBuffer paramBuffer;
5626
5627 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5628
5629 if (isCallValid)
5630 {
5631 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5632 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5633 CaptureGetFragDataIndexEXT_name(glState, isCallValid, programPacked, name, &nameParam);
5634 paramBuffer.addParam(std::move(nameParam));
5635 }
5636 else
5637 {
5638 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5639 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5640 &nameParam.value);
5641 paramBuffer.addParam(std::move(nameParam));
5642 }
5643
5644 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
5645 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
5646 paramBuffer.addReturnValue(std::move(returnValueCapture));
5647
5648 return CallCapture(angle::EntryPoint::GLGetFragDataIndexEXT, std::move(paramBuffer));
5649 }
5650
CaptureGetProgramResourceLocationIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,const GLchar * name,GLint returnValue)5651 CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
5652 bool isCallValid,
5653 ShaderProgramID programPacked,
5654 GLenum programInterface,
5655 const GLchar *name,
5656 GLint returnValue)
5657 {
5658 ParamBuffer paramBuffer;
5659
5660 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5661 paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum,
5662 programInterface);
5663
5664 if (isCallValid)
5665 {
5666 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5667 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5668 CaptureGetProgramResourceLocationIndexEXT_name(glState, isCallValid, programPacked,
5669 programInterface, name, &nameParam);
5670 paramBuffer.addParam(std::move(nameParam));
5671 }
5672 else
5673 {
5674 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5675 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5676 &nameParam.value);
5677 paramBuffer.addParam(std::move(nameParam));
5678 }
5679
5680 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
5681 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
5682 paramBuffer.addReturnValue(std::move(returnValueCapture));
5683
5684 return CallCapture(angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
5685 std::move(paramBuffer));
5686 }
5687
CaptureBufferStorageEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLsizeiptr size,const void * data,GLbitfield flags)5688 CallCapture CaptureBufferStorageEXT(const State &glState,
5689 bool isCallValid,
5690 BufferBinding targetPacked,
5691 GLsizeiptr size,
5692 const void *data,
5693 GLbitfield flags)
5694 {
5695 ParamBuffer paramBuffer;
5696
5697 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5698 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
5699
5700 if (isCallValid)
5701 {
5702 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5703 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
5704 CaptureBufferStorageEXT_data(glState, isCallValid, targetPacked, size, data, flags,
5705 &dataParam);
5706 paramBuffer.addParam(std::move(dataParam));
5707 }
5708 else
5709 {
5710 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5711 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5712 &dataParam.value);
5713 paramBuffer.addParam(std::move(dataParam));
5714 }
5715
5716 paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
5717
5718 return CallCapture(angle::EntryPoint::GLBufferStorageEXT, std::move(paramBuffer));
5719 }
5720
CaptureClipControlEXT(const State & glState,bool isCallValid,ClipOrigin originPacked,ClipDepthMode depthPacked)5721 CallCapture CaptureClipControlEXT(const State &glState,
5722 bool isCallValid,
5723 ClipOrigin originPacked,
5724 ClipDepthMode depthPacked)
5725 {
5726 ParamBuffer paramBuffer;
5727
5728 paramBuffer.addValueParam("originPacked", ParamType::TClipOrigin, originPacked);
5729 paramBuffer.addValueParam("depthPacked", ParamType::TClipDepthMode, depthPacked);
5730
5731 return CallCapture(angle::EntryPoint::GLClipControlEXT, std::move(paramBuffer));
5732 }
5733
CaptureCopyImageSubDataEXT(const State & glState,bool isCallValid,GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth)5734 CallCapture CaptureCopyImageSubDataEXT(const State &glState,
5735 bool isCallValid,
5736 GLuint srcName,
5737 GLenum srcTarget,
5738 GLint srcLevel,
5739 GLint srcX,
5740 GLint srcY,
5741 GLint srcZ,
5742 GLuint dstName,
5743 GLenum dstTarget,
5744 GLint dstLevel,
5745 GLint dstX,
5746 GLint dstY,
5747 GLint dstZ,
5748 GLsizei srcWidth,
5749 GLsizei srcHeight,
5750 GLsizei srcDepth)
5751 {
5752 ParamBuffer paramBuffer;
5753
5754 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
5755 paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
5756 srcTarget);
5757 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
5758 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
5759 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
5760 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
5761 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
5762 paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
5763 dstTarget);
5764 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
5765 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
5766 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
5767 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
5768 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
5769 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
5770 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
5771
5772 return CallCapture(angle::EntryPoint::GLCopyImageSubDataEXT, std::move(paramBuffer));
5773 }
5774
CaptureGetObjectLabelEXT(const State & glState,bool isCallValid,GLenum type,GLuint object,GLsizei bufSize,GLsizei * length,GLchar * label)5775 CallCapture CaptureGetObjectLabelEXT(const State &glState,
5776 bool isCallValid,
5777 GLenum type,
5778 GLuint object,
5779 GLsizei bufSize,
5780 GLsizei *length,
5781 GLchar *label)
5782 {
5783 ParamBuffer paramBuffer;
5784
5785 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
5786 paramBuffer.addValueParam("object", ParamType::TGLuint, object);
5787 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5788
5789 if (isCallValid)
5790 {
5791 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5792 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
5793 CaptureGetObjectLabelEXT_length(glState, isCallValid, type, object, bufSize, length, label,
5794 &lengthParam);
5795 paramBuffer.addParam(std::move(lengthParam));
5796 }
5797 else
5798 {
5799 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5800 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
5801 &lengthParam.value);
5802 paramBuffer.addParam(std::move(lengthParam));
5803 }
5804
5805 if (isCallValid)
5806 {
5807 ParamCapture labelParam("label", ParamType::TGLcharPointer);
5808 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
5809 CaptureGetObjectLabelEXT_label(glState, isCallValid, type, object, bufSize, length, label,
5810 &labelParam);
5811 paramBuffer.addParam(std::move(labelParam));
5812 }
5813 else
5814 {
5815 ParamCapture labelParam("label", ParamType::TGLcharPointer);
5816 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
5817 &labelParam.value);
5818 paramBuffer.addParam(std::move(labelParam));
5819 }
5820
5821 return CallCapture(angle::EntryPoint::GLGetObjectLabelEXT, std::move(paramBuffer));
5822 }
5823
CaptureLabelObjectEXT(const State & glState,bool isCallValid,GLenum type,GLuint object,GLsizei length,const GLchar * label)5824 CallCapture CaptureLabelObjectEXT(const State &glState,
5825 bool isCallValid,
5826 GLenum type,
5827 GLuint object,
5828 GLsizei length,
5829 const GLchar *label)
5830 {
5831 ParamBuffer paramBuffer;
5832
5833 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
5834 paramBuffer.addValueParam("object", ParamType::TGLuint, object);
5835 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
5836
5837 if (isCallValid)
5838 {
5839 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
5840 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
5841 CaptureLabelObjectEXT_label(glState, isCallValid, type, object, length, label, &labelParam);
5842 paramBuffer.addParam(std::move(labelParam));
5843 }
5844 else
5845 {
5846 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
5847 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5848 &labelParam.value);
5849 paramBuffer.addParam(std::move(labelParam));
5850 }
5851
5852 return CallCapture(angle::EntryPoint::GLLabelObjectEXT, std::move(paramBuffer));
5853 }
5854
CaptureInsertEventMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)5855 CallCapture CaptureInsertEventMarkerEXT(const State &glState,
5856 bool isCallValid,
5857 GLsizei length,
5858 const GLchar *marker)
5859 {
5860 ParamBuffer paramBuffer;
5861
5862 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
5863
5864 if (isCallValid)
5865 {
5866 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
5867 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
5868 CaptureInsertEventMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
5869 paramBuffer.addParam(std::move(markerParam));
5870 }
5871 else
5872 {
5873 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
5874 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5875 &markerParam.value);
5876 paramBuffer.addParam(std::move(markerParam));
5877 }
5878
5879 return CallCapture(angle::EntryPoint::GLInsertEventMarkerEXT, std::move(paramBuffer));
5880 }
5881
CapturePopGroupMarkerEXT(const State & glState,bool isCallValid)5882 CallCapture CapturePopGroupMarkerEXT(const State &glState, bool isCallValid)
5883 {
5884 ParamBuffer paramBuffer;
5885
5886 return CallCapture(angle::EntryPoint::GLPopGroupMarkerEXT, std::move(paramBuffer));
5887 }
5888
CapturePushGroupMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)5889 CallCapture CapturePushGroupMarkerEXT(const State &glState,
5890 bool isCallValid,
5891 GLsizei length,
5892 const GLchar *marker)
5893 {
5894 ParamBuffer paramBuffer;
5895
5896 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
5897
5898 if (isCallValid)
5899 {
5900 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
5901 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
5902 CapturePushGroupMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
5903 paramBuffer.addParam(std::move(markerParam));
5904 }
5905 else
5906 {
5907 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
5908 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5909 &markerParam.value);
5910 paramBuffer.addParam(std::move(markerParam));
5911 }
5912
5913 return CallCapture(angle::EntryPoint::GLPushGroupMarkerEXT, std::move(paramBuffer));
5914 }
5915
CaptureDiscardFramebufferEXT(const State & glState,bool isCallValid,GLenum target,GLsizei numAttachments,const GLenum * attachments)5916 CallCapture CaptureDiscardFramebufferEXT(const State &glState,
5917 bool isCallValid,
5918 GLenum target,
5919 GLsizei numAttachments,
5920 const GLenum *attachments)
5921 {
5922 ParamBuffer paramBuffer;
5923
5924 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
5925 paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
5926
5927 if (isCallValid)
5928 {
5929 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
5930 InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
5931 CaptureDiscardFramebufferEXT_attachments(glState, isCallValid, target, numAttachments,
5932 attachments, &attachmentsParam);
5933 paramBuffer.addParam(std::move(attachmentsParam));
5934 }
5935 else
5936 {
5937 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
5938 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
5939 &attachmentsParam.value);
5940 paramBuffer.addParam(std::move(attachmentsParam));
5941 }
5942
5943 return CallCapture(angle::EntryPoint::GLDiscardFramebufferEXT, std::move(paramBuffer));
5944 }
5945
CaptureBeginQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked,QueryID idPacked)5946 CallCapture CaptureBeginQueryEXT(const State &glState,
5947 bool isCallValid,
5948 QueryType targetPacked,
5949 QueryID idPacked)
5950 {
5951 ParamBuffer paramBuffer;
5952
5953 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
5954 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
5955
5956 return CallCapture(angle::EntryPoint::GLBeginQueryEXT, std::move(paramBuffer));
5957 }
5958
CaptureDeleteQueriesEXT(const State & glState,bool isCallValid,GLsizei n,const QueryID * idsPacked)5959 CallCapture CaptureDeleteQueriesEXT(const State &glState,
5960 bool isCallValid,
5961 GLsizei n,
5962 const QueryID *idsPacked)
5963 {
5964 ParamBuffer paramBuffer;
5965
5966 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5967
5968 if (isCallValid)
5969 {
5970 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
5971 InitParamValue(ParamType::TQueryIDConstPointer, idsPacked, &idsPackedParam.value);
5972 CaptureDeleteQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
5973 paramBuffer.addParam(std::move(idsPackedParam));
5974 }
5975 else
5976 {
5977 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
5978 InitParamValue(ParamType::TQueryIDConstPointer, static_cast<const QueryID *>(nullptr),
5979 &idsPackedParam.value);
5980 paramBuffer.addParam(std::move(idsPackedParam));
5981 }
5982
5983 return CallCapture(angle::EntryPoint::GLDeleteQueriesEXT, std::move(paramBuffer));
5984 }
5985
CaptureEndQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked)5986 CallCapture CaptureEndQueryEXT(const State &glState, bool isCallValid, QueryType targetPacked)
5987 {
5988 ParamBuffer paramBuffer;
5989
5990 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
5991
5992 return CallCapture(angle::EntryPoint::GLEndQueryEXT, std::move(paramBuffer));
5993 }
5994
CaptureGenQueriesEXT(const State & glState,bool isCallValid,GLsizei n,QueryID * idsPacked)5995 CallCapture CaptureGenQueriesEXT(const State &glState,
5996 bool isCallValid,
5997 GLsizei n,
5998 QueryID *idsPacked)
5999 {
6000 ParamBuffer paramBuffer;
6001
6002 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6003
6004 if (isCallValid)
6005 {
6006 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
6007 InitParamValue(ParamType::TQueryIDPointer, idsPacked, &idsPackedParam.value);
6008 CaptureGenQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
6009 paramBuffer.addParam(std::move(idsPackedParam));
6010 }
6011 else
6012 {
6013 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
6014 InitParamValue(ParamType::TQueryIDPointer, static_cast<QueryID *>(nullptr),
6015 &idsPackedParam.value);
6016 paramBuffer.addParam(std::move(idsPackedParam));
6017 }
6018
6019 return CallCapture(angle::EntryPoint::GLGenQueriesEXT, std::move(paramBuffer));
6020 }
6021
CaptureGetInteger64vEXT(const State & glState,bool isCallValid,GLenum pname,GLint64 * data)6022 CallCapture CaptureGetInteger64vEXT(const State &glState,
6023 bool isCallValid,
6024 GLenum pname,
6025 GLint64 *data)
6026 {
6027 ParamBuffer paramBuffer;
6028
6029 paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname);
6030
6031 if (isCallValid)
6032 {
6033 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
6034 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
6035 CaptureGetInteger64vEXT_data(glState, isCallValid, pname, data, &dataParam);
6036 paramBuffer.addParam(std::move(dataParam));
6037 }
6038 else
6039 {
6040 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
6041 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
6042 &dataParam.value);
6043 paramBuffer.addParam(std::move(dataParam));
6044 }
6045
6046 return CallCapture(angle::EntryPoint::GLGetInteger64vEXT, std::move(paramBuffer));
6047 }
6048
CaptureGetQueryObjecti64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint64 * params)6049 CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
6050 bool isCallValid,
6051 QueryID idPacked,
6052 GLenum pname,
6053 GLint64 *params)
6054 {
6055 ParamBuffer paramBuffer;
6056
6057 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6058 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6059 pname);
6060
6061 if (isCallValid)
6062 {
6063 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
6064 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
6065 CaptureGetQueryObjecti64vEXT_params(glState, isCallValid, idPacked, pname, params,
6066 ¶msParam);
6067 paramBuffer.addParam(std::move(paramsParam));
6068 }
6069 else
6070 {
6071 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
6072 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
6073 ¶msParam.value);
6074 paramBuffer.addParam(std::move(paramsParam));
6075 }
6076
6077 return CallCapture(angle::EntryPoint::GLGetQueryObjecti64vEXT, std::move(paramBuffer));
6078 }
6079
CaptureGetQueryObjectivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint * params)6080 CallCapture CaptureGetQueryObjectivEXT(const State &glState,
6081 bool isCallValid,
6082 QueryID idPacked,
6083 GLenum pname,
6084 GLint *params)
6085 {
6086 ParamBuffer paramBuffer;
6087
6088 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6089 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6090 pname);
6091
6092 if (isCallValid)
6093 {
6094 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6095 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6096 CaptureGetQueryObjectivEXT_params(glState, isCallValid, idPacked, pname, params,
6097 ¶msParam);
6098 paramBuffer.addParam(std::move(paramsParam));
6099 }
6100 else
6101 {
6102 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6103 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6104 paramBuffer.addParam(std::move(paramsParam));
6105 }
6106
6107 return CallCapture(angle::EntryPoint::GLGetQueryObjectivEXT, std::move(paramBuffer));
6108 }
6109
CaptureGetQueryObjectui64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint64 * params)6110 CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
6111 bool isCallValid,
6112 QueryID idPacked,
6113 GLenum pname,
6114 GLuint64 *params)
6115 {
6116 ParamBuffer paramBuffer;
6117
6118 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6119 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6120 pname);
6121
6122 if (isCallValid)
6123 {
6124 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
6125 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
6126 CaptureGetQueryObjectui64vEXT_params(glState, isCallValid, idPacked, pname, params,
6127 ¶msParam);
6128 paramBuffer.addParam(std::move(paramsParam));
6129 }
6130 else
6131 {
6132 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
6133 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
6134 ¶msParam.value);
6135 paramBuffer.addParam(std::move(paramsParam));
6136 }
6137
6138 return CallCapture(angle::EntryPoint::GLGetQueryObjectui64vEXT, std::move(paramBuffer));
6139 }
6140
CaptureGetQueryObjectuivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint * params)6141 CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
6142 bool isCallValid,
6143 QueryID idPacked,
6144 GLenum pname,
6145 GLuint *params)
6146 {
6147 ParamBuffer paramBuffer;
6148
6149 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6150 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6151 pname);
6152
6153 if (isCallValid)
6154 {
6155 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
6156 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
6157 CaptureGetQueryObjectuivEXT_params(glState, isCallValid, idPacked, pname, params,
6158 ¶msParam);
6159 paramBuffer.addParam(std::move(paramsParam));
6160 }
6161 else
6162 {
6163 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
6164 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
6165 ¶msParam.value);
6166 paramBuffer.addParam(std::move(paramsParam));
6167 }
6168
6169 return CallCapture(angle::EntryPoint::GLGetQueryObjectuivEXT, std::move(paramBuffer));
6170 }
6171
CaptureGetQueryivEXT(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLint * params)6172 CallCapture CaptureGetQueryivEXT(const State &glState,
6173 bool isCallValid,
6174 QueryType targetPacked,
6175 GLenum pname,
6176 GLint *params)
6177 {
6178 ParamBuffer paramBuffer;
6179
6180 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
6181 paramBuffer.addEnumParam("pname", GLESEnum::QueryParameterName, ParamType::TGLenum, pname);
6182
6183 if (isCallValid)
6184 {
6185 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6186 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6187 CaptureGetQueryivEXT_params(glState, isCallValid, targetPacked, pname, params,
6188 ¶msParam);
6189 paramBuffer.addParam(std::move(paramsParam));
6190 }
6191 else
6192 {
6193 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6194 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6195 paramBuffer.addParam(std::move(paramsParam));
6196 }
6197
6198 return CallCapture(angle::EntryPoint::GLGetQueryivEXT, std::move(paramBuffer));
6199 }
6200
CaptureIsQueryEXT(const State & glState,bool isCallValid,QueryID idPacked,GLboolean returnValue)6201 CallCapture CaptureIsQueryEXT(const State &glState,
6202 bool isCallValid,
6203 QueryID idPacked,
6204 GLboolean returnValue)
6205 {
6206 ParamBuffer paramBuffer;
6207
6208 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6209
6210 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6211 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6212 paramBuffer.addReturnValue(std::move(returnValueCapture));
6213
6214 return CallCapture(angle::EntryPoint::GLIsQueryEXT, std::move(paramBuffer));
6215 }
6216
CaptureQueryCounterEXT(const State & glState,bool isCallValid,QueryID idPacked,QueryType targetPacked)6217 CallCapture CaptureQueryCounterEXT(const State &glState,
6218 bool isCallValid,
6219 QueryID idPacked,
6220 QueryType targetPacked)
6221 {
6222 ParamBuffer paramBuffer;
6223
6224 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6225 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
6226
6227 return CallCapture(angle::EntryPoint::GLQueryCounterEXT, std::move(paramBuffer));
6228 }
6229
CaptureDrawBuffersEXT(const State & glState,bool isCallValid,GLsizei n,const GLenum * bufs)6230 CallCapture CaptureDrawBuffersEXT(const State &glState,
6231 bool isCallValid,
6232 GLsizei n,
6233 const GLenum *bufs)
6234 {
6235 ParamBuffer paramBuffer;
6236
6237 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6238
6239 if (isCallValid)
6240 {
6241 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
6242 InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
6243 CaptureDrawBuffersEXT_bufs(glState, isCallValid, n, bufs, &bufsParam);
6244 paramBuffer.addParam(std::move(bufsParam));
6245 }
6246 else
6247 {
6248 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
6249 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
6250 &bufsParam.value);
6251 paramBuffer.addParam(std::move(bufsParam));
6252 }
6253
6254 return CallCapture(angle::EntryPoint::GLDrawBuffersEXT, std::move(paramBuffer));
6255 }
6256
CaptureBlendEquationSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)6257 CallCapture CaptureBlendEquationSeparateiEXT(const State &glState,
6258 bool isCallValid,
6259 GLuint buf,
6260 GLenum modeRGB,
6261 GLenum modeAlpha)
6262 {
6263 ParamBuffer paramBuffer;
6264
6265 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6266 paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
6267 modeRGB);
6268 paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
6269 modeAlpha);
6270
6271 return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiEXT, std::move(paramBuffer));
6272 }
6273
CaptureBlendEquationiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum mode)6274 CallCapture CaptureBlendEquationiEXT(const State &glState,
6275 bool isCallValid,
6276 GLuint buf,
6277 GLenum mode)
6278 {
6279 ParamBuffer paramBuffer;
6280
6281 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6282 paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode);
6283
6284 return CallCapture(angle::EntryPoint::GLBlendEquationiEXT, std::move(paramBuffer));
6285 }
6286
CaptureBlendFuncSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)6287 CallCapture CaptureBlendFuncSeparateiEXT(const State &glState,
6288 bool isCallValid,
6289 GLuint buf,
6290 GLenum srcRGB,
6291 GLenum dstRGB,
6292 GLenum srcAlpha,
6293 GLenum dstAlpha)
6294 {
6295 ParamBuffer paramBuffer;
6296
6297 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6298 paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB);
6299 paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB);
6300 paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha);
6301 paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha);
6302
6303 return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiEXT, std::move(paramBuffer));
6304 }
6305
CaptureBlendFunciEXT(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)6306 CallCapture CaptureBlendFunciEXT(const State &glState,
6307 bool isCallValid,
6308 GLuint buf,
6309 GLenum src,
6310 GLenum dst)
6311 {
6312 ParamBuffer paramBuffer;
6313
6314 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6315 paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src);
6316 paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst);
6317
6318 return CallCapture(angle::EntryPoint::GLBlendFunciEXT, std::move(paramBuffer));
6319 }
6320
CaptureColorMaskiEXT(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)6321 CallCapture CaptureColorMaskiEXT(const State &glState,
6322 bool isCallValid,
6323 GLuint index,
6324 GLboolean r,
6325 GLboolean g,
6326 GLboolean b,
6327 GLboolean a)
6328 {
6329 ParamBuffer paramBuffer;
6330
6331 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6332 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
6333 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
6334 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
6335 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
6336
6337 return CallCapture(angle::EntryPoint::GLColorMaskiEXT, std::move(paramBuffer));
6338 }
6339
CaptureDisableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)6340 CallCapture CaptureDisableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
6341 {
6342 ParamBuffer paramBuffer;
6343
6344 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
6345 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6346
6347 return CallCapture(angle::EntryPoint::GLDisableiEXT, std::move(paramBuffer));
6348 }
6349
CaptureEnableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)6350 CallCapture CaptureEnableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
6351 {
6352 ParamBuffer paramBuffer;
6353
6354 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
6355 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6356
6357 return CallCapture(angle::EntryPoint::GLEnableiEXT, std::move(paramBuffer));
6358 }
6359
CaptureIsEnablediEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)6360 CallCapture CaptureIsEnablediEXT(const State &glState,
6361 bool isCallValid,
6362 GLenum target,
6363 GLuint index,
6364 GLboolean returnValue)
6365 {
6366 ParamBuffer paramBuffer;
6367
6368 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
6369 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6370
6371 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6372 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6373 paramBuffer.addReturnValue(std::move(returnValueCapture));
6374
6375 return CallCapture(angle::EntryPoint::GLIsEnablediEXT, std::move(paramBuffer));
6376 }
6377
CaptureDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)6378 CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
6379 bool isCallValid,
6380 PrimitiveMode modePacked,
6381 GLsizei count,
6382 DrawElementsType typePacked,
6383 const void *indices,
6384 GLint basevertex)
6385 {
6386 ParamBuffer paramBuffer;
6387
6388 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6389 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6390 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6391
6392 if (isCallValid)
6393 {
6394 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6395 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6396 CaptureDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
6397 typePacked, indices, basevertex, &indicesParam);
6398 paramBuffer.addParam(std::move(indicesParam));
6399 }
6400 else
6401 {
6402 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6403 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6404 &indicesParam.value);
6405 paramBuffer.addParam(std::move(indicesParam));
6406 }
6407
6408 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
6409
6410 return CallCapture(angle::EntryPoint::GLDrawElementsBaseVertexEXT, std::move(paramBuffer));
6411 }
6412
CaptureDrawElementsInstancedBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)6413 CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
6414 bool isCallValid,
6415 PrimitiveMode modePacked,
6416 GLsizei count,
6417 DrawElementsType typePacked,
6418 const void *indices,
6419 GLsizei instancecount,
6420 GLint basevertex)
6421 {
6422 ParamBuffer paramBuffer;
6423
6424 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6425 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6426 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6427
6428 if (isCallValid)
6429 {
6430 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6431 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6432 CaptureDrawElementsInstancedBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
6433 typePacked, indices, instancecount,
6434 basevertex, &indicesParam);
6435 paramBuffer.addParam(std::move(indicesParam));
6436 }
6437 else
6438 {
6439 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6440 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6441 &indicesParam.value);
6442 paramBuffer.addParam(std::move(indicesParam));
6443 }
6444
6445 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
6446 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
6447
6448 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexEXT,
6449 std::move(paramBuffer));
6450 }
6451
CaptureDrawRangeElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)6452 CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
6453 bool isCallValid,
6454 PrimitiveMode modePacked,
6455 GLuint start,
6456 GLuint end,
6457 GLsizei count,
6458 DrawElementsType typePacked,
6459 const void *indices,
6460 GLint basevertex)
6461 {
6462 ParamBuffer paramBuffer;
6463
6464 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6465 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
6466 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
6467 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6468 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6469
6470 if (isCallValid)
6471 {
6472 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6473 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6474 CaptureDrawRangeElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, start, end,
6475 count, typePacked, indices, basevertex,
6476 &indicesParam);
6477 paramBuffer.addParam(std::move(indicesParam));
6478 }
6479 else
6480 {
6481 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6482 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6483 &indicesParam.value);
6484 paramBuffer.addParam(std::move(indicesParam));
6485 }
6486
6487 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
6488
6489 return CallCapture(angle::EntryPoint::GLDrawRangeElementsBaseVertexEXT, std::move(paramBuffer));
6490 }
6491
CaptureMultiDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount,const GLint * basevertex)6492 CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
6493 bool isCallValid,
6494 PrimitiveMode modePacked,
6495 const GLsizei *count,
6496 DrawElementsType typePacked,
6497 const void *const *indices,
6498 GLsizei drawcount,
6499 const GLint *basevertex)
6500 {
6501 ParamBuffer paramBuffer;
6502
6503 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6504
6505 if (isCallValid)
6506 {
6507 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
6508 InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value);
6509 CaptureMultiDrawElementsBaseVertexEXT_count(glState, isCallValid, modePacked, count,
6510 typePacked, indices, drawcount, basevertex,
6511 &countParam);
6512 paramBuffer.addParam(std::move(countParam));
6513 }
6514 else
6515 {
6516 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
6517 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
6518 &countParam.value);
6519 paramBuffer.addParam(std::move(countParam));
6520 }
6521
6522 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6523
6524 if (isCallValid)
6525 {
6526 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
6527 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
6528 CaptureMultiDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
6529 typePacked, indices, drawcount, basevertex,
6530 &indicesParam);
6531 paramBuffer.addParam(std::move(indicesParam));
6532 }
6533 else
6534 {
6535 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
6536 InitParamValue(ParamType::TvoidConstPointerPointer,
6537 static_cast<const void *const *>(nullptr), &indicesParam.value);
6538 paramBuffer.addParam(std::move(indicesParam));
6539 }
6540
6541 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
6542
6543 if (isCallValid)
6544 {
6545 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
6546 InitParamValue(ParamType::TGLintConstPointer, basevertex, &basevertexParam.value);
6547 CaptureMultiDrawElementsBaseVertexEXT_basevertex(glState, isCallValid, modePacked, count,
6548 typePacked, indices, drawcount, basevertex,
6549 &basevertexParam);
6550 paramBuffer.addParam(std::move(basevertexParam));
6551 }
6552 else
6553 {
6554 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
6555 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
6556 &basevertexParam.value);
6557 paramBuffer.addParam(std::move(basevertexParam));
6558 }
6559
6560 return CallCapture(angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT, std::move(paramBuffer));
6561 }
6562
CaptureBufferStorageExternalEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)6563 CallCapture CaptureBufferStorageExternalEXT(const State &glState,
6564 bool isCallValid,
6565 BufferBinding targetPacked,
6566 GLintptr offset,
6567 GLsizeiptr size,
6568 GLeglClientBufferEXT clientBuffer,
6569 GLbitfield flags)
6570 {
6571 ParamBuffer paramBuffer;
6572
6573 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
6574 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6575 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6576 paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer);
6577 paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
6578
6579 return CallCapture(angle::EntryPoint::GLBufferStorageExternalEXT, std::move(paramBuffer));
6580 }
6581
CaptureNamedBufferStorageExternalEXT(const State & glState,bool isCallValid,GLuint buffer,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)6582 CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState,
6583 bool isCallValid,
6584 GLuint buffer,
6585 GLintptr offset,
6586 GLsizeiptr size,
6587 GLeglClientBufferEXT clientBuffer,
6588 GLbitfield flags)
6589 {
6590 ParamBuffer paramBuffer;
6591
6592 paramBuffer.addValueParam("buffer", ParamType::TGLuint, buffer);
6593 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6594 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6595 paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer);
6596 paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
6597
6598 return CallCapture(angle::EntryPoint::GLNamedBufferStorageExternalEXT, std::move(paramBuffer));
6599 }
6600
CaptureFramebufferTextureEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)6601 CallCapture CaptureFramebufferTextureEXT(const State &glState,
6602 bool isCallValid,
6603 GLenum target,
6604 GLenum attachment,
6605 TextureID texturePacked,
6606 GLint level)
6607 {
6608 ParamBuffer paramBuffer;
6609
6610 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
6611 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
6612 attachment);
6613 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
6614 paramBuffer.addValueParam("level", ParamType::TGLint, level);
6615
6616 return CallCapture(angle::EntryPoint::GLFramebufferTextureEXT, std::move(paramBuffer));
6617 }
6618
CaptureDrawArraysInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint start,GLsizei count,GLsizei primcount)6619 CallCapture CaptureDrawArraysInstancedEXT(const State &glState,
6620 bool isCallValid,
6621 PrimitiveMode modePacked,
6622 GLint start,
6623 GLsizei count,
6624 GLsizei primcount)
6625 {
6626 ParamBuffer paramBuffer;
6627
6628 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6629 paramBuffer.addValueParam("start", ParamType::TGLint, start);
6630 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6631 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
6632
6633 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedEXT, std::move(paramBuffer));
6634 }
6635
CaptureDrawElementsInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)6636 CallCapture CaptureDrawElementsInstancedEXT(const State &glState,
6637 bool isCallValid,
6638 PrimitiveMode modePacked,
6639 GLsizei count,
6640 DrawElementsType typePacked,
6641 const void *indices,
6642 GLsizei primcount)
6643 {
6644 ParamBuffer paramBuffer;
6645
6646 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6647 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6648 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6649
6650 if (isCallValid)
6651 {
6652 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6653 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6654 CaptureDrawElementsInstancedEXT_indices(glState, isCallValid, modePacked, count, typePacked,
6655 indices, primcount, &indicesParam);
6656 paramBuffer.addParam(std::move(indicesParam));
6657 }
6658 else
6659 {
6660 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6661 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6662 &indicesParam.value);
6663 paramBuffer.addParam(std::move(indicesParam));
6664 }
6665
6666 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
6667
6668 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedEXT, std::move(paramBuffer));
6669 }
6670
CaptureVertexAttribDivisorEXT(const State & glState,bool isCallValid,GLuint index,GLuint divisor)6671 CallCapture CaptureVertexAttribDivisorEXT(const State &glState,
6672 bool isCallValid,
6673 GLuint index,
6674 GLuint divisor)
6675 {
6676 ParamBuffer paramBuffer;
6677
6678 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6679 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
6680
6681 return CallCapture(angle::EntryPoint::GLVertexAttribDivisorEXT, std::move(paramBuffer));
6682 }
6683
CaptureFlushMappedBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length)6684 CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState,
6685 bool isCallValid,
6686 BufferBinding targetPacked,
6687 GLintptr offset,
6688 GLsizeiptr length)
6689 {
6690 ParamBuffer paramBuffer;
6691
6692 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
6693 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6694 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
6695
6696 return CallCapture(angle::EntryPoint::GLFlushMappedBufferRangeEXT, std::move(paramBuffer));
6697 }
6698
CaptureMapBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length,GLbitfield access,void * returnValue)6699 CallCapture CaptureMapBufferRangeEXT(const State &glState,
6700 bool isCallValid,
6701 BufferBinding targetPacked,
6702 GLintptr offset,
6703 GLsizeiptr length,
6704 GLbitfield access,
6705 void *returnValue)
6706 {
6707 ParamBuffer paramBuffer;
6708
6709 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
6710 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6711 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
6712 paramBuffer.addEnumParam("access", GLESEnum::MapBufferAccessMask, ParamType::TGLbitfield,
6713 access);
6714
6715 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
6716 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
6717 paramBuffer.addReturnValue(std::move(returnValueCapture));
6718
6719 return CallCapture(angle::EntryPoint::GLMapBufferRangeEXT, std::move(paramBuffer));
6720 }
6721
CaptureBufferStorageMemEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizeiptr size,MemoryObjectID memoryPacked,GLuint64 offset)6722 CallCapture CaptureBufferStorageMemEXT(const State &glState,
6723 bool isCallValid,
6724 TextureType targetPacked,
6725 GLsizeiptr size,
6726 MemoryObjectID memoryPacked,
6727 GLuint64 offset)
6728 {
6729 ParamBuffer paramBuffer;
6730
6731 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6732 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6733 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
6734 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
6735
6736 return CallCapture(angle::EntryPoint::GLBufferStorageMemEXT, std::move(paramBuffer));
6737 }
6738
CaptureCreateMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,MemoryObjectID * memoryObjectsPacked)6739 CallCapture CaptureCreateMemoryObjectsEXT(const State &glState,
6740 bool isCallValid,
6741 GLsizei n,
6742 MemoryObjectID *memoryObjectsPacked)
6743 {
6744 ParamBuffer paramBuffer;
6745
6746 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6747
6748 if (isCallValid)
6749 {
6750 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6751 ParamType::TMemoryObjectIDPointer);
6752 InitParamValue(ParamType::TMemoryObjectIDPointer, memoryObjectsPacked,
6753 &memoryObjectsPackedParam.value);
6754 CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(
6755 glState, isCallValid, n, memoryObjectsPacked, &memoryObjectsPackedParam);
6756 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6757 }
6758 else
6759 {
6760 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6761 ParamType::TMemoryObjectIDPointer);
6762 InitParamValue(ParamType::TMemoryObjectIDPointer, static_cast<MemoryObjectID *>(nullptr),
6763 &memoryObjectsPackedParam.value);
6764 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6765 }
6766
6767 return CallCapture(angle::EntryPoint::GLCreateMemoryObjectsEXT, std::move(paramBuffer));
6768 }
6769
CaptureDeleteMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,const MemoryObjectID * memoryObjectsPacked)6770 CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState,
6771 bool isCallValid,
6772 GLsizei n,
6773 const MemoryObjectID *memoryObjectsPacked)
6774 {
6775 ParamBuffer paramBuffer;
6776
6777 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6778
6779 if (isCallValid)
6780 {
6781 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6782 ParamType::TMemoryObjectIDConstPointer);
6783 InitParamValue(ParamType::TMemoryObjectIDConstPointer, memoryObjectsPacked,
6784 &memoryObjectsPackedParam.value);
6785 CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(
6786 glState, isCallValid, n, memoryObjectsPacked, &memoryObjectsPackedParam);
6787 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6788 }
6789 else
6790 {
6791 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6792 ParamType::TMemoryObjectIDConstPointer);
6793 InitParamValue(ParamType::TMemoryObjectIDConstPointer,
6794 static_cast<const MemoryObjectID *>(nullptr),
6795 &memoryObjectsPackedParam.value);
6796 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6797 }
6798
6799 return CallCapture(angle::EntryPoint::GLDeleteMemoryObjectsEXT, std::move(paramBuffer));
6800 }
6801
CaptureGetMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,GLint * params)6802 CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState,
6803 bool isCallValid,
6804 MemoryObjectID memoryObjectPacked,
6805 GLenum pname,
6806 GLint *params)
6807 {
6808 ParamBuffer paramBuffer;
6809
6810 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
6811 paramBuffer.addEnumParam("pname", GLESEnum::MemoryObjectParameterName, ParamType::TGLenum,
6812 pname);
6813
6814 if (isCallValid)
6815 {
6816 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6817 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6818 CaptureGetMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
6819 params, ¶msParam);
6820 paramBuffer.addParam(std::move(paramsParam));
6821 }
6822 else
6823 {
6824 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6825 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6826 paramBuffer.addParam(std::move(paramsParam));
6827 }
6828
6829 return CallCapture(angle::EntryPoint::GLGetMemoryObjectParameterivEXT, std::move(paramBuffer));
6830 }
6831
CaptureGetUnsignedBytevEXT(const State & glState,bool isCallValid,GLenum pname,GLubyte * data)6832 CallCapture CaptureGetUnsignedBytevEXT(const State &glState,
6833 bool isCallValid,
6834 GLenum pname,
6835 GLubyte *data)
6836 {
6837 ParamBuffer paramBuffer;
6838
6839 paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname);
6840
6841 if (isCallValid)
6842 {
6843 ParamCapture dataParam("data", ParamType::TGLubytePointer);
6844 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
6845 CaptureGetUnsignedBytevEXT_data(glState, isCallValid, pname, data, &dataParam);
6846 paramBuffer.addParam(std::move(dataParam));
6847 }
6848 else
6849 {
6850 ParamCapture dataParam("data", ParamType::TGLubytePointer);
6851 InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
6852 &dataParam.value);
6853 paramBuffer.addParam(std::move(dataParam));
6854 }
6855
6856 return CallCapture(angle::EntryPoint::GLGetUnsignedBytevEXT, std::move(paramBuffer));
6857 }
6858
CaptureGetUnsignedBytei_vEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLubyte * data)6859 CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState,
6860 bool isCallValid,
6861 GLenum target,
6862 GLuint index,
6863 GLubyte *data)
6864 {
6865 ParamBuffer paramBuffer;
6866
6867 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
6868 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6869
6870 if (isCallValid)
6871 {
6872 ParamCapture dataParam("data", ParamType::TGLubytePointer);
6873 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
6874 CaptureGetUnsignedBytei_vEXT_data(glState, isCallValid, target, index, data, &dataParam);
6875 paramBuffer.addParam(std::move(dataParam));
6876 }
6877 else
6878 {
6879 ParamCapture dataParam("data", ParamType::TGLubytePointer);
6880 InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
6881 &dataParam.value);
6882 paramBuffer.addParam(std::move(dataParam));
6883 }
6884
6885 return CallCapture(angle::EntryPoint::GLGetUnsignedBytei_vEXT, std::move(paramBuffer));
6886 }
6887
CaptureIsMemoryObjectEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLboolean returnValue)6888 CallCapture CaptureIsMemoryObjectEXT(const State &glState,
6889 bool isCallValid,
6890 MemoryObjectID memoryObjectPacked,
6891 GLboolean returnValue)
6892 {
6893 ParamBuffer paramBuffer;
6894
6895 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
6896
6897 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6898 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6899 paramBuffer.addReturnValue(std::move(returnValueCapture));
6900
6901 return CallCapture(angle::EntryPoint::GLIsMemoryObjectEXT, std::move(paramBuffer));
6902 }
6903
CaptureMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,const GLint * params)6904 CallCapture CaptureMemoryObjectParameterivEXT(const State &glState,
6905 bool isCallValid,
6906 MemoryObjectID memoryObjectPacked,
6907 GLenum pname,
6908 const GLint *params)
6909 {
6910 ParamBuffer paramBuffer;
6911
6912 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
6913 paramBuffer.addEnumParam("pname", GLESEnum::MemoryObjectParameterName, ParamType::TGLenum,
6914 pname);
6915
6916 if (isCallValid)
6917 {
6918 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
6919 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
6920 CaptureMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
6921 params, ¶msParam);
6922 paramBuffer.addParam(std::move(paramsParam));
6923 }
6924 else
6925 {
6926 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
6927 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
6928 ¶msParam.value);
6929 paramBuffer.addParam(std::move(paramsParam));
6930 }
6931
6932 return CallCapture(angle::EntryPoint::GLMemoryObjectParameterivEXT, std::move(paramBuffer));
6933 }
6934
CaptureTexStorageMem2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,MemoryObjectID memoryPacked,GLuint64 offset)6935 CallCapture CaptureTexStorageMem2DEXT(const State &glState,
6936 bool isCallValid,
6937 TextureType targetPacked,
6938 GLsizei levels,
6939 GLenum internalFormat,
6940 GLsizei width,
6941 GLsizei height,
6942 MemoryObjectID memoryPacked,
6943 GLuint64 offset)
6944 {
6945 ParamBuffer paramBuffer;
6946
6947 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6948 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
6949 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
6950 internalFormat);
6951 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
6952 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
6953 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
6954 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
6955
6956 return CallCapture(angle::EntryPoint::GLTexStorageMem2DEXT, std::move(paramBuffer));
6957 }
6958
CaptureTexStorageMem2DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)6959 CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState,
6960 bool isCallValid,
6961 TextureType targetPacked,
6962 GLsizei samples,
6963 GLenum internalFormat,
6964 GLsizei width,
6965 GLsizei height,
6966 GLboolean fixedSampleLocations,
6967 MemoryObjectID memoryPacked,
6968 GLuint64 offset)
6969 {
6970 ParamBuffer paramBuffer;
6971
6972 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6973 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
6974 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
6975 internalFormat);
6976 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
6977 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
6978 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
6979 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
6980 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
6981
6982 return CallCapture(angle::EntryPoint::GLTexStorageMem2DMultisampleEXT, std::move(paramBuffer));
6983 }
6984
CaptureTexStorageMem3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,MemoryObjectID memoryPacked,GLuint64 offset)6985 CallCapture CaptureTexStorageMem3DEXT(const State &glState,
6986 bool isCallValid,
6987 TextureType targetPacked,
6988 GLsizei levels,
6989 GLenum internalFormat,
6990 GLsizei width,
6991 GLsizei height,
6992 GLsizei depth,
6993 MemoryObjectID memoryPacked,
6994 GLuint64 offset)
6995 {
6996 ParamBuffer paramBuffer;
6997
6998 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6999 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
7000 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
7001 internalFormat);
7002 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7003 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7004 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
7005 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7006 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
7007
7008 return CallCapture(angle::EntryPoint::GLTexStorageMem3DEXT, std::move(paramBuffer));
7009 }
7010
CaptureTexStorageMem3DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)7011 CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState,
7012 bool isCallValid,
7013 TextureType targetPacked,
7014 GLsizei samples,
7015 GLenum internalFormat,
7016 GLsizei width,
7017 GLsizei height,
7018 GLsizei depth,
7019 GLboolean fixedSampleLocations,
7020 MemoryObjectID memoryPacked,
7021 GLuint64 offset)
7022 {
7023 ParamBuffer paramBuffer;
7024
7025 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
7026 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7027 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
7028 internalFormat);
7029 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7030 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7031 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
7032 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
7033 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7034 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
7035
7036 return CallCapture(angle::EntryPoint::GLTexStorageMem3DMultisampleEXT, std::move(paramBuffer));
7037 }
7038
CaptureImportMemoryFdEXT(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLint fd)7039 CallCapture CaptureImportMemoryFdEXT(const State &glState,
7040 bool isCallValid,
7041 MemoryObjectID memoryPacked,
7042 GLuint64 size,
7043 HandleType handleTypePacked,
7044 GLint fd)
7045 {
7046 ParamBuffer paramBuffer;
7047
7048 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7049 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
7050 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
7051 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
7052
7053 return CallCapture(angle::EntryPoint::GLImportMemoryFdEXT, std::move(paramBuffer));
7054 }
7055
CaptureMultiDrawArraysIndirectEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,const void * indirect,GLsizei drawcount,GLsizei stride)7056 CallCapture CaptureMultiDrawArraysIndirectEXT(const State &glState,
7057 bool isCallValid,
7058 PrimitiveMode modePacked,
7059 const void *indirect,
7060 GLsizei drawcount,
7061 GLsizei stride)
7062 {
7063 ParamBuffer paramBuffer;
7064
7065 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7066
7067 if (isCallValid)
7068 {
7069 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7070 InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
7071 CaptureMultiDrawArraysIndirectEXT_indirect(glState, isCallValid, modePacked, indirect,
7072 drawcount, stride, &indirectParam);
7073 paramBuffer.addParam(std::move(indirectParam));
7074 }
7075 else
7076 {
7077 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7078 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7079 &indirectParam.value);
7080 paramBuffer.addParam(std::move(indirectParam));
7081 }
7082
7083 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
7084 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
7085
7086 return CallCapture(angle::EntryPoint::GLMultiDrawArraysIndirectEXT, std::move(paramBuffer));
7087 }
7088
CaptureMultiDrawElementsIndirectEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,DrawElementsType typePacked,const void * indirect,GLsizei drawcount,GLsizei stride)7089 CallCapture CaptureMultiDrawElementsIndirectEXT(const State &glState,
7090 bool isCallValid,
7091 PrimitiveMode modePacked,
7092 DrawElementsType typePacked,
7093 const void *indirect,
7094 GLsizei drawcount,
7095 GLsizei stride)
7096 {
7097 ParamBuffer paramBuffer;
7098
7099 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7100 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
7101
7102 if (isCallValid)
7103 {
7104 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7105 InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
7106 CaptureMultiDrawElementsIndirectEXT_indirect(glState, isCallValid, modePacked, typePacked,
7107 indirect, drawcount, stride, &indirectParam);
7108 paramBuffer.addParam(std::move(indirectParam));
7109 }
7110 else
7111 {
7112 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7113 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7114 &indirectParam.value);
7115 paramBuffer.addParam(std::move(indirectParam));
7116 }
7117
7118 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
7119 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
7120
7121 return CallCapture(angle::EntryPoint::GLMultiDrawElementsIndirectEXT, std::move(paramBuffer));
7122 }
7123
CaptureFramebufferTexture2DMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLsizei samples)7124 CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
7125 bool isCallValid,
7126 GLenum target,
7127 GLenum attachment,
7128 TextureTarget textargetPacked,
7129 TextureID texturePacked,
7130 GLint level,
7131 GLsizei samples)
7132 {
7133 ParamBuffer paramBuffer;
7134
7135 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
7136 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
7137 attachment);
7138 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
7139 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
7140 paramBuffer.addValueParam("level", ParamType::TGLint, level);
7141 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7142
7143 return CallCapture(angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT,
7144 std::move(paramBuffer));
7145 }
7146
CaptureRenderbufferStorageMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)7147 CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
7148 bool isCallValid,
7149 GLenum target,
7150 GLsizei samples,
7151 GLenum internalformat,
7152 GLsizei width,
7153 GLsizei height)
7154 {
7155 ParamBuffer paramBuffer;
7156
7157 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
7158 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7159 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
7160 internalformat);
7161 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7162 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7163
7164 return CallCapture(angle::EntryPoint::GLRenderbufferStorageMultisampleEXT,
7165 std::move(paramBuffer));
7166 }
7167
CapturePolygonOffsetClampEXT(const State & glState,bool isCallValid,GLfloat factor,GLfloat units,GLfloat clamp)7168 CallCapture CapturePolygonOffsetClampEXT(const State &glState,
7169 bool isCallValid,
7170 GLfloat factor,
7171 GLfloat units,
7172 GLfloat clamp)
7173 {
7174 ParamBuffer paramBuffer;
7175
7176 paramBuffer.addValueParam("factor", ParamType::TGLfloat, factor);
7177 paramBuffer.addValueParam("units", ParamType::TGLfloat, units);
7178 paramBuffer.addValueParam("clamp", ParamType::TGLfloat, clamp);
7179
7180 return CallCapture(angle::EntryPoint::GLPolygonOffsetClampEXT, std::move(paramBuffer));
7181 }
7182
CapturePrimitiveBoundingBoxEXT(const State & glState,bool isCallValid,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)7183 CallCapture CapturePrimitiveBoundingBoxEXT(const State &glState,
7184 bool isCallValid,
7185 GLfloat minX,
7186 GLfloat minY,
7187 GLfloat minZ,
7188 GLfloat minW,
7189 GLfloat maxX,
7190 GLfloat maxY,
7191 GLfloat maxZ,
7192 GLfloat maxW)
7193 {
7194 ParamBuffer paramBuffer;
7195
7196 paramBuffer.addValueParam("minX", ParamType::TGLfloat, minX);
7197 paramBuffer.addValueParam("minY", ParamType::TGLfloat, minY);
7198 paramBuffer.addValueParam("minZ", ParamType::TGLfloat, minZ);
7199 paramBuffer.addValueParam("minW", ParamType::TGLfloat, minW);
7200 paramBuffer.addValueParam("maxX", ParamType::TGLfloat, maxX);
7201 paramBuffer.addValueParam("maxY", ParamType::TGLfloat, maxY);
7202 paramBuffer.addValueParam("maxZ", ParamType::TGLfloat, maxZ);
7203 paramBuffer.addValueParam("maxW", ParamType::TGLfloat, maxW);
7204
7205 return CallCapture(angle::EntryPoint::GLPrimitiveBoundingBoxEXT, std::move(paramBuffer));
7206 }
7207
CaptureGetGraphicsResetStatusEXT(const State & glState,bool isCallValid,GLenum returnValue)7208 CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
7209 bool isCallValid,
7210 GLenum returnValue)
7211 {
7212 ParamBuffer paramBuffer;
7213
7214 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
7215 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
7216 paramBuffer.addReturnValue(std::move(returnValueCapture));
7217
7218 return CallCapture(angle::EntryPoint::GLGetGraphicsResetStatusEXT, std::move(paramBuffer));
7219 }
7220
CaptureGetnUniformfvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)7221 CallCapture CaptureGetnUniformfvEXT(const State &glState,
7222 bool isCallValid,
7223 ShaderProgramID programPacked,
7224 UniformLocation locationPacked,
7225 GLsizei bufSize,
7226 GLfloat *params)
7227 {
7228 ParamBuffer paramBuffer;
7229
7230 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7231 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7232 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7233
7234 if (isCallValid)
7235 {
7236 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
7237 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
7238 CaptureGetnUniformfvEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
7239 params, ¶msParam);
7240 paramBuffer.addParam(std::move(paramsParam));
7241 }
7242 else
7243 {
7244 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
7245 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
7246 ¶msParam.value);
7247 paramBuffer.addParam(std::move(paramsParam));
7248 }
7249
7250 return CallCapture(angle::EntryPoint::GLGetnUniformfvEXT, std::move(paramBuffer));
7251 }
7252
CaptureGetnUniformivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)7253 CallCapture CaptureGetnUniformivEXT(const State &glState,
7254 bool isCallValid,
7255 ShaderProgramID programPacked,
7256 UniformLocation locationPacked,
7257 GLsizei bufSize,
7258 GLint *params)
7259 {
7260 ParamBuffer paramBuffer;
7261
7262 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7263 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7264 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7265
7266 if (isCallValid)
7267 {
7268 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7269 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
7270 CaptureGetnUniformivEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
7271 params, ¶msParam);
7272 paramBuffer.addParam(std::move(paramsParam));
7273 }
7274 else
7275 {
7276 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7277 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
7278 paramBuffer.addParam(std::move(paramsParam));
7279 }
7280
7281 return CallCapture(angle::EntryPoint::GLGetnUniformivEXT, std::move(paramBuffer));
7282 }
7283
CaptureReadnPixelsEXT(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)7284 CallCapture CaptureReadnPixelsEXT(const State &glState,
7285 bool isCallValid,
7286 GLint x,
7287 GLint y,
7288 GLsizei width,
7289 GLsizei height,
7290 GLenum format,
7291 GLenum type,
7292 GLsizei bufSize,
7293 void *data)
7294 {
7295 ParamBuffer paramBuffer;
7296
7297 paramBuffer.addValueParam("x", ParamType::TGLint, x);
7298 paramBuffer.addValueParam("y", ParamType::TGLint, y);
7299 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7300 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7301 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
7302 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
7303 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7304
7305 if (isCallValid)
7306 {
7307 ParamCapture dataParam("data", ParamType::TvoidPointer);
7308 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
7309 CaptureReadnPixelsEXT_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
7310 data, &dataParam);
7311 paramBuffer.addParam(std::move(dataParam));
7312 }
7313 else
7314 {
7315 ParamCapture dataParam("data", ParamType::TvoidPointer);
7316 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
7317 paramBuffer.addParam(std::move(dataParam));
7318 }
7319
7320 return CallCapture(angle::EntryPoint::GLReadnPixelsEXT, std::move(paramBuffer));
7321 }
7322
CaptureDeleteSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,const SemaphoreID * semaphoresPacked)7323 CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
7324 bool isCallValid,
7325 GLsizei n,
7326 const SemaphoreID *semaphoresPacked)
7327 {
7328 ParamBuffer paramBuffer;
7329
7330 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7331
7332 if (isCallValid)
7333 {
7334 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
7335 InitParamValue(ParamType::TSemaphoreIDConstPointer, semaphoresPacked,
7336 &semaphoresPackedParam.value);
7337 CaptureDeleteSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
7338 &semaphoresPackedParam);
7339 paramBuffer.addParam(std::move(semaphoresPackedParam));
7340 }
7341 else
7342 {
7343 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
7344 InitParamValue(ParamType::TSemaphoreIDConstPointer,
7345 static_cast<const SemaphoreID *>(nullptr), &semaphoresPackedParam.value);
7346 paramBuffer.addParam(std::move(semaphoresPackedParam));
7347 }
7348
7349 return CallCapture(angle::EntryPoint::GLDeleteSemaphoresEXT, std::move(paramBuffer));
7350 }
7351
CaptureGenSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,SemaphoreID * semaphoresPacked)7352 CallCapture CaptureGenSemaphoresEXT(const State &glState,
7353 bool isCallValid,
7354 GLsizei n,
7355 SemaphoreID *semaphoresPacked)
7356 {
7357 ParamBuffer paramBuffer;
7358
7359 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7360
7361 if (isCallValid)
7362 {
7363 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
7364 InitParamValue(ParamType::TSemaphoreIDPointer, semaphoresPacked,
7365 &semaphoresPackedParam.value);
7366 CaptureGenSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
7367 &semaphoresPackedParam);
7368 paramBuffer.addParam(std::move(semaphoresPackedParam));
7369 }
7370 else
7371 {
7372 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
7373 InitParamValue(ParamType::TSemaphoreIDPointer, static_cast<SemaphoreID *>(nullptr),
7374 &semaphoresPackedParam.value);
7375 paramBuffer.addParam(std::move(semaphoresPackedParam));
7376 }
7377
7378 return CallCapture(angle::EntryPoint::GLGenSemaphoresEXT, std::move(paramBuffer));
7379 }
7380
CaptureGetSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,GLuint64 * params)7381 CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
7382 bool isCallValid,
7383 SemaphoreID semaphorePacked,
7384 GLenum pname,
7385 GLuint64 *params)
7386 {
7387 ParamBuffer paramBuffer;
7388
7389 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7390 paramBuffer.addEnumParam("pname", GLESEnum::SemaphoreParameterName, ParamType::TGLenum, pname);
7391
7392 if (isCallValid)
7393 {
7394 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
7395 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
7396 CaptureGetSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
7397 params, ¶msParam);
7398 paramBuffer.addParam(std::move(paramsParam));
7399 }
7400 else
7401 {
7402 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
7403 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
7404 ¶msParam.value);
7405 paramBuffer.addParam(std::move(paramsParam));
7406 }
7407
7408 return CallCapture(angle::EntryPoint::GLGetSemaphoreParameterui64vEXT, std::move(paramBuffer));
7409 }
7410
CaptureIsSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLboolean returnValue)7411 CallCapture CaptureIsSemaphoreEXT(const State &glState,
7412 bool isCallValid,
7413 SemaphoreID semaphorePacked,
7414 GLboolean returnValue)
7415 {
7416 ParamBuffer paramBuffer;
7417
7418 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7419
7420 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7421 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7422 paramBuffer.addReturnValue(std::move(returnValueCapture));
7423
7424 return CallCapture(angle::EntryPoint::GLIsSemaphoreEXT, std::move(paramBuffer));
7425 }
7426
CaptureSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,const GLuint64 * params)7427 CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
7428 bool isCallValid,
7429 SemaphoreID semaphorePacked,
7430 GLenum pname,
7431 const GLuint64 *params)
7432 {
7433 ParamBuffer paramBuffer;
7434
7435 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7436 paramBuffer.addEnumParam("pname", GLESEnum::SemaphoreParameterName, ParamType::TGLenum, pname);
7437
7438 if (isCallValid)
7439 {
7440 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
7441 InitParamValue(ParamType::TGLuint64ConstPointer, params, ¶msParam.value);
7442 CaptureSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
7443 params, ¶msParam);
7444 paramBuffer.addParam(std::move(paramsParam));
7445 }
7446 else
7447 {
7448 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
7449 InitParamValue(ParamType::TGLuint64ConstPointer, static_cast<const GLuint64 *>(nullptr),
7450 ¶msParam.value);
7451 paramBuffer.addParam(std::move(paramsParam));
7452 }
7453
7454 return CallCapture(angle::EntryPoint::GLSemaphoreParameterui64vEXT, std::move(paramBuffer));
7455 }
7456
CaptureSignalSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * dstLayouts)7457 CallCapture CaptureSignalSemaphoreEXT(const State &glState,
7458 bool isCallValid,
7459 SemaphoreID semaphorePacked,
7460 GLuint numBufferBarriers,
7461 const BufferID *buffersPacked,
7462 GLuint numTextureBarriers,
7463 const TextureID *texturesPacked,
7464 const GLenum *dstLayouts)
7465 {
7466 ParamBuffer paramBuffer;
7467
7468 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7469 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
7470
7471 if (isCallValid)
7472 {
7473 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7474 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
7475 CaptureSignalSemaphoreEXT_buffersPacked(
7476 glState, isCallValid, semaphorePacked, numBufferBarriers, buffersPacked,
7477 numTextureBarriers, texturesPacked, dstLayouts, &buffersPackedParam);
7478 paramBuffer.addParam(std::move(buffersPackedParam));
7479 }
7480 else
7481 {
7482 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7483 InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
7484 &buffersPackedParam.value);
7485 paramBuffer.addParam(std::move(buffersPackedParam));
7486 }
7487
7488 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
7489
7490 if (isCallValid)
7491 {
7492 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7493 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
7494 &texturesPackedParam.value);
7495 CaptureSignalSemaphoreEXT_texturesPacked(
7496 glState, isCallValid, semaphorePacked, numBufferBarriers, buffersPacked,
7497 numTextureBarriers, texturesPacked, dstLayouts, &texturesPackedParam);
7498 paramBuffer.addParam(std::move(texturesPackedParam));
7499 }
7500 else
7501 {
7502 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7503 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
7504 &texturesPackedParam.value);
7505 paramBuffer.addParam(std::move(texturesPackedParam));
7506 }
7507
7508 if (isCallValid)
7509 {
7510 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
7511 InitParamValue(ParamType::TGLenumConstPointer, dstLayouts, &dstLayoutsParam.value);
7512 CaptureSignalSemaphoreEXT_dstLayouts(glState, isCallValid, semaphorePacked,
7513 numBufferBarriers, buffersPacked, numTextureBarriers,
7514 texturesPacked, dstLayouts, &dstLayoutsParam);
7515 paramBuffer.addParam(std::move(dstLayoutsParam));
7516 }
7517 else
7518 {
7519 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
7520 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
7521 &dstLayoutsParam.value);
7522 paramBuffer.addParam(std::move(dstLayoutsParam));
7523 }
7524
7525 return CallCapture(angle::EntryPoint::GLSignalSemaphoreEXT, std::move(paramBuffer));
7526 }
7527
CaptureWaitSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * srcLayouts)7528 CallCapture CaptureWaitSemaphoreEXT(const State &glState,
7529 bool isCallValid,
7530 SemaphoreID semaphorePacked,
7531 GLuint numBufferBarriers,
7532 const BufferID *buffersPacked,
7533 GLuint numTextureBarriers,
7534 const TextureID *texturesPacked,
7535 const GLenum *srcLayouts)
7536 {
7537 ParamBuffer paramBuffer;
7538
7539 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7540 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
7541
7542 if (isCallValid)
7543 {
7544 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7545 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
7546 CaptureWaitSemaphoreEXT_buffersPacked(glState, isCallValid, semaphorePacked,
7547 numBufferBarriers, buffersPacked, numTextureBarriers,
7548 texturesPacked, srcLayouts, &buffersPackedParam);
7549 paramBuffer.addParam(std::move(buffersPackedParam));
7550 }
7551 else
7552 {
7553 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7554 InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
7555 &buffersPackedParam.value);
7556 paramBuffer.addParam(std::move(buffersPackedParam));
7557 }
7558
7559 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
7560
7561 if (isCallValid)
7562 {
7563 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7564 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
7565 &texturesPackedParam.value);
7566 CaptureWaitSemaphoreEXT_texturesPacked(glState, isCallValid, semaphorePacked,
7567 numBufferBarriers, buffersPacked, numTextureBarriers,
7568 texturesPacked, srcLayouts, &texturesPackedParam);
7569 paramBuffer.addParam(std::move(texturesPackedParam));
7570 }
7571 else
7572 {
7573 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7574 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
7575 &texturesPackedParam.value);
7576 paramBuffer.addParam(std::move(texturesPackedParam));
7577 }
7578
7579 if (isCallValid)
7580 {
7581 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
7582 InitParamValue(ParamType::TGLenumConstPointer, srcLayouts, &srcLayoutsParam.value);
7583 CaptureWaitSemaphoreEXT_srcLayouts(glState, isCallValid, semaphorePacked, numBufferBarriers,
7584 buffersPacked, numTextureBarriers, texturesPacked,
7585 srcLayouts, &srcLayoutsParam);
7586 paramBuffer.addParam(std::move(srcLayoutsParam));
7587 }
7588 else
7589 {
7590 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
7591 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
7592 &srcLayoutsParam.value);
7593 paramBuffer.addParam(std::move(srcLayoutsParam));
7594 }
7595
7596 return CallCapture(angle::EntryPoint::GLWaitSemaphoreEXT, std::move(paramBuffer));
7597 }
7598
CaptureImportSemaphoreFdEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLint fd)7599 CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
7600 bool isCallValid,
7601 SemaphoreID semaphorePacked,
7602 HandleType handleTypePacked,
7603 GLint fd)
7604 {
7605 ParamBuffer paramBuffer;
7606
7607 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7608 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
7609 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
7610
7611 return CallCapture(angle::EntryPoint::GLImportSemaphoreFdEXT, std::move(paramBuffer));
7612 }
7613
CaptureActiveShaderProgramEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,ShaderProgramID programPacked)7614 CallCapture CaptureActiveShaderProgramEXT(const State &glState,
7615 bool isCallValid,
7616 ProgramPipelineID pipelinePacked,
7617 ShaderProgramID programPacked)
7618 {
7619 ParamBuffer paramBuffer;
7620
7621 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7622 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7623
7624 return CallCapture(angle::EntryPoint::GLActiveShaderProgramEXT, std::move(paramBuffer));
7625 }
7626
CaptureBindProgramPipelineEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked)7627 CallCapture CaptureBindProgramPipelineEXT(const State &glState,
7628 bool isCallValid,
7629 ProgramPipelineID pipelinePacked)
7630 {
7631 ParamBuffer paramBuffer;
7632
7633 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7634
7635 return CallCapture(angle::EntryPoint::GLBindProgramPipelineEXT, std::move(paramBuffer));
7636 }
7637
CaptureCreateShaderProgramvEXT(const State & glState,bool isCallValid,ShaderType typePacked,GLsizei count,const GLchar ** strings,GLuint returnValue)7638 CallCapture CaptureCreateShaderProgramvEXT(const State &glState,
7639 bool isCallValid,
7640 ShaderType typePacked,
7641 GLsizei count,
7642 const GLchar **strings,
7643 GLuint returnValue)
7644 {
7645 ParamBuffer paramBuffer;
7646
7647 paramBuffer.addValueParam("typePacked", ParamType::TShaderType, typePacked);
7648 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7649
7650 if (isCallValid)
7651 {
7652 ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
7653 InitParamValue(ParamType::TGLcharConstPointerPointer, strings, &stringsParam.value);
7654 CaptureCreateShaderProgramvEXT_strings(glState, isCallValid, typePacked, count, strings,
7655 &stringsParam);
7656 paramBuffer.addParam(std::move(stringsParam));
7657 }
7658 else
7659 {
7660 ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
7661 InitParamValue(ParamType::TGLcharConstPointerPointer, static_cast<const GLchar **>(nullptr),
7662 &stringsParam.value);
7663 paramBuffer.addParam(std::move(stringsParam));
7664 }
7665
7666 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
7667 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
7668 paramBuffer.addReturnValue(std::move(returnValueCapture));
7669
7670 return CallCapture(angle::EntryPoint::GLCreateShaderProgramvEXT, std::move(paramBuffer));
7671 }
7672
CaptureDeleteProgramPipelinesEXT(const State & glState,bool isCallValid,GLsizei n,const ProgramPipelineID * pipelinesPacked)7673 CallCapture CaptureDeleteProgramPipelinesEXT(const State &glState,
7674 bool isCallValid,
7675 GLsizei n,
7676 const ProgramPipelineID *pipelinesPacked)
7677 {
7678 ParamBuffer paramBuffer;
7679
7680 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7681
7682 if (isCallValid)
7683 {
7684 ParamCapture pipelinesPackedParam("pipelinesPacked",
7685 ParamType::TProgramPipelineIDConstPointer);
7686 InitParamValue(ParamType::TProgramPipelineIDConstPointer, pipelinesPacked,
7687 &pipelinesPackedParam.value);
7688 CaptureDeleteProgramPipelinesEXT_pipelinesPacked(glState, isCallValid, n, pipelinesPacked,
7689 &pipelinesPackedParam);
7690 paramBuffer.addParam(std::move(pipelinesPackedParam));
7691 }
7692 else
7693 {
7694 ParamCapture pipelinesPackedParam("pipelinesPacked",
7695 ParamType::TProgramPipelineIDConstPointer);
7696 InitParamValue(ParamType::TProgramPipelineIDConstPointer,
7697 static_cast<const ProgramPipelineID *>(nullptr),
7698 &pipelinesPackedParam.value);
7699 paramBuffer.addParam(std::move(pipelinesPackedParam));
7700 }
7701
7702 return CallCapture(angle::EntryPoint::GLDeleteProgramPipelinesEXT, std::move(paramBuffer));
7703 }
7704
CaptureGenProgramPipelinesEXT(const State & glState,bool isCallValid,GLsizei n,ProgramPipelineID * pipelinesPacked)7705 CallCapture CaptureGenProgramPipelinesEXT(const State &glState,
7706 bool isCallValid,
7707 GLsizei n,
7708 ProgramPipelineID *pipelinesPacked)
7709 {
7710 ParamBuffer paramBuffer;
7711
7712 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7713
7714 if (isCallValid)
7715 {
7716 ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDPointer);
7717 InitParamValue(ParamType::TProgramPipelineIDPointer, pipelinesPacked,
7718 &pipelinesPackedParam.value);
7719 CaptureGenProgramPipelinesEXT_pipelinesPacked(glState, isCallValid, n, pipelinesPacked,
7720 &pipelinesPackedParam);
7721 paramBuffer.addParam(std::move(pipelinesPackedParam));
7722 }
7723 else
7724 {
7725 ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDPointer);
7726 InitParamValue(ParamType::TProgramPipelineIDPointer,
7727 static_cast<ProgramPipelineID *>(nullptr), &pipelinesPackedParam.value);
7728 paramBuffer.addParam(std::move(pipelinesPackedParam));
7729 }
7730
7731 return CallCapture(angle::EntryPoint::GLGenProgramPipelinesEXT, std::move(paramBuffer));
7732 }
7733
CaptureGetProgramPipelineInfoLogEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLsizei bufSize,GLsizei * length,GLchar * infoLog)7734 CallCapture CaptureGetProgramPipelineInfoLogEXT(const State &glState,
7735 bool isCallValid,
7736 ProgramPipelineID pipelinePacked,
7737 GLsizei bufSize,
7738 GLsizei *length,
7739 GLchar *infoLog)
7740 {
7741 ParamBuffer paramBuffer;
7742
7743 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7744 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7745
7746 if (isCallValid)
7747 {
7748 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
7749 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
7750 CaptureGetProgramPipelineInfoLogEXT_length(glState, isCallValid, pipelinePacked, bufSize,
7751 length, infoLog, &lengthParam);
7752 paramBuffer.addParam(std::move(lengthParam));
7753 }
7754 else
7755 {
7756 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
7757 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
7758 &lengthParam.value);
7759 paramBuffer.addParam(std::move(lengthParam));
7760 }
7761
7762 if (isCallValid)
7763 {
7764 ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
7765 InitParamValue(ParamType::TGLcharPointer, infoLog, &infoLogParam.value);
7766 CaptureGetProgramPipelineInfoLogEXT_infoLog(glState, isCallValid, pipelinePacked, bufSize,
7767 length, infoLog, &infoLogParam);
7768 paramBuffer.addParam(std::move(infoLogParam));
7769 }
7770 else
7771 {
7772 ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
7773 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
7774 &infoLogParam.value);
7775 paramBuffer.addParam(std::move(infoLogParam));
7776 }
7777
7778 return CallCapture(angle::EntryPoint::GLGetProgramPipelineInfoLogEXT, std::move(paramBuffer));
7779 }
7780
CaptureGetProgramPipelineivEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLenum pname,GLint * params)7781 CallCapture CaptureGetProgramPipelineivEXT(const State &glState,
7782 bool isCallValid,
7783 ProgramPipelineID pipelinePacked,
7784 GLenum pname,
7785 GLint *params)
7786 {
7787 ParamBuffer paramBuffer;
7788
7789 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7790 paramBuffer.addEnumParam("pname", GLESEnum::PipelineParameterName, ParamType::TGLenum, pname);
7791
7792 if (isCallValid)
7793 {
7794 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7795 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
7796 CaptureGetProgramPipelineivEXT_params(glState, isCallValid, pipelinePacked, pname, params,
7797 ¶msParam);
7798 paramBuffer.addParam(std::move(paramsParam));
7799 }
7800 else
7801 {
7802 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7803 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
7804 paramBuffer.addParam(std::move(paramsParam));
7805 }
7806
7807 return CallCapture(angle::EntryPoint::GLGetProgramPipelineivEXT, std::move(paramBuffer));
7808 }
7809
CaptureIsProgramPipelineEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLboolean returnValue)7810 CallCapture CaptureIsProgramPipelineEXT(const State &glState,
7811 bool isCallValid,
7812 ProgramPipelineID pipelinePacked,
7813 GLboolean returnValue)
7814 {
7815 ParamBuffer paramBuffer;
7816
7817 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7818
7819 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7820 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7821 paramBuffer.addReturnValue(std::move(returnValueCapture));
7822
7823 return CallCapture(angle::EntryPoint::GLIsProgramPipelineEXT, std::move(paramBuffer));
7824 }
7825
CaptureProgramParameteriEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum pname,GLint value)7826 CallCapture CaptureProgramParameteriEXT(const State &glState,
7827 bool isCallValid,
7828 ShaderProgramID programPacked,
7829 GLenum pname,
7830 GLint value)
7831 {
7832 ParamBuffer paramBuffer;
7833
7834 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7835 paramBuffer.addEnumParam("pname", GLESEnum::ProgramParameterPName, ParamType::TGLenum, pname);
7836 paramBuffer.addValueParam("value", ParamType::TGLint, value);
7837
7838 return CallCapture(angle::EntryPoint::GLProgramParameteriEXT, std::move(paramBuffer));
7839 }
7840
CaptureProgramUniform1fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0)7841 CallCapture CaptureProgramUniform1fEXT(const State &glState,
7842 bool isCallValid,
7843 ShaderProgramID programPacked,
7844 UniformLocation locationPacked,
7845 GLfloat v0)
7846 {
7847 ParamBuffer paramBuffer;
7848
7849 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7850 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7851 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
7852
7853 return CallCapture(angle::EntryPoint::GLProgramUniform1fEXT, std::move(paramBuffer));
7854 }
7855
CaptureProgramUniform1fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)7856 CallCapture CaptureProgramUniform1fvEXT(const State &glState,
7857 bool isCallValid,
7858 ShaderProgramID programPacked,
7859 UniformLocation locationPacked,
7860 GLsizei count,
7861 const GLfloat *value)
7862 {
7863 ParamBuffer paramBuffer;
7864
7865 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7866 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7867 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7868
7869 if (isCallValid)
7870 {
7871 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
7872 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
7873 CaptureProgramUniform1fvEXT_value(glState, isCallValid, programPacked, locationPacked,
7874 count, value, &valueParam);
7875 paramBuffer.addParam(std::move(valueParam));
7876 }
7877 else
7878 {
7879 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
7880 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
7881 &valueParam.value);
7882 paramBuffer.addParam(std::move(valueParam));
7883 }
7884
7885 return CallCapture(angle::EntryPoint::GLProgramUniform1fvEXT, std::move(paramBuffer));
7886 }
7887
CaptureProgramUniform1iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0)7888 CallCapture CaptureProgramUniform1iEXT(const State &glState,
7889 bool isCallValid,
7890 ShaderProgramID programPacked,
7891 UniformLocation locationPacked,
7892 GLint v0)
7893 {
7894 ParamBuffer paramBuffer;
7895
7896 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7897 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7898 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
7899
7900 return CallCapture(angle::EntryPoint::GLProgramUniform1iEXT, std::move(paramBuffer));
7901 }
7902
CaptureProgramUniform1ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)7903 CallCapture CaptureProgramUniform1ivEXT(const State &glState,
7904 bool isCallValid,
7905 ShaderProgramID programPacked,
7906 UniformLocation locationPacked,
7907 GLsizei count,
7908 const GLint *value)
7909 {
7910 ParamBuffer paramBuffer;
7911
7912 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7913 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7914 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7915
7916 if (isCallValid)
7917 {
7918 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
7919 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
7920 CaptureProgramUniform1ivEXT_value(glState, isCallValid, programPacked, locationPacked,
7921 count, value, &valueParam);
7922 paramBuffer.addParam(std::move(valueParam));
7923 }
7924 else
7925 {
7926 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
7927 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
7928 &valueParam.value);
7929 paramBuffer.addParam(std::move(valueParam));
7930 }
7931
7932 return CallCapture(angle::EntryPoint::GLProgramUniform1ivEXT, std::move(paramBuffer));
7933 }
7934
CaptureProgramUniform1uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0)7935 CallCapture CaptureProgramUniform1uiEXT(const State &glState,
7936 bool isCallValid,
7937 ShaderProgramID programPacked,
7938 UniformLocation locationPacked,
7939 GLuint v0)
7940 {
7941 ParamBuffer paramBuffer;
7942
7943 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7944 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7945 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
7946
7947 return CallCapture(angle::EntryPoint::GLProgramUniform1uiEXT, std::move(paramBuffer));
7948 }
7949
CaptureProgramUniform1uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)7950 CallCapture CaptureProgramUniform1uivEXT(const State &glState,
7951 bool isCallValid,
7952 ShaderProgramID programPacked,
7953 UniformLocation locationPacked,
7954 GLsizei count,
7955 const GLuint *value)
7956 {
7957 ParamBuffer paramBuffer;
7958
7959 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7960 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7961 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7962
7963 if (isCallValid)
7964 {
7965 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
7966 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
7967 CaptureProgramUniform1uivEXT_value(glState, isCallValid, programPacked, locationPacked,
7968 count, value, &valueParam);
7969 paramBuffer.addParam(std::move(valueParam));
7970 }
7971 else
7972 {
7973 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
7974 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
7975 &valueParam.value);
7976 paramBuffer.addParam(std::move(valueParam));
7977 }
7978
7979 return CallCapture(angle::EntryPoint::GLProgramUniform1uivEXT, std::move(paramBuffer));
7980 }
7981
CaptureProgramUniform2fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0,GLfloat v1)7982 CallCapture CaptureProgramUniform2fEXT(const State &glState,
7983 bool isCallValid,
7984 ShaderProgramID programPacked,
7985 UniformLocation locationPacked,
7986 GLfloat v0,
7987 GLfloat v1)
7988 {
7989 ParamBuffer paramBuffer;
7990
7991 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7992 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7993 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
7994 paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
7995
7996 return CallCapture(angle::EntryPoint::GLProgramUniform2fEXT, std::move(paramBuffer));
7997 }
7998
CaptureProgramUniform2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)7999 CallCapture CaptureProgramUniform2fvEXT(const State &glState,
8000 bool isCallValid,
8001 ShaderProgramID programPacked,
8002 UniformLocation locationPacked,
8003 GLsizei count,
8004 const GLfloat *value)
8005 {
8006 ParamBuffer paramBuffer;
8007
8008 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8009 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8010 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8011
8012 if (isCallValid)
8013 {
8014 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8015 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8016 CaptureProgramUniform2fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8017 count, value, &valueParam);
8018 paramBuffer.addParam(std::move(valueParam));
8019 }
8020 else
8021 {
8022 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8023 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8024 &valueParam.value);
8025 paramBuffer.addParam(std::move(valueParam));
8026 }
8027
8028 return CallCapture(angle::EntryPoint::GLProgramUniform2fvEXT, std::move(paramBuffer));
8029 }
8030
CaptureProgramUniform2iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0,GLint v1)8031 CallCapture CaptureProgramUniform2iEXT(const State &glState,
8032 bool isCallValid,
8033 ShaderProgramID programPacked,
8034 UniformLocation locationPacked,
8035 GLint v0,
8036 GLint v1)
8037 {
8038 ParamBuffer paramBuffer;
8039
8040 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8041 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8042 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8043 paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
8044
8045 return CallCapture(angle::EntryPoint::GLProgramUniform2iEXT, std::move(paramBuffer));
8046 }
8047
CaptureProgramUniform2ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8048 CallCapture CaptureProgramUniform2ivEXT(const State &glState,
8049 bool isCallValid,
8050 ShaderProgramID programPacked,
8051 UniformLocation locationPacked,
8052 GLsizei count,
8053 const GLint *value)
8054 {
8055 ParamBuffer paramBuffer;
8056
8057 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8058 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8059 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8060
8061 if (isCallValid)
8062 {
8063 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8064 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8065 CaptureProgramUniform2ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8066 count, value, &valueParam);
8067 paramBuffer.addParam(std::move(valueParam));
8068 }
8069 else
8070 {
8071 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8072 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8073 &valueParam.value);
8074 paramBuffer.addParam(std::move(valueParam));
8075 }
8076
8077 return CallCapture(angle::EntryPoint::GLProgramUniform2ivEXT, std::move(paramBuffer));
8078 }
8079
CaptureProgramUniform2uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0,GLuint v1)8080 CallCapture CaptureProgramUniform2uiEXT(const State &glState,
8081 bool isCallValid,
8082 ShaderProgramID programPacked,
8083 UniformLocation locationPacked,
8084 GLuint v0,
8085 GLuint v1)
8086 {
8087 ParamBuffer paramBuffer;
8088
8089 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8090 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8091 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8092 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
8093
8094 return CallCapture(angle::EntryPoint::GLProgramUniform2uiEXT, std::move(paramBuffer));
8095 }
8096
CaptureProgramUniform2uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8097 CallCapture CaptureProgramUniform2uivEXT(const State &glState,
8098 bool isCallValid,
8099 ShaderProgramID programPacked,
8100 UniformLocation locationPacked,
8101 GLsizei count,
8102 const GLuint *value)
8103 {
8104 ParamBuffer paramBuffer;
8105
8106 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8107 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8108 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8109
8110 if (isCallValid)
8111 {
8112 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8113 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8114 CaptureProgramUniform2uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8115 count, value, &valueParam);
8116 paramBuffer.addParam(std::move(valueParam));
8117 }
8118 else
8119 {
8120 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8121 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8122 &valueParam.value);
8123 paramBuffer.addParam(std::move(valueParam));
8124 }
8125
8126 return CallCapture(angle::EntryPoint::GLProgramUniform2uivEXT, std::move(paramBuffer));
8127 }
8128
CaptureProgramUniform3fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0,GLfloat v1,GLfloat v2)8129 CallCapture CaptureProgramUniform3fEXT(const State &glState,
8130 bool isCallValid,
8131 ShaderProgramID programPacked,
8132 UniformLocation locationPacked,
8133 GLfloat v0,
8134 GLfloat v1,
8135 GLfloat v2)
8136 {
8137 ParamBuffer paramBuffer;
8138
8139 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8140 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8141 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
8142 paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
8143 paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
8144
8145 return CallCapture(angle::EntryPoint::GLProgramUniform3fEXT, std::move(paramBuffer));
8146 }
8147
CaptureProgramUniform3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)8148 CallCapture CaptureProgramUniform3fvEXT(const State &glState,
8149 bool isCallValid,
8150 ShaderProgramID programPacked,
8151 UniformLocation locationPacked,
8152 GLsizei count,
8153 const GLfloat *value)
8154 {
8155 ParamBuffer paramBuffer;
8156
8157 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8158 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8159 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8160
8161 if (isCallValid)
8162 {
8163 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8164 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8165 CaptureProgramUniform3fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8166 count, value, &valueParam);
8167 paramBuffer.addParam(std::move(valueParam));
8168 }
8169 else
8170 {
8171 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8172 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8173 &valueParam.value);
8174 paramBuffer.addParam(std::move(valueParam));
8175 }
8176
8177 return CallCapture(angle::EntryPoint::GLProgramUniform3fvEXT, std::move(paramBuffer));
8178 }
8179
CaptureProgramUniform3iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0,GLint v1,GLint v2)8180 CallCapture CaptureProgramUniform3iEXT(const State &glState,
8181 bool isCallValid,
8182 ShaderProgramID programPacked,
8183 UniformLocation locationPacked,
8184 GLint v0,
8185 GLint v1,
8186 GLint v2)
8187 {
8188 ParamBuffer paramBuffer;
8189
8190 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8191 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8192 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8193 paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
8194 paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
8195
8196 return CallCapture(angle::EntryPoint::GLProgramUniform3iEXT, std::move(paramBuffer));
8197 }
8198
CaptureProgramUniform3ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8199 CallCapture CaptureProgramUniform3ivEXT(const State &glState,
8200 bool isCallValid,
8201 ShaderProgramID programPacked,
8202 UniformLocation locationPacked,
8203 GLsizei count,
8204 const GLint *value)
8205 {
8206 ParamBuffer paramBuffer;
8207
8208 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8209 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8210 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8211
8212 if (isCallValid)
8213 {
8214 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8215 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8216 CaptureProgramUniform3ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8217 count, value, &valueParam);
8218 paramBuffer.addParam(std::move(valueParam));
8219 }
8220 else
8221 {
8222 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8223 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8224 &valueParam.value);
8225 paramBuffer.addParam(std::move(valueParam));
8226 }
8227
8228 return CallCapture(angle::EntryPoint::GLProgramUniform3ivEXT, std::move(paramBuffer));
8229 }
8230
CaptureProgramUniform3uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0,GLuint v1,GLuint v2)8231 CallCapture CaptureProgramUniform3uiEXT(const State &glState,
8232 bool isCallValid,
8233 ShaderProgramID programPacked,
8234 UniformLocation locationPacked,
8235 GLuint v0,
8236 GLuint v1,
8237 GLuint v2)
8238 {
8239 ParamBuffer paramBuffer;
8240
8241 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8242 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8243 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8244 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
8245 paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
8246
8247 return CallCapture(angle::EntryPoint::GLProgramUniform3uiEXT, std::move(paramBuffer));
8248 }
8249
CaptureProgramUniform3uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8250 CallCapture CaptureProgramUniform3uivEXT(const State &glState,
8251 bool isCallValid,
8252 ShaderProgramID programPacked,
8253 UniformLocation locationPacked,
8254 GLsizei count,
8255 const GLuint *value)
8256 {
8257 ParamBuffer paramBuffer;
8258
8259 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8260 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8261 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8262
8263 if (isCallValid)
8264 {
8265 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8266 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8267 CaptureProgramUniform3uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8268 count, value, &valueParam);
8269 paramBuffer.addParam(std::move(valueParam));
8270 }
8271 else
8272 {
8273 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8274 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8275 &valueParam.value);
8276 paramBuffer.addParam(std::move(valueParam));
8277 }
8278
8279 return CallCapture(angle::EntryPoint::GLProgramUniform3uivEXT, std::move(paramBuffer));
8280 }
8281
CaptureProgramUniform4fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)8282 CallCapture CaptureProgramUniform4fEXT(const State &glState,
8283 bool isCallValid,
8284 ShaderProgramID programPacked,
8285 UniformLocation locationPacked,
8286 GLfloat v0,
8287 GLfloat v1,
8288 GLfloat v2,
8289 GLfloat v3)
8290 {
8291 ParamBuffer paramBuffer;
8292
8293 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8294 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8295 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
8296 paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
8297 paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
8298 paramBuffer.addValueParam("v3", ParamType::TGLfloat, v3);
8299
8300 return CallCapture(angle::EntryPoint::GLProgramUniform4fEXT, std::move(paramBuffer));
8301 }
8302
CaptureProgramUniform4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)8303 CallCapture CaptureProgramUniform4fvEXT(const State &glState,
8304 bool isCallValid,
8305 ShaderProgramID programPacked,
8306 UniformLocation locationPacked,
8307 GLsizei count,
8308 const GLfloat *value)
8309 {
8310 ParamBuffer paramBuffer;
8311
8312 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8313 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8314 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8315
8316 if (isCallValid)
8317 {
8318 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8319 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8320 CaptureProgramUniform4fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8321 count, value, &valueParam);
8322 paramBuffer.addParam(std::move(valueParam));
8323 }
8324 else
8325 {
8326 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8327 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8328 &valueParam.value);
8329 paramBuffer.addParam(std::move(valueParam));
8330 }
8331
8332 return CallCapture(angle::EntryPoint::GLProgramUniform4fvEXT, std::move(paramBuffer));
8333 }
8334
CaptureProgramUniform4iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0,GLint v1,GLint v2,GLint v3)8335 CallCapture CaptureProgramUniform4iEXT(const State &glState,
8336 bool isCallValid,
8337 ShaderProgramID programPacked,
8338 UniformLocation locationPacked,
8339 GLint v0,
8340 GLint v1,
8341 GLint v2,
8342 GLint v3)
8343 {
8344 ParamBuffer paramBuffer;
8345
8346 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8347 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8348 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8349 paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
8350 paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
8351 paramBuffer.addValueParam("v3", ParamType::TGLint, v3);
8352
8353 return CallCapture(angle::EntryPoint::GLProgramUniform4iEXT, std::move(paramBuffer));
8354 }
8355
CaptureProgramUniform4ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8356 CallCapture CaptureProgramUniform4ivEXT(const State &glState,
8357 bool isCallValid,
8358 ShaderProgramID programPacked,
8359 UniformLocation locationPacked,
8360 GLsizei count,
8361 const GLint *value)
8362 {
8363 ParamBuffer paramBuffer;
8364
8365 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8366 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8367 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8368
8369 if (isCallValid)
8370 {
8371 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8372 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8373 CaptureProgramUniform4ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8374 count, value, &valueParam);
8375 paramBuffer.addParam(std::move(valueParam));
8376 }
8377 else
8378 {
8379 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8380 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8381 &valueParam.value);
8382 paramBuffer.addParam(std::move(valueParam));
8383 }
8384
8385 return CallCapture(angle::EntryPoint::GLProgramUniform4ivEXT, std::move(paramBuffer));
8386 }
8387
CaptureProgramUniform4uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0,GLuint v1,GLuint v2,GLuint v3)8388 CallCapture CaptureProgramUniform4uiEXT(const State &glState,
8389 bool isCallValid,
8390 ShaderProgramID programPacked,
8391 UniformLocation locationPacked,
8392 GLuint v0,
8393 GLuint v1,
8394 GLuint v2,
8395 GLuint v3)
8396 {
8397 ParamBuffer paramBuffer;
8398
8399 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8400 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8401 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8402 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
8403 paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
8404 paramBuffer.addValueParam("v3", ParamType::TGLuint, v3);
8405
8406 return CallCapture(angle::EntryPoint::GLProgramUniform4uiEXT, std::move(paramBuffer));
8407 }
8408
CaptureProgramUniform4uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8409 CallCapture CaptureProgramUniform4uivEXT(const State &glState,
8410 bool isCallValid,
8411 ShaderProgramID programPacked,
8412 UniformLocation locationPacked,
8413 GLsizei count,
8414 const GLuint *value)
8415 {
8416 ParamBuffer paramBuffer;
8417
8418 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8419 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8420 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8421
8422 if (isCallValid)
8423 {
8424 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8425 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8426 CaptureProgramUniform4uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8427 count, value, &valueParam);
8428 paramBuffer.addParam(std::move(valueParam));
8429 }
8430 else
8431 {
8432 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8433 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8434 &valueParam.value);
8435 paramBuffer.addParam(std::move(valueParam));
8436 }
8437
8438 return CallCapture(angle::EntryPoint::GLProgramUniform4uivEXT, std::move(paramBuffer));
8439 }
8440
CaptureProgramUniformMatrix2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8441 CallCapture CaptureProgramUniformMatrix2fvEXT(const State &glState,
8442 bool isCallValid,
8443 ShaderProgramID programPacked,
8444 UniformLocation locationPacked,
8445 GLsizei count,
8446 GLboolean transpose,
8447 const GLfloat *value)
8448 {
8449 ParamBuffer paramBuffer;
8450
8451 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8452 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8453 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8454 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8455
8456 if (isCallValid)
8457 {
8458 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8459 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8460 CaptureProgramUniformMatrix2fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8461 count, transpose, value, &valueParam);
8462 paramBuffer.addParam(std::move(valueParam));
8463 }
8464 else
8465 {
8466 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8467 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8468 &valueParam.value);
8469 paramBuffer.addParam(std::move(valueParam));
8470 }
8471
8472 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2fvEXT, std::move(paramBuffer));
8473 }
8474
CaptureProgramUniformMatrix2x3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8475 CallCapture CaptureProgramUniformMatrix2x3fvEXT(const State &glState,
8476 bool isCallValid,
8477 ShaderProgramID programPacked,
8478 UniformLocation locationPacked,
8479 GLsizei count,
8480 GLboolean transpose,
8481 const GLfloat *value)
8482 {
8483 ParamBuffer paramBuffer;
8484
8485 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8486 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8487 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8488 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8489
8490 if (isCallValid)
8491 {
8492 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8493 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8494 CaptureProgramUniformMatrix2x3fvEXT_value(glState, isCallValid, programPacked,
8495 locationPacked, count, transpose, value,
8496 &valueParam);
8497 paramBuffer.addParam(std::move(valueParam));
8498 }
8499 else
8500 {
8501 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8502 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8503 &valueParam.value);
8504 paramBuffer.addParam(std::move(valueParam));
8505 }
8506
8507 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT, std::move(paramBuffer));
8508 }
8509
CaptureProgramUniformMatrix2x4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8510 CallCapture CaptureProgramUniformMatrix2x4fvEXT(const State &glState,
8511 bool isCallValid,
8512 ShaderProgramID programPacked,
8513 UniformLocation locationPacked,
8514 GLsizei count,
8515 GLboolean transpose,
8516 const GLfloat *value)
8517 {
8518 ParamBuffer paramBuffer;
8519
8520 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8521 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8522 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8523 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8524
8525 if (isCallValid)
8526 {
8527 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8528 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8529 CaptureProgramUniformMatrix2x4fvEXT_value(glState, isCallValid, programPacked,
8530 locationPacked, count, transpose, value,
8531 &valueParam);
8532 paramBuffer.addParam(std::move(valueParam));
8533 }
8534 else
8535 {
8536 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8537 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8538 &valueParam.value);
8539 paramBuffer.addParam(std::move(valueParam));
8540 }
8541
8542 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT, std::move(paramBuffer));
8543 }
8544
CaptureProgramUniformMatrix3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8545 CallCapture CaptureProgramUniformMatrix3fvEXT(const State &glState,
8546 bool isCallValid,
8547 ShaderProgramID programPacked,
8548 UniformLocation locationPacked,
8549 GLsizei count,
8550 GLboolean transpose,
8551 const GLfloat *value)
8552 {
8553 ParamBuffer paramBuffer;
8554
8555 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8556 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8557 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8558 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8559
8560 if (isCallValid)
8561 {
8562 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8563 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8564 CaptureProgramUniformMatrix3fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8565 count, transpose, value, &valueParam);
8566 paramBuffer.addParam(std::move(valueParam));
8567 }
8568 else
8569 {
8570 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8571 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8572 &valueParam.value);
8573 paramBuffer.addParam(std::move(valueParam));
8574 }
8575
8576 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3fvEXT, std::move(paramBuffer));
8577 }
8578
CaptureProgramUniformMatrix3x2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8579 CallCapture CaptureProgramUniformMatrix3x2fvEXT(const State &glState,
8580 bool isCallValid,
8581 ShaderProgramID programPacked,
8582 UniformLocation locationPacked,
8583 GLsizei count,
8584 GLboolean transpose,
8585 const GLfloat *value)
8586 {
8587 ParamBuffer paramBuffer;
8588
8589 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8590 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8591 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8592 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8593
8594 if (isCallValid)
8595 {
8596 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8597 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8598 CaptureProgramUniformMatrix3x2fvEXT_value(glState, isCallValid, programPacked,
8599 locationPacked, count, transpose, value,
8600 &valueParam);
8601 paramBuffer.addParam(std::move(valueParam));
8602 }
8603 else
8604 {
8605 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8606 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8607 &valueParam.value);
8608 paramBuffer.addParam(std::move(valueParam));
8609 }
8610
8611 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT, std::move(paramBuffer));
8612 }
8613
CaptureProgramUniformMatrix3x4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8614 CallCapture CaptureProgramUniformMatrix3x4fvEXT(const State &glState,
8615 bool isCallValid,
8616 ShaderProgramID programPacked,
8617 UniformLocation locationPacked,
8618 GLsizei count,
8619 GLboolean transpose,
8620 const GLfloat *value)
8621 {
8622 ParamBuffer paramBuffer;
8623
8624 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8625 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8626 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8627 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8628
8629 if (isCallValid)
8630 {
8631 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8632 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8633 CaptureProgramUniformMatrix3x4fvEXT_value(glState, isCallValid, programPacked,
8634 locationPacked, count, transpose, value,
8635 &valueParam);
8636 paramBuffer.addParam(std::move(valueParam));
8637 }
8638 else
8639 {
8640 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8641 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8642 &valueParam.value);
8643 paramBuffer.addParam(std::move(valueParam));
8644 }
8645
8646 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT, std::move(paramBuffer));
8647 }
8648
CaptureProgramUniformMatrix4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8649 CallCapture CaptureProgramUniformMatrix4fvEXT(const State &glState,
8650 bool isCallValid,
8651 ShaderProgramID programPacked,
8652 UniformLocation locationPacked,
8653 GLsizei count,
8654 GLboolean transpose,
8655 const GLfloat *value)
8656 {
8657 ParamBuffer paramBuffer;
8658
8659 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8660 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8661 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8662 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8663
8664 if (isCallValid)
8665 {
8666 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8667 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8668 CaptureProgramUniformMatrix4fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8669 count, transpose, value, &valueParam);
8670 paramBuffer.addParam(std::move(valueParam));
8671 }
8672 else
8673 {
8674 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8675 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8676 &valueParam.value);
8677 paramBuffer.addParam(std::move(valueParam));
8678 }
8679
8680 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4fvEXT, std::move(paramBuffer));
8681 }
8682
CaptureProgramUniformMatrix4x2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8683 CallCapture CaptureProgramUniformMatrix4x2fvEXT(const State &glState,
8684 bool isCallValid,
8685 ShaderProgramID programPacked,
8686 UniformLocation locationPacked,
8687 GLsizei count,
8688 GLboolean transpose,
8689 const GLfloat *value)
8690 {
8691 ParamBuffer paramBuffer;
8692
8693 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8694 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8695 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8696 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8697
8698 if (isCallValid)
8699 {
8700 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8701 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8702 CaptureProgramUniformMatrix4x2fvEXT_value(glState, isCallValid, programPacked,
8703 locationPacked, count, transpose, value,
8704 &valueParam);
8705 paramBuffer.addParam(std::move(valueParam));
8706 }
8707 else
8708 {
8709 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8710 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8711 &valueParam.value);
8712 paramBuffer.addParam(std::move(valueParam));
8713 }
8714
8715 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT, std::move(paramBuffer));
8716 }
8717
CaptureProgramUniformMatrix4x3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8718 CallCapture CaptureProgramUniformMatrix4x3fvEXT(const State &glState,
8719 bool isCallValid,
8720 ShaderProgramID programPacked,
8721 UniformLocation locationPacked,
8722 GLsizei count,
8723 GLboolean transpose,
8724 const GLfloat *value)
8725 {
8726 ParamBuffer paramBuffer;
8727
8728 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8729 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8730 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8731 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8732
8733 if (isCallValid)
8734 {
8735 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8736 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8737 CaptureProgramUniformMatrix4x3fvEXT_value(glState, isCallValid, programPacked,
8738 locationPacked, count, transpose, value,
8739 &valueParam);
8740 paramBuffer.addParam(std::move(valueParam));
8741 }
8742 else
8743 {
8744 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8745 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8746 &valueParam.value);
8747 paramBuffer.addParam(std::move(valueParam));
8748 }
8749
8750 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT, std::move(paramBuffer));
8751 }
8752
CaptureUseProgramStagesEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLbitfield stages,ShaderProgramID programPacked)8753 CallCapture CaptureUseProgramStagesEXT(const State &glState,
8754 bool isCallValid,
8755 ProgramPipelineID pipelinePacked,
8756 GLbitfield stages,
8757 ShaderProgramID programPacked)
8758 {
8759 ParamBuffer paramBuffer;
8760
8761 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
8762 paramBuffer.addEnumParam("stages", GLESEnum::UseProgramStageMask, ParamType::TGLbitfield,
8763 stages);
8764 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8765
8766 return CallCapture(angle::EntryPoint::GLUseProgramStagesEXT, std::move(paramBuffer));
8767 }
8768
CaptureValidateProgramPipelineEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked)8769 CallCapture CaptureValidateProgramPipelineEXT(const State &glState,
8770 bool isCallValid,
8771 ProgramPipelineID pipelinePacked)
8772 {
8773 ParamBuffer paramBuffer;
8774
8775 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
8776
8777 return CallCapture(angle::EntryPoint::GLValidateProgramPipelineEXT, std::move(paramBuffer));
8778 }
8779
CaptureFramebufferFetchBarrierEXT(const State & glState,bool isCallValid)8780 CallCapture CaptureFramebufferFetchBarrierEXT(const State &glState, bool isCallValid)
8781 {
8782 ParamBuffer paramBuffer;
8783
8784 return CallCapture(angle::EntryPoint::GLFramebufferFetchBarrierEXT, std::move(paramBuffer));
8785 }
8786
CapturePatchParameteriEXT(const State & glState,bool isCallValid,GLenum pname,GLint value)8787 CallCapture CapturePatchParameteriEXT(const State &glState,
8788 bool isCallValid,
8789 GLenum pname,
8790 GLint value)
8791 {
8792 ParamBuffer paramBuffer;
8793
8794 paramBuffer.addEnumParam("pname", GLESEnum::PatchParameterName, ParamType::TGLenum, pname);
8795 paramBuffer.addValueParam("value", ParamType::TGLint, value);
8796
8797 return CallCapture(angle::EntryPoint::GLPatchParameteriEXT, std::move(paramBuffer));
8798 }
8799
CaptureGetSamplerParameterIivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)8800 CallCapture CaptureGetSamplerParameterIivEXT(const State &glState,
8801 bool isCallValid,
8802 SamplerID samplerPacked,
8803 GLenum pname,
8804 GLint *params)
8805 {
8806 ParamBuffer paramBuffer;
8807
8808 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8809 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
8810
8811 if (isCallValid)
8812 {
8813 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8814 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
8815 CaptureGetSamplerParameterIivEXT_params(glState, isCallValid, samplerPacked, pname, params,
8816 ¶msParam);
8817 paramBuffer.addParam(std::move(paramsParam));
8818 }
8819 else
8820 {
8821 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8822 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
8823 paramBuffer.addParam(std::move(paramsParam));
8824 }
8825
8826 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivEXT, std::move(paramBuffer));
8827 }
8828
CaptureGetSamplerParameterIuivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)8829 CallCapture CaptureGetSamplerParameterIuivEXT(const State &glState,
8830 bool isCallValid,
8831 SamplerID samplerPacked,
8832 GLenum pname,
8833 GLuint *params)
8834 {
8835 ParamBuffer paramBuffer;
8836
8837 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8838 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
8839
8840 if (isCallValid)
8841 {
8842 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8843 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
8844 CaptureGetSamplerParameterIuivEXT_params(glState, isCallValid, samplerPacked, pname, params,
8845 ¶msParam);
8846 paramBuffer.addParam(std::move(paramsParam));
8847 }
8848 else
8849 {
8850 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8851 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
8852 ¶msParam.value);
8853 paramBuffer.addParam(std::move(paramsParam));
8854 }
8855
8856 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivEXT, std::move(paramBuffer));
8857 }
8858
CaptureGetTexParameterIivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)8859 CallCapture CaptureGetTexParameterIivEXT(const State &glState,
8860 bool isCallValid,
8861 TextureType targetPacked,
8862 GLenum pname,
8863 GLint *params)
8864 {
8865 ParamBuffer paramBuffer;
8866
8867 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8868 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
8869
8870 if (isCallValid)
8871 {
8872 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8873 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
8874 CaptureGetTexParameterIivEXT_params(glState, isCallValid, targetPacked, pname, params,
8875 ¶msParam);
8876 paramBuffer.addParam(std::move(paramsParam));
8877 }
8878 else
8879 {
8880 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8881 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
8882 paramBuffer.addParam(std::move(paramsParam));
8883 }
8884
8885 return CallCapture(angle::EntryPoint::GLGetTexParameterIivEXT, std::move(paramBuffer));
8886 }
8887
CaptureGetTexParameterIuivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)8888 CallCapture CaptureGetTexParameterIuivEXT(const State &glState,
8889 bool isCallValid,
8890 TextureType targetPacked,
8891 GLenum pname,
8892 GLuint *params)
8893 {
8894 ParamBuffer paramBuffer;
8895
8896 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8897 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
8898
8899 if (isCallValid)
8900 {
8901 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8902 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
8903 CaptureGetTexParameterIuivEXT_params(glState, isCallValid, targetPacked, pname, params,
8904 ¶msParam);
8905 paramBuffer.addParam(std::move(paramsParam));
8906 }
8907 else
8908 {
8909 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8910 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
8911 ¶msParam.value);
8912 paramBuffer.addParam(std::move(paramsParam));
8913 }
8914
8915 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivEXT, std::move(paramBuffer));
8916 }
8917
CaptureSamplerParameterIivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)8918 CallCapture CaptureSamplerParameterIivEXT(const State &glState,
8919 bool isCallValid,
8920 SamplerID samplerPacked,
8921 GLenum pname,
8922 const GLint *param)
8923 {
8924 ParamBuffer paramBuffer;
8925
8926 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8927 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
8928
8929 if (isCallValid)
8930 {
8931 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
8932 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
8933 CaptureSamplerParameterIivEXT_param(glState, isCallValid, samplerPacked, pname, param,
8934 ¶mParam);
8935 paramBuffer.addParam(std::move(paramParam));
8936 }
8937 else
8938 {
8939 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
8940 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8941 ¶mParam.value);
8942 paramBuffer.addParam(std::move(paramParam));
8943 }
8944
8945 return CallCapture(angle::EntryPoint::GLSamplerParameterIivEXT, std::move(paramBuffer));
8946 }
8947
CaptureSamplerParameterIuivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)8948 CallCapture CaptureSamplerParameterIuivEXT(const State &glState,
8949 bool isCallValid,
8950 SamplerID samplerPacked,
8951 GLenum pname,
8952 const GLuint *param)
8953 {
8954 ParamBuffer paramBuffer;
8955
8956 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8957 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
8958
8959 if (isCallValid)
8960 {
8961 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
8962 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
8963 CaptureSamplerParameterIuivEXT_param(glState, isCallValid, samplerPacked, pname, param,
8964 ¶mParam);
8965 paramBuffer.addParam(std::move(paramParam));
8966 }
8967 else
8968 {
8969 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
8970 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8971 ¶mParam.value);
8972 paramBuffer.addParam(std::move(paramParam));
8973 }
8974
8975 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivEXT, std::move(paramBuffer));
8976 }
8977
CaptureTexParameterIivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)8978 CallCapture CaptureTexParameterIivEXT(const State &glState,
8979 bool isCallValid,
8980 TextureType targetPacked,
8981 GLenum pname,
8982 const GLint *params)
8983 {
8984 ParamBuffer paramBuffer;
8985
8986 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8987 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
8988
8989 if (isCallValid)
8990 {
8991 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
8992 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
8993 CaptureTexParameterIivEXT_params(glState, isCallValid, targetPacked, pname, params,
8994 ¶msParam);
8995 paramBuffer.addParam(std::move(paramsParam));
8996 }
8997 else
8998 {
8999 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
9000 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
9001 ¶msParam.value);
9002 paramBuffer.addParam(std::move(paramsParam));
9003 }
9004
9005 return CallCapture(angle::EntryPoint::GLTexParameterIivEXT, std::move(paramBuffer));
9006 }
9007
CaptureTexParameterIuivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)9008 CallCapture CaptureTexParameterIuivEXT(const State &glState,
9009 bool isCallValid,
9010 TextureType targetPacked,
9011 GLenum pname,
9012 const GLuint *params)
9013 {
9014 ParamBuffer paramBuffer;
9015
9016 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9017 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
9018
9019 if (isCallValid)
9020 {
9021 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
9022 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
9023 CaptureTexParameterIuivEXT_params(glState, isCallValid, targetPacked, pname, params,
9024 ¶msParam);
9025 paramBuffer.addParam(std::move(paramsParam));
9026 }
9027 else
9028 {
9029 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
9030 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
9031 ¶msParam.value);
9032 paramBuffer.addParam(std::move(paramsParam));
9033 }
9034
9035 return CallCapture(angle::EntryPoint::GLTexParameterIuivEXT, std::move(paramBuffer));
9036 }
9037
CaptureTexBufferEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)9038 CallCapture CaptureTexBufferEXT(const State &glState,
9039 bool isCallValid,
9040 TextureType targetPacked,
9041 GLenum internalformat,
9042 BufferID bufferPacked)
9043 {
9044 ParamBuffer paramBuffer;
9045
9046 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9047 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9048 internalformat);
9049 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
9050
9051 return CallCapture(angle::EntryPoint::GLTexBufferEXT, std::move(paramBuffer));
9052 }
9053
CaptureTexBufferRangeEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)9054 CallCapture CaptureTexBufferRangeEXT(const State &glState,
9055 bool isCallValid,
9056 TextureType targetPacked,
9057 GLenum internalformat,
9058 BufferID bufferPacked,
9059 GLintptr offset,
9060 GLsizeiptr size)
9061 {
9062 ParamBuffer paramBuffer;
9063
9064 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9065 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9066 internalformat);
9067 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
9068 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
9069 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
9070
9071 return CallCapture(angle::EntryPoint::GLTexBufferRangeEXT, std::move(paramBuffer));
9072 }
9073
CaptureTexStorage1DEXT(const State & glState,bool isCallValid,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)9074 CallCapture CaptureTexStorage1DEXT(const State &glState,
9075 bool isCallValid,
9076 GLenum target,
9077 GLsizei levels,
9078 GLenum internalformat,
9079 GLsizei width)
9080 {
9081 ParamBuffer paramBuffer;
9082
9083 paramBuffer.addEnumParam("target", GLESEnum::TextureTarget, ParamType::TGLenum, target);
9084 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9085 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9086 internalformat);
9087 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9088
9089 return CallCapture(angle::EntryPoint::GLTexStorage1DEXT, std::move(paramBuffer));
9090 }
9091
CaptureTexStorage2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)9092 CallCapture CaptureTexStorage2DEXT(const State &glState,
9093 bool isCallValid,
9094 TextureType targetPacked,
9095 GLsizei levels,
9096 GLenum internalformat,
9097 GLsizei width,
9098 GLsizei height)
9099 {
9100 ParamBuffer paramBuffer;
9101
9102 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9103 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9104 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9105 internalformat);
9106 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9107 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9108
9109 return CallCapture(angle::EntryPoint::GLTexStorage2DEXT, std::move(paramBuffer));
9110 }
9111
CaptureTexStorage3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)9112 CallCapture CaptureTexStorage3DEXT(const State &glState,
9113 bool isCallValid,
9114 TextureType targetPacked,
9115 GLsizei levels,
9116 GLenum internalformat,
9117 GLsizei width,
9118 GLsizei height,
9119 GLsizei depth)
9120 {
9121 ParamBuffer paramBuffer;
9122
9123 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9124 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9125 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9126 internalformat);
9127 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9128 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9129 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
9130
9131 return CallCapture(angle::EntryPoint::GLTexStorage3DEXT, std::move(paramBuffer));
9132 }
9133
CaptureBlendBarrierKHR(const State & glState,bool isCallValid)9134 CallCapture CaptureBlendBarrierKHR(const State &glState, bool isCallValid)
9135 {
9136 ParamBuffer paramBuffer;
9137
9138 return CallCapture(angle::EntryPoint::GLBlendBarrierKHR, std::move(paramBuffer));
9139 }
9140
CaptureDebugMessageCallbackKHR(const State & glState,bool isCallValid,GLDEBUGPROCKHR callback,const void * userParam)9141 CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
9142 bool isCallValid,
9143 GLDEBUGPROCKHR callback,
9144 const void *userParam)
9145 {
9146 ParamBuffer paramBuffer;
9147
9148 paramBuffer.addValueParam("callback", ParamType::TGLDEBUGPROCKHR, callback);
9149
9150 if (isCallValid)
9151 {
9152 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
9153 InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
9154 CaptureDebugMessageCallbackKHR_userParam(glState, isCallValid, callback, userParam,
9155 &userParamParam);
9156 paramBuffer.addParam(std::move(userParamParam));
9157 }
9158 else
9159 {
9160 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
9161 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
9162 &userParamParam.value);
9163 paramBuffer.addParam(std::move(userParamParam));
9164 }
9165
9166 return CallCapture(angle::EntryPoint::GLDebugMessageCallbackKHR, std::move(paramBuffer));
9167 }
9168
CaptureDebugMessageControlKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)9169 CallCapture CaptureDebugMessageControlKHR(const State &glState,
9170 bool isCallValid,
9171 GLenum source,
9172 GLenum type,
9173 GLenum severity,
9174 GLsizei count,
9175 const GLuint *ids,
9176 GLboolean enabled)
9177 {
9178 ParamBuffer paramBuffer;
9179
9180 paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source);
9181 paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type);
9182 paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity);
9183 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
9184
9185 if (isCallValid)
9186 {
9187 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
9188 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
9189 CaptureDebugMessageControlKHR_ids(glState, isCallValid, source, type, severity, count, ids,
9190 enabled, &idsParam);
9191 paramBuffer.addParam(std::move(idsParam));
9192 }
9193 else
9194 {
9195 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
9196 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
9197 &idsParam.value);
9198 paramBuffer.addParam(std::move(idsParam));
9199 }
9200
9201 paramBuffer.addValueParam("enabled", ParamType::TGLboolean, enabled);
9202
9203 return CallCapture(angle::EntryPoint::GLDebugMessageControlKHR, std::move(paramBuffer));
9204 }
9205
CaptureDebugMessageInsertKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)9206 CallCapture CaptureDebugMessageInsertKHR(const State &glState,
9207 bool isCallValid,
9208 GLenum source,
9209 GLenum type,
9210 GLuint id,
9211 GLenum severity,
9212 GLsizei length,
9213 const GLchar *buf)
9214 {
9215 ParamBuffer paramBuffer;
9216
9217 paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source);
9218 paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type);
9219 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
9220 paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity);
9221 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9222
9223 if (isCallValid)
9224 {
9225 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
9226 InitParamValue(ParamType::TGLcharConstPointer, buf, &bufParam.value);
9227 CaptureDebugMessageInsertKHR_buf(glState, isCallValid, source, type, id, severity, length,
9228 buf, &bufParam);
9229 paramBuffer.addParam(std::move(bufParam));
9230 }
9231 else
9232 {
9233 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
9234 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9235 &bufParam.value);
9236 paramBuffer.addParam(std::move(bufParam));
9237 }
9238
9239 return CallCapture(angle::EntryPoint::GLDebugMessageInsertKHR, std::move(paramBuffer));
9240 }
9241
CaptureGetDebugMessageLogKHR(const State & glState,bool isCallValid,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog,GLuint returnValue)9242 CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
9243 bool isCallValid,
9244 GLuint count,
9245 GLsizei bufSize,
9246 GLenum *sources,
9247 GLenum *types,
9248 GLuint *ids,
9249 GLenum *severities,
9250 GLsizei *lengths,
9251 GLchar *messageLog,
9252 GLuint returnValue)
9253 {
9254 ParamBuffer paramBuffer;
9255
9256 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
9257 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9258
9259 if (isCallValid)
9260 {
9261 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
9262 InitParamValue(ParamType::TGLenumPointer, sources, &sourcesParam.value);
9263 CaptureGetDebugMessageLogKHR_sources(glState, isCallValid, count, bufSize, sources, types,
9264 ids, severities, lengths, messageLog, &sourcesParam);
9265 paramBuffer.addParam(std::move(sourcesParam));
9266 }
9267 else
9268 {
9269 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
9270 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
9271 &sourcesParam.value);
9272 paramBuffer.addParam(std::move(sourcesParam));
9273 }
9274
9275 if (isCallValid)
9276 {
9277 ParamCapture typesParam("types", ParamType::TGLenumPointer);
9278 InitParamValue(ParamType::TGLenumPointer, types, &typesParam.value);
9279 CaptureGetDebugMessageLogKHR_types(glState, isCallValid, count, bufSize, sources, types,
9280 ids, severities, lengths, messageLog, &typesParam);
9281 paramBuffer.addParam(std::move(typesParam));
9282 }
9283 else
9284 {
9285 ParamCapture typesParam("types", ParamType::TGLenumPointer);
9286 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
9287 &typesParam.value);
9288 paramBuffer.addParam(std::move(typesParam));
9289 }
9290
9291 if (isCallValid)
9292 {
9293 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
9294 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
9295 CaptureGetDebugMessageLogKHR_ids(glState, isCallValid, count, bufSize, sources, types, ids,
9296 severities, lengths, messageLog, &idsParam);
9297 paramBuffer.addParam(std::move(idsParam));
9298 }
9299 else
9300 {
9301 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
9302 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &idsParam.value);
9303 paramBuffer.addParam(std::move(idsParam));
9304 }
9305
9306 if (isCallValid)
9307 {
9308 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
9309 InitParamValue(ParamType::TGLenumPointer, severities, &severitiesParam.value);
9310 CaptureGetDebugMessageLogKHR_severities(glState, isCallValid, count, bufSize, sources,
9311 types, ids, severities, lengths, messageLog,
9312 &severitiesParam);
9313 paramBuffer.addParam(std::move(severitiesParam));
9314 }
9315 else
9316 {
9317 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
9318 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
9319 &severitiesParam.value);
9320 paramBuffer.addParam(std::move(severitiesParam));
9321 }
9322
9323 if (isCallValid)
9324 {
9325 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
9326 InitParamValue(ParamType::TGLsizeiPointer, lengths, &lengthsParam.value);
9327 CaptureGetDebugMessageLogKHR_lengths(glState, isCallValid, count, bufSize, sources, types,
9328 ids, severities, lengths, messageLog, &lengthsParam);
9329 paramBuffer.addParam(std::move(lengthsParam));
9330 }
9331 else
9332 {
9333 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
9334 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
9335 &lengthsParam.value);
9336 paramBuffer.addParam(std::move(lengthsParam));
9337 }
9338
9339 if (isCallValid)
9340 {
9341 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
9342 InitParamValue(ParamType::TGLcharPointer, messageLog, &messageLogParam.value);
9343 CaptureGetDebugMessageLogKHR_messageLog(glState, isCallValid, count, bufSize, sources,
9344 types, ids, severities, lengths, messageLog,
9345 &messageLogParam);
9346 paramBuffer.addParam(std::move(messageLogParam));
9347 }
9348 else
9349 {
9350 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
9351 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
9352 &messageLogParam.value);
9353 paramBuffer.addParam(std::move(messageLogParam));
9354 }
9355
9356 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
9357 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
9358 paramBuffer.addReturnValue(std::move(returnValueCapture));
9359
9360 return CallCapture(angle::EntryPoint::GLGetDebugMessageLogKHR, std::move(paramBuffer));
9361 }
9362
CaptureGetObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)9363 CallCapture CaptureGetObjectLabelKHR(const State &glState,
9364 bool isCallValid,
9365 GLenum identifier,
9366 GLuint name,
9367 GLsizei bufSize,
9368 GLsizei *length,
9369 GLchar *label)
9370 {
9371 ParamBuffer paramBuffer;
9372
9373 paramBuffer.addEnumParam("identifier", GLESEnum::AllEnums, ParamType::TGLenum, identifier);
9374 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
9375 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9376
9377 if (isCallValid)
9378 {
9379 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9380 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
9381 CaptureGetObjectLabelKHR_length(glState, isCallValid, identifier, name, bufSize, length,
9382 label, &lengthParam);
9383 paramBuffer.addParam(std::move(lengthParam));
9384 }
9385 else
9386 {
9387 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9388 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
9389 &lengthParam.value);
9390 paramBuffer.addParam(std::move(lengthParam));
9391 }
9392
9393 if (isCallValid)
9394 {
9395 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9396 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
9397 CaptureGetObjectLabelKHR_label(glState, isCallValid, identifier, name, bufSize, length,
9398 label, &labelParam);
9399 paramBuffer.addParam(std::move(labelParam));
9400 }
9401 else
9402 {
9403 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9404 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
9405 &labelParam.value);
9406 paramBuffer.addParam(std::move(labelParam));
9407 }
9408
9409 return CallCapture(angle::EntryPoint::GLGetObjectLabelKHR, std::move(paramBuffer));
9410 }
9411
CaptureGetObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)9412 CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
9413 bool isCallValid,
9414 const void *ptr,
9415 GLsizei bufSize,
9416 GLsizei *length,
9417 GLchar *label)
9418 {
9419 ParamBuffer paramBuffer;
9420
9421 if (isCallValid)
9422 {
9423 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9424 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
9425 CaptureGetObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, bufSize, length, label,
9426 &ptrParam);
9427 paramBuffer.addParam(std::move(ptrParam));
9428 }
9429 else
9430 {
9431 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9432 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
9433 &ptrParam.value);
9434 paramBuffer.addParam(std::move(ptrParam));
9435 }
9436
9437 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9438
9439 if (isCallValid)
9440 {
9441 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9442 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
9443 CaptureGetObjectPtrLabelKHR_length(glState, isCallValid, ptr, bufSize, length, label,
9444 &lengthParam);
9445 paramBuffer.addParam(std::move(lengthParam));
9446 }
9447 else
9448 {
9449 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9450 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
9451 &lengthParam.value);
9452 paramBuffer.addParam(std::move(lengthParam));
9453 }
9454
9455 if (isCallValid)
9456 {
9457 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9458 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
9459 CaptureGetObjectPtrLabelKHR_label(glState, isCallValid, ptr, bufSize, length, label,
9460 &labelParam);
9461 paramBuffer.addParam(std::move(labelParam));
9462 }
9463 else
9464 {
9465 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9466 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
9467 &labelParam.value);
9468 paramBuffer.addParam(std::move(labelParam));
9469 }
9470
9471 return CallCapture(angle::EntryPoint::GLGetObjectPtrLabelKHR, std::move(paramBuffer));
9472 }
9473
CaptureGetPointervKHR(const State & glState,bool isCallValid,GLenum pname,void ** params)9474 CallCapture CaptureGetPointervKHR(const State &glState,
9475 bool isCallValid,
9476 GLenum pname,
9477 void **params)
9478 {
9479 ParamBuffer paramBuffer;
9480
9481 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
9482
9483 if (isCallValid)
9484 {
9485 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
9486 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
9487 CaptureGetPointervKHR_params(glState, isCallValid, pname, params, ¶msParam);
9488 paramBuffer.addParam(std::move(paramsParam));
9489 }
9490 else
9491 {
9492 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
9493 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
9494 ¶msParam.value);
9495 paramBuffer.addParam(std::move(paramsParam));
9496 }
9497
9498 return CallCapture(angle::EntryPoint::GLGetPointervKHR, std::move(paramBuffer));
9499 }
9500
CaptureObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)9501 CallCapture CaptureObjectLabelKHR(const State &glState,
9502 bool isCallValid,
9503 GLenum identifier,
9504 GLuint name,
9505 GLsizei length,
9506 const GLchar *label)
9507 {
9508 ParamBuffer paramBuffer;
9509
9510 paramBuffer.addEnumParam("identifier", GLESEnum::ObjectIdentifier, ParamType::TGLenum,
9511 identifier);
9512 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
9513 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9514
9515 if (isCallValid)
9516 {
9517 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9518 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
9519 CaptureObjectLabelKHR_label(glState, isCallValid, identifier, name, length, label,
9520 &labelParam);
9521 paramBuffer.addParam(std::move(labelParam));
9522 }
9523 else
9524 {
9525 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9526 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9527 &labelParam.value);
9528 paramBuffer.addParam(std::move(labelParam));
9529 }
9530
9531 return CallCapture(angle::EntryPoint::GLObjectLabelKHR, std::move(paramBuffer));
9532 }
9533
CaptureObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei length,const GLchar * label)9534 CallCapture CaptureObjectPtrLabelKHR(const State &glState,
9535 bool isCallValid,
9536 const void *ptr,
9537 GLsizei length,
9538 const GLchar *label)
9539 {
9540 ParamBuffer paramBuffer;
9541
9542 if (isCallValid)
9543 {
9544 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9545 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
9546 CaptureObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, length, label, &ptrParam);
9547 paramBuffer.addParam(std::move(ptrParam));
9548 }
9549 else
9550 {
9551 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9552 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
9553 &ptrParam.value);
9554 paramBuffer.addParam(std::move(ptrParam));
9555 }
9556
9557 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9558
9559 if (isCallValid)
9560 {
9561 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9562 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
9563 CaptureObjectPtrLabelKHR_label(glState, isCallValid, ptr, length, label, &labelParam);
9564 paramBuffer.addParam(std::move(labelParam));
9565 }
9566 else
9567 {
9568 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9569 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9570 &labelParam.value);
9571 paramBuffer.addParam(std::move(labelParam));
9572 }
9573
9574 return CallCapture(angle::EntryPoint::GLObjectPtrLabelKHR, std::move(paramBuffer));
9575 }
9576
CapturePopDebugGroupKHR(const State & glState,bool isCallValid)9577 CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid)
9578 {
9579 ParamBuffer paramBuffer;
9580
9581 return CallCapture(angle::EntryPoint::GLPopDebugGroupKHR, std::move(paramBuffer));
9582 }
9583
CapturePushDebugGroupKHR(const State & glState,bool isCallValid,GLenum source,GLuint id,GLsizei length,const GLchar * message)9584 CallCapture CapturePushDebugGroupKHR(const State &glState,
9585 bool isCallValid,
9586 GLenum source,
9587 GLuint id,
9588 GLsizei length,
9589 const GLchar *message)
9590 {
9591 ParamBuffer paramBuffer;
9592
9593 paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source);
9594 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
9595 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9596
9597 if (isCallValid)
9598 {
9599 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
9600 InitParamValue(ParamType::TGLcharConstPointer, message, &messageParam.value);
9601 CapturePushDebugGroupKHR_message(glState, isCallValid, source, id, length, message,
9602 &messageParam);
9603 paramBuffer.addParam(std::move(messageParam));
9604 }
9605 else
9606 {
9607 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
9608 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9609 &messageParam.value);
9610 paramBuffer.addParam(std::move(messageParam));
9611 }
9612
9613 return CallCapture(angle::EntryPoint::GLPushDebugGroupKHR, std::move(paramBuffer));
9614 }
9615
CaptureMaxShaderCompilerThreadsKHR(const State & glState,bool isCallValid,GLuint count)9616 CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState, bool isCallValid, GLuint count)
9617 {
9618 ParamBuffer paramBuffer;
9619
9620 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
9621
9622 return CallCapture(angle::EntryPoint::GLMaxShaderCompilerThreadsKHR, std::move(paramBuffer));
9623 }
9624
CaptureFramebufferParameteriMESA(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint param)9625 CallCapture CaptureFramebufferParameteriMESA(const State &glState,
9626 bool isCallValid,
9627 GLenum target,
9628 GLenum pname,
9629 GLint param)
9630 {
9631 ParamBuffer paramBuffer;
9632
9633 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
9634 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferParameterName, ParamType::TGLenum,
9635 pname);
9636 paramBuffer.addValueParam("param", ParamType::TGLint, param);
9637
9638 return CallCapture(angle::EntryPoint::GLFramebufferParameteriMESA, std::move(paramBuffer));
9639 }
9640
CaptureGetFramebufferParameterivMESA(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)9641 CallCapture CaptureGetFramebufferParameterivMESA(const State &glState,
9642 bool isCallValid,
9643 GLenum target,
9644 GLenum pname,
9645 GLint *params)
9646 {
9647 ParamBuffer paramBuffer;
9648
9649 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
9650 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName,
9651 ParamType::TGLenum, pname);
9652
9653 if (isCallValid)
9654 {
9655 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9656 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9657 CaptureGetFramebufferParameterivMESA_params(glState, isCallValid, target, pname, params,
9658 ¶msParam);
9659 paramBuffer.addParam(std::move(paramsParam));
9660 }
9661 else
9662 {
9663 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9664 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9665 paramBuffer.addParam(std::move(paramsParam));
9666 }
9667
9668 return CallCapture(angle::EntryPoint::GLGetFramebufferParameterivMESA, std::move(paramBuffer));
9669 }
9670
CaptureDeleteFencesNV(const State & glState,bool isCallValid,GLsizei n,const FenceNVID * fencesPacked)9671 CallCapture CaptureDeleteFencesNV(const State &glState,
9672 bool isCallValid,
9673 GLsizei n,
9674 const FenceNVID *fencesPacked)
9675 {
9676 ParamBuffer paramBuffer;
9677
9678 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
9679
9680 if (isCallValid)
9681 {
9682 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
9683 InitParamValue(ParamType::TFenceNVIDConstPointer, fencesPacked, &fencesPackedParam.value);
9684 CaptureDeleteFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked,
9685 &fencesPackedParam);
9686 paramBuffer.addParam(std::move(fencesPackedParam));
9687 }
9688 else
9689 {
9690 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
9691 InitParamValue(ParamType::TFenceNVIDConstPointer, static_cast<const FenceNVID *>(nullptr),
9692 &fencesPackedParam.value);
9693 paramBuffer.addParam(std::move(fencesPackedParam));
9694 }
9695
9696 return CallCapture(angle::EntryPoint::GLDeleteFencesNV, std::move(paramBuffer));
9697 }
9698
CaptureFinishFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked)9699 CallCapture CaptureFinishFenceNV(const State &glState, bool isCallValid, FenceNVID fencePacked)
9700 {
9701 ParamBuffer paramBuffer;
9702
9703 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9704
9705 return CallCapture(angle::EntryPoint::GLFinishFenceNV, std::move(paramBuffer));
9706 }
9707
CaptureGenFencesNV(const State & glState,bool isCallValid,GLsizei n,FenceNVID * fencesPacked)9708 CallCapture CaptureGenFencesNV(const State &glState,
9709 bool isCallValid,
9710 GLsizei n,
9711 FenceNVID *fencesPacked)
9712 {
9713 ParamBuffer paramBuffer;
9714
9715 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
9716
9717 if (isCallValid)
9718 {
9719 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
9720 InitParamValue(ParamType::TFenceNVIDPointer, fencesPacked, &fencesPackedParam.value);
9721 CaptureGenFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked, &fencesPackedParam);
9722 paramBuffer.addParam(std::move(fencesPackedParam));
9723 }
9724 else
9725 {
9726 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
9727 InitParamValue(ParamType::TFenceNVIDPointer, static_cast<FenceNVID *>(nullptr),
9728 &fencesPackedParam.value);
9729 paramBuffer.addParam(std::move(fencesPackedParam));
9730 }
9731
9732 return CallCapture(angle::EntryPoint::GLGenFencesNV, std::move(paramBuffer));
9733 }
9734
CaptureGetFenceivNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum pname,GLint * params)9735 CallCapture CaptureGetFenceivNV(const State &glState,
9736 bool isCallValid,
9737 FenceNVID fencePacked,
9738 GLenum pname,
9739 GLint *params)
9740 {
9741 ParamBuffer paramBuffer;
9742
9743 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9744 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
9745
9746 if (isCallValid)
9747 {
9748 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9749 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9750 CaptureGetFenceivNV_params(glState, isCallValid, fencePacked, pname, params, ¶msParam);
9751 paramBuffer.addParam(std::move(paramsParam));
9752 }
9753 else
9754 {
9755 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9756 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9757 paramBuffer.addParam(std::move(paramsParam));
9758 }
9759
9760 return CallCapture(angle::EntryPoint::GLGetFenceivNV, std::move(paramBuffer));
9761 }
9762
CaptureIsFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)9763 CallCapture CaptureIsFenceNV(const State &glState,
9764 bool isCallValid,
9765 FenceNVID fencePacked,
9766 GLboolean returnValue)
9767 {
9768 ParamBuffer paramBuffer;
9769
9770 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9771
9772 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
9773 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
9774 paramBuffer.addReturnValue(std::move(returnValueCapture));
9775
9776 return CallCapture(angle::EntryPoint::GLIsFenceNV, std::move(paramBuffer));
9777 }
9778
CaptureSetFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum condition)9779 CallCapture CaptureSetFenceNV(const State &glState,
9780 bool isCallValid,
9781 FenceNVID fencePacked,
9782 GLenum condition)
9783 {
9784 ParamBuffer paramBuffer;
9785
9786 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9787 paramBuffer.addEnumParam("condition", GLESEnum::AllEnums, ParamType::TGLenum, condition);
9788
9789 return CallCapture(angle::EntryPoint::GLSetFenceNV, std::move(paramBuffer));
9790 }
9791
CaptureTestFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)9792 CallCapture CaptureTestFenceNV(const State &glState,
9793 bool isCallValid,
9794 FenceNVID fencePacked,
9795 GLboolean returnValue)
9796 {
9797 ParamBuffer paramBuffer;
9798
9799 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9800
9801 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
9802 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
9803 paramBuffer.addReturnValue(std::move(returnValueCapture));
9804
9805 return CallCapture(angle::EntryPoint::GLTestFenceNV, std::move(paramBuffer));
9806 }
9807
CaptureBlitFramebufferNV(const State & glState,bool isCallValid,GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)9808 CallCapture CaptureBlitFramebufferNV(const State &glState,
9809 bool isCallValid,
9810 GLint srcX0,
9811 GLint srcY0,
9812 GLint srcX1,
9813 GLint srcY1,
9814 GLint dstX0,
9815 GLint dstY0,
9816 GLint dstX1,
9817 GLint dstY1,
9818 GLbitfield mask,
9819 GLenum filter)
9820 {
9821 ParamBuffer paramBuffer;
9822
9823 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
9824 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
9825 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
9826 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
9827 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
9828 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
9829 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
9830 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
9831 paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask);
9832 paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter);
9833
9834 return CallCapture(angle::EntryPoint::GLBlitFramebufferNV, std::move(paramBuffer));
9835 }
9836
CapturePolygonModeNV(const State & glState,bool isCallValid,GLenum face,PolygonMode modePacked)9837 CallCapture CapturePolygonModeNV(const State &glState,
9838 bool isCallValid,
9839 GLenum face,
9840 PolygonMode modePacked)
9841 {
9842 ParamBuffer paramBuffer;
9843
9844 paramBuffer.addEnumParam("face", GLESEnum::TriangleFace, ParamType::TGLenum, face);
9845 paramBuffer.addValueParam("modePacked", ParamType::TPolygonMode, modePacked);
9846
9847 return CallCapture(angle::EntryPoint::GLPolygonModeNV, std::move(paramBuffer));
9848 }
9849
CaptureEGLImageTargetRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,egl::ImageID imagePacked)9850 CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
9851 bool isCallValid,
9852 GLenum target,
9853 egl::ImageID imagePacked)
9854 {
9855 ParamBuffer paramBuffer;
9856
9857 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
9858 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
9859
9860 return CallCapture(angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES,
9861 std::move(paramBuffer));
9862 }
9863
CaptureEGLImageTargetTexture2DOES(const State & glState,bool isCallValid,TextureType targetPacked,egl::ImageID imagePacked)9864 CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
9865 bool isCallValid,
9866 TextureType targetPacked,
9867 egl::ImageID imagePacked)
9868 {
9869 ParamBuffer paramBuffer;
9870
9871 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9872 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
9873
9874 return CallCapture(angle::EntryPoint::GLEGLImageTargetTexture2DOES, std::move(paramBuffer));
9875 }
9876
CaptureCopyImageSubDataOES(const State & glState,bool isCallValid,GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth)9877 CallCapture CaptureCopyImageSubDataOES(const State &glState,
9878 bool isCallValid,
9879 GLuint srcName,
9880 GLenum srcTarget,
9881 GLint srcLevel,
9882 GLint srcX,
9883 GLint srcY,
9884 GLint srcZ,
9885 GLuint dstName,
9886 GLenum dstTarget,
9887 GLint dstLevel,
9888 GLint dstX,
9889 GLint dstY,
9890 GLint dstZ,
9891 GLsizei srcWidth,
9892 GLsizei srcHeight,
9893 GLsizei srcDepth)
9894 {
9895 ParamBuffer paramBuffer;
9896
9897 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
9898 paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
9899 srcTarget);
9900 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
9901 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
9902 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
9903 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
9904 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
9905 paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
9906 dstTarget);
9907 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
9908 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
9909 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
9910 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
9911 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
9912 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
9913 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
9914
9915 return CallCapture(angle::EntryPoint::GLCopyImageSubDataOES, std::move(paramBuffer));
9916 }
9917
CaptureBlendEquationSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)9918 CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
9919 bool isCallValid,
9920 GLuint buf,
9921 GLenum modeRGB,
9922 GLenum modeAlpha)
9923 {
9924 ParamBuffer paramBuffer;
9925
9926 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
9927 paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
9928 modeRGB);
9929 paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
9930 modeAlpha);
9931
9932 return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiOES, std::move(paramBuffer));
9933 }
9934
CaptureBlendEquationiOES(const State & glState,bool isCallValid,GLuint buf,GLenum mode)9935 CallCapture CaptureBlendEquationiOES(const State &glState,
9936 bool isCallValid,
9937 GLuint buf,
9938 GLenum mode)
9939 {
9940 ParamBuffer paramBuffer;
9941
9942 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
9943 paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode);
9944
9945 return CallCapture(angle::EntryPoint::GLBlendEquationiOES, std::move(paramBuffer));
9946 }
9947
CaptureBlendFuncSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)9948 CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
9949 bool isCallValid,
9950 GLuint buf,
9951 GLenum srcRGB,
9952 GLenum dstRGB,
9953 GLenum srcAlpha,
9954 GLenum dstAlpha)
9955 {
9956 ParamBuffer paramBuffer;
9957
9958 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
9959 paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB);
9960 paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB);
9961 paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha);
9962 paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha);
9963
9964 return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiOES, std::move(paramBuffer));
9965 }
9966
CaptureBlendFunciOES(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)9967 CallCapture CaptureBlendFunciOES(const State &glState,
9968 bool isCallValid,
9969 GLuint buf,
9970 GLenum src,
9971 GLenum dst)
9972 {
9973 ParamBuffer paramBuffer;
9974
9975 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
9976 paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src);
9977 paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst);
9978
9979 return CallCapture(angle::EntryPoint::GLBlendFunciOES, std::move(paramBuffer));
9980 }
9981
CaptureColorMaskiOES(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)9982 CallCapture CaptureColorMaskiOES(const State &glState,
9983 bool isCallValid,
9984 GLuint index,
9985 GLboolean r,
9986 GLboolean g,
9987 GLboolean b,
9988 GLboolean a)
9989 {
9990 ParamBuffer paramBuffer;
9991
9992 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
9993 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
9994 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
9995 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
9996 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
9997
9998 return CallCapture(angle::EntryPoint::GLColorMaskiOES, std::move(paramBuffer));
9999 }
10000
CaptureDisableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)10001 CallCapture CaptureDisableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
10002 {
10003 ParamBuffer paramBuffer;
10004
10005 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10006 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10007
10008 return CallCapture(angle::EntryPoint::GLDisableiOES, std::move(paramBuffer));
10009 }
10010
CaptureEnableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)10011 CallCapture CaptureEnableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
10012 {
10013 ParamBuffer paramBuffer;
10014
10015 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10016 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10017
10018 return CallCapture(angle::EntryPoint::GLEnableiOES, std::move(paramBuffer));
10019 }
10020
CaptureIsEnablediOES(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)10021 CallCapture CaptureIsEnablediOES(const State &glState,
10022 bool isCallValid,
10023 GLenum target,
10024 GLuint index,
10025 GLboolean returnValue)
10026 {
10027 ParamBuffer paramBuffer;
10028
10029 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10030 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10031
10032 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10033 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10034 paramBuffer.addReturnValue(std::move(returnValueCapture));
10035
10036 return CallCapture(angle::EntryPoint::GLIsEnablediOES, std::move(paramBuffer));
10037 }
10038
CaptureDrawElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)10039 CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
10040 bool isCallValid,
10041 PrimitiveMode modePacked,
10042 GLsizei count,
10043 DrawElementsType typePacked,
10044 const void *indices,
10045 GLint basevertex)
10046 {
10047 ParamBuffer paramBuffer;
10048
10049 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10050 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10051 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10052
10053 if (isCallValid)
10054 {
10055 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10056 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10057 CaptureDrawElementsBaseVertexOES_indices(glState, isCallValid, modePacked, count,
10058 typePacked, indices, basevertex, &indicesParam);
10059 paramBuffer.addParam(std::move(indicesParam));
10060 }
10061 else
10062 {
10063 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10064 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10065 &indicesParam.value);
10066 paramBuffer.addParam(std::move(indicesParam));
10067 }
10068
10069 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10070
10071 return CallCapture(angle::EntryPoint::GLDrawElementsBaseVertexOES, std::move(paramBuffer));
10072 }
10073
CaptureDrawElementsInstancedBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)10074 CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
10075 bool isCallValid,
10076 PrimitiveMode modePacked,
10077 GLsizei count,
10078 DrawElementsType typePacked,
10079 const void *indices,
10080 GLsizei instancecount,
10081 GLint basevertex)
10082 {
10083 ParamBuffer paramBuffer;
10084
10085 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10086 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10087 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10088
10089 if (isCallValid)
10090 {
10091 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10092 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10093 CaptureDrawElementsInstancedBaseVertexOES_indices(glState, isCallValid, modePacked, count,
10094 typePacked, indices, instancecount,
10095 basevertex, &indicesParam);
10096 paramBuffer.addParam(std::move(indicesParam));
10097 }
10098 else
10099 {
10100 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10101 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10102 &indicesParam.value);
10103 paramBuffer.addParam(std::move(indicesParam));
10104 }
10105
10106 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
10107 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10108
10109 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexOES,
10110 std::move(paramBuffer));
10111 }
10112
CaptureDrawRangeElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)10113 CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
10114 bool isCallValid,
10115 PrimitiveMode modePacked,
10116 GLuint start,
10117 GLuint end,
10118 GLsizei count,
10119 DrawElementsType typePacked,
10120 const void *indices,
10121 GLint basevertex)
10122 {
10123 ParamBuffer paramBuffer;
10124
10125 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10126 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
10127 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
10128 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10129 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10130
10131 if (isCallValid)
10132 {
10133 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10134 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10135 CaptureDrawRangeElementsBaseVertexOES_indices(glState, isCallValid, modePacked, start, end,
10136 count, typePacked, indices, basevertex,
10137 &indicesParam);
10138 paramBuffer.addParam(std::move(indicesParam));
10139 }
10140 else
10141 {
10142 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10143 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10144 &indicesParam.value);
10145 paramBuffer.addParam(std::move(indicesParam));
10146 }
10147
10148 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10149
10150 return CallCapture(angle::EntryPoint::GLDrawRangeElementsBaseVertexOES, std::move(paramBuffer));
10151 }
10152
CaptureDrawTexfOES(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)10153 CallCapture CaptureDrawTexfOES(const State &glState,
10154 bool isCallValid,
10155 GLfloat x,
10156 GLfloat y,
10157 GLfloat z,
10158 GLfloat width,
10159 GLfloat height)
10160 {
10161 ParamBuffer paramBuffer;
10162
10163 paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
10164 paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
10165 paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
10166 paramBuffer.addValueParam("width", ParamType::TGLfloat, width);
10167 paramBuffer.addValueParam("height", ParamType::TGLfloat, height);
10168
10169 return CallCapture(angle::EntryPoint::GLDrawTexfOES, std::move(paramBuffer));
10170 }
10171
CaptureDrawTexfvOES(const State & glState,bool isCallValid,const GLfloat * coords)10172 CallCapture CaptureDrawTexfvOES(const State &glState, bool isCallValid, const GLfloat *coords)
10173 {
10174 ParamBuffer paramBuffer;
10175
10176 if (isCallValid)
10177 {
10178 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
10179 InitParamValue(ParamType::TGLfloatConstPointer, coords, &coordsParam.value);
10180 CaptureDrawTexfvOES_coords(glState, isCallValid, coords, &coordsParam);
10181 paramBuffer.addParam(std::move(coordsParam));
10182 }
10183 else
10184 {
10185 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
10186 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
10187 &coordsParam.value);
10188 paramBuffer.addParam(std::move(coordsParam));
10189 }
10190
10191 return CallCapture(angle::EntryPoint::GLDrawTexfvOES, std::move(paramBuffer));
10192 }
10193
CaptureDrawTexiOES(const State & glState,bool isCallValid,GLint x,GLint y,GLint z,GLint width,GLint height)10194 CallCapture CaptureDrawTexiOES(const State &glState,
10195 bool isCallValid,
10196 GLint x,
10197 GLint y,
10198 GLint z,
10199 GLint width,
10200 GLint height)
10201 {
10202 ParamBuffer paramBuffer;
10203
10204 paramBuffer.addValueParam("x", ParamType::TGLint, x);
10205 paramBuffer.addValueParam("y", ParamType::TGLint, y);
10206 paramBuffer.addValueParam("z", ParamType::TGLint, z);
10207 paramBuffer.addValueParam("width", ParamType::TGLint, width);
10208 paramBuffer.addValueParam("height", ParamType::TGLint, height);
10209
10210 return CallCapture(angle::EntryPoint::GLDrawTexiOES, std::move(paramBuffer));
10211 }
10212
CaptureDrawTexivOES(const State & glState,bool isCallValid,const GLint * coords)10213 CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords)
10214 {
10215 ParamBuffer paramBuffer;
10216
10217 if (isCallValid)
10218 {
10219 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
10220 InitParamValue(ParamType::TGLintConstPointer, coords, &coordsParam.value);
10221 CaptureDrawTexivOES_coords(glState, isCallValid, coords, &coordsParam);
10222 paramBuffer.addParam(std::move(coordsParam));
10223 }
10224 else
10225 {
10226 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
10227 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
10228 &coordsParam.value);
10229 paramBuffer.addParam(std::move(coordsParam));
10230 }
10231
10232 return CallCapture(angle::EntryPoint::GLDrawTexivOES, std::move(paramBuffer));
10233 }
10234
CaptureDrawTexsOES(const State & glState,bool isCallValid,GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)10235 CallCapture CaptureDrawTexsOES(const State &glState,
10236 bool isCallValid,
10237 GLshort x,
10238 GLshort y,
10239 GLshort z,
10240 GLshort width,
10241 GLshort height)
10242 {
10243 ParamBuffer paramBuffer;
10244
10245 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
10246 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
10247 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
10248 paramBuffer.addValueParam("width", ParamType::TGLshort, width);
10249 paramBuffer.addValueParam("height", ParamType::TGLshort, height);
10250
10251 return CallCapture(angle::EntryPoint::GLDrawTexsOES, std::move(paramBuffer));
10252 }
10253
CaptureDrawTexsvOES(const State & glState,bool isCallValid,const GLshort * coords)10254 CallCapture CaptureDrawTexsvOES(const State &glState, bool isCallValid, const GLshort *coords)
10255 {
10256 ParamBuffer paramBuffer;
10257
10258 if (isCallValid)
10259 {
10260 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
10261 InitParamValue(ParamType::TGLshortConstPointer, coords, &coordsParam.value);
10262 CaptureDrawTexsvOES_coords(glState, isCallValid, coords, &coordsParam);
10263 paramBuffer.addParam(std::move(coordsParam));
10264 }
10265 else
10266 {
10267 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
10268 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
10269 &coordsParam.value);
10270 paramBuffer.addParam(std::move(coordsParam));
10271 }
10272
10273 return CallCapture(angle::EntryPoint::GLDrawTexsvOES, std::move(paramBuffer));
10274 }
10275
CaptureDrawTexxOES(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)10276 CallCapture CaptureDrawTexxOES(const State &glState,
10277 bool isCallValid,
10278 GLfixed x,
10279 GLfixed y,
10280 GLfixed z,
10281 GLfixed width,
10282 GLfixed height)
10283 {
10284 ParamBuffer paramBuffer;
10285
10286 paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
10287 paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
10288 paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
10289 paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
10290 paramBuffer.addValueParam("height", ParamType::TGLfixed, height);
10291
10292 return CallCapture(angle::EntryPoint::GLDrawTexxOES, std::move(paramBuffer));
10293 }
10294
CaptureDrawTexxvOES(const State & glState,bool isCallValid,const GLfixed * coords)10295 CallCapture CaptureDrawTexxvOES(const State &glState, bool isCallValid, const GLfixed *coords)
10296 {
10297 ParamBuffer paramBuffer;
10298
10299 if (isCallValid)
10300 {
10301 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
10302 InitParamValue(ParamType::TGLfixedConstPointer, coords, &coordsParam.value);
10303 CaptureDrawTexxvOES_coords(glState, isCallValid, coords, &coordsParam);
10304 paramBuffer.addParam(std::move(coordsParam));
10305 }
10306 else
10307 {
10308 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
10309 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
10310 &coordsParam.value);
10311 paramBuffer.addParam(std::move(coordsParam));
10312 }
10313
10314 return CallCapture(angle::EntryPoint::GLDrawTexxvOES, std::move(paramBuffer));
10315 }
10316
CaptureBindFramebufferOES(const State & glState,bool isCallValid,GLenum target,FramebufferID framebufferPacked)10317 CallCapture CaptureBindFramebufferOES(const State &glState,
10318 bool isCallValid,
10319 GLenum target,
10320 FramebufferID framebufferPacked)
10321 {
10322 ParamBuffer paramBuffer;
10323
10324 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10325 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
10326
10327 return CallCapture(angle::EntryPoint::GLBindFramebufferOES, std::move(paramBuffer));
10328 }
10329
CaptureBindRenderbufferOES(const State & glState,bool isCallValid,GLenum target,RenderbufferID renderbufferPacked)10330 CallCapture CaptureBindRenderbufferOES(const State &glState,
10331 bool isCallValid,
10332 GLenum target,
10333 RenderbufferID renderbufferPacked)
10334 {
10335 ParamBuffer paramBuffer;
10336
10337 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10338 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10339
10340 return CallCapture(angle::EntryPoint::GLBindRenderbufferOES, std::move(paramBuffer));
10341 }
10342
CaptureCheckFramebufferStatusOES(const State & glState,bool isCallValid,GLenum target,GLenum returnValue)10343 CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
10344 bool isCallValid,
10345 GLenum target,
10346 GLenum returnValue)
10347 {
10348 ParamBuffer paramBuffer;
10349
10350 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10351
10352 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
10353 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
10354 paramBuffer.addReturnValue(std::move(returnValueCapture));
10355
10356 return CallCapture(angle::EntryPoint::GLCheckFramebufferStatusOES, std::move(paramBuffer));
10357 }
10358
CaptureDeleteFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,const FramebufferID * framebuffersPacked)10359 CallCapture CaptureDeleteFramebuffersOES(const State &glState,
10360 bool isCallValid,
10361 GLsizei n,
10362 const FramebufferID *framebuffersPacked)
10363 {
10364 ParamBuffer paramBuffer;
10365
10366 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10367
10368 if (isCallValid)
10369 {
10370 ParamCapture framebuffersPackedParam("framebuffersPacked",
10371 ParamType::TFramebufferIDConstPointer);
10372 InitParamValue(ParamType::TFramebufferIDConstPointer, framebuffersPacked,
10373 &framebuffersPackedParam.value);
10374 CaptureDeleteFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
10375 &framebuffersPackedParam);
10376 paramBuffer.addParam(std::move(framebuffersPackedParam));
10377 }
10378 else
10379 {
10380 ParamCapture framebuffersPackedParam("framebuffersPacked",
10381 ParamType::TFramebufferIDConstPointer);
10382 InitParamValue(ParamType::TFramebufferIDConstPointer,
10383 static_cast<const FramebufferID *>(nullptr), &framebuffersPackedParam.value);
10384 paramBuffer.addParam(std::move(framebuffersPackedParam));
10385 }
10386
10387 return CallCapture(angle::EntryPoint::GLDeleteFramebuffersOES, std::move(paramBuffer));
10388 }
10389
CaptureDeleteRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,const RenderbufferID * renderbuffersPacked)10390 CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
10391 bool isCallValid,
10392 GLsizei n,
10393 const RenderbufferID *renderbuffersPacked)
10394 {
10395 ParamBuffer paramBuffer;
10396
10397 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10398
10399 if (isCallValid)
10400 {
10401 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10402 ParamType::TRenderbufferIDConstPointer);
10403 InitParamValue(ParamType::TRenderbufferIDConstPointer, renderbuffersPacked,
10404 &renderbuffersPackedParam.value);
10405 CaptureDeleteRenderbuffersOES_renderbuffersPacked(
10406 glState, isCallValid, n, renderbuffersPacked, &renderbuffersPackedParam);
10407 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10408 }
10409 else
10410 {
10411 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10412 ParamType::TRenderbufferIDConstPointer);
10413 InitParamValue(ParamType::TRenderbufferIDConstPointer,
10414 static_cast<const RenderbufferID *>(nullptr),
10415 &renderbuffersPackedParam.value);
10416 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10417 }
10418
10419 return CallCapture(angle::EntryPoint::GLDeleteRenderbuffersOES, std::move(paramBuffer));
10420 }
10421
CaptureFramebufferRenderbufferOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum renderbuffertarget,RenderbufferID renderbufferPacked)10422 CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
10423 bool isCallValid,
10424 GLenum target,
10425 GLenum attachment,
10426 GLenum renderbuffertarget,
10427 RenderbufferID renderbufferPacked)
10428 {
10429 ParamBuffer paramBuffer;
10430
10431 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10432 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10433 attachment);
10434 paramBuffer.addEnumParam("renderbuffertarget", GLESEnum::RenderbufferTarget, ParamType::TGLenum,
10435 renderbuffertarget);
10436 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10437
10438 return CallCapture(angle::EntryPoint::GLFramebufferRenderbufferOES, std::move(paramBuffer));
10439 }
10440
CaptureFramebufferTexture2DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level)10441 CallCapture CaptureFramebufferTexture2DOES(const State &glState,
10442 bool isCallValid,
10443 GLenum target,
10444 GLenum attachment,
10445 TextureTarget textargetPacked,
10446 TextureID texturePacked,
10447 GLint level)
10448 {
10449 ParamBuffer paramBuffer;
10450
10451 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10452 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10453 attachment);
10454 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
10455 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
10456 paramBuffer.addValueParam("level", ParamType::TGLint, level);
10457
10458 return CallCapture(angle::EntryPoint::GLFramebufferTexture2DOES, std::move(paramBuffer));
10459 }
10460
CaptureGenFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,FramebufferID * framebuffersPacked)10461 CallCapture CaptureGenFramebuffersOES(const State &glState,
10462 bool isCallValid,
10463 GLsizei n,
10464 FramebufferID *framebuffersPacked)
10465 {
10466 ParamBuffer paramBuffer;
10467
10468 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10469
10470 if (isCallValid)
10471 {
10472 ParamCapture framebuffersPackedParam("framebuffersPacked",
10473 ParamType::TFramebufferIDPointer);
10474 InitParamValue(ParamType::TFramebufferIDPointer, framebuffersPacked,
10475 &framebuffersPackedParam.value);
10476 CaptureGenFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
10477 &framebuffersPackedParam);
10478 paramBuffer.addParam(std::move(framebuffersPackedParam));
10479 }
10480 else
10481 {
10482 ParamCapture framebuffersPackedParam("framebuffersPacked",
10483 ParamType::TFramebufferIDPointer);
10484 InitParamValue(ParamType::TFramebufferIDPointer, static_cast<FramebufferID *>(nullptr),
10485 &framebuffersPackedParam.value);
10486 paramBuffer.addParam(std::move(framebuffersPackedParam));
10487 }
10488
10489 return CallCapture(angle::EntryPoint::GLGenFramebuffersOES, std::move(paramBuffer));
10490 }
10491
CaptureGenRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,RenderbufferID * renderbuffersPacked)10492 CallCapture CaptureGenRenderbuffersOES(const State &glState,
10493 bool isCallValid,
10494 GLsizei n,
10495 RenderbufferID *renderbuffersPacked)
10496 {
10497 ParamBuffer paramBuffer;
10498
10499 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10500
10501 if (isCallValid)
10502 {
10503 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10504 ParamType::TRenderbufferIDPointer);
10505 InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
10506 &renderbuffersPackedParam.value);
10507 CaptureGenRenderbuffersOES_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
10508 &renderbuffersPackedParam);
10509 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10510 }
10511 else
10512 {
10513 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10514 ParamType::TRenderbufferIDPointer);
10515 InitParamValue(ParamType::TRenderbufferIDPointer, static_cast<RenderbufferID *>(nullptr),
10516 &renderbuffersPackedParam.value);
10517 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10518 }
10519
10520 return CallCapture(angle::EntryPoint::GLGenRenderbuffersOES, std::move(paramBuffer));
10521 }
10522
CaptureGenerateMipmapOES(const State & glState,bool isCallValid,TextureType targetPacked)10523 CallCapture CaptureGenerateMipmapOES(const State &glState,
10524 bool isCallValid,
10525 TextureType targetPacked)
10526 {
10527 ParamBuffer paramBuffer;
10528
10529 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
10530
10531 return CallCapture(angle::EntryPoint::GLGenerateMipmapOES, std::move(paramBuffer));
10532 }
10533
CaptureGetFramebufferAttachmentParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLint * params)10534 CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
10535 bool isCallValid,
10536 GLenum target,
10537 GLenum attachment,
10538 GLenum pname,
10539 GLint *params)
10540 {
10541 ParamBuffer paramBuffer;
10542
10543 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10544 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10545 attachment);
10546 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName,
10547 ParamType::TGLenum, pname);
10548
10549 if (isCallValid)
10550 {
10551 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10552 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10553 CaptureGetFramebufferAttachmentParameterivOES_params(
10554 glState, isCallValid, target, attachment, pname, params, ¶msParam);
10555 paramBuffer.addParam(std::move(paramsParam));
10556 }
10557 else
10558 {
10559 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10560 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10561 paramBuffer.addParam(std::move(paramsParam));
10562 }
10563
10564 return CallCapture(angle::EntryPoint::GLGetFramebufferAttachmentParameterivOES,
10565 std::move(paramBuffer));
10566 }
10567
CaptureGetRenderbufferParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)10568 CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
10569 bool isCallValid,
10570 GLenum target,
10571 GLenum pname,
10572 GLint *params)
10573 {
10574 ParamBuffer paramBuffer;
10575
10576 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10577 paramBuffer.addEnumParam("pname", GLESEnum::RenderbufferParameterName, ParamType::TGLenum,
10578 pname);
10579
10580 if (isCallValid)
10581 {
10582 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10583 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10584 CaptureGetRenderbufferParameterivOES_params(glState, isCallValid, target, pname, params,
10585 ¶msParam);
10586 paramBuffer.addParam(std::move(paramsParam));
10587 }
10588 else
10589 {
10590 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10591 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10592 paramBuffer.addParam(std::move(paramsParam));
10593 }
10594
10595 return CallCapture(angle::EntryPoint::GLGetRenderbufferParameterivOES, std::move(paramBuffer));
10596 }
10597
CaptureIsFramebufferOES(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLboolean returnValue)10598 CallCapture CaptureIsFramebufferOES(const State &glState,
10599 bool isCallValid,
10600 FramebufferID framebufferPacked,
10601 GLboolean returnValue)
10602 {
10603 ParamBuffer paramBuffer;
10604
10605 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
10606
10607 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10608 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10609 paramBuffer.addReturnValue(std::move(returnValueCapture));
10610
10611 return CallCapture(angle::EntryPoint::GLIsFramebufferOES, std::move(paramBuffer));
10612 }
10613
CaptureIsRenderbufferOES(const State & glState,bool isCallValid,RenderbufferID renderbufferPacked,GLboolean returnValue)10614 CallCapture CaptureIsRenderbufferOES(const State &glState,
10615 bool isCallValid,
10616 RenderbufferID renderbufferPacked,
10617 GLboolean returnValue)
10618 {
10619 ParamBuffer paramBuffer;
10620
10621 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10622
10623 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10624 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10625 paramBuffer.addReturnValue(std::move(returnValueCapture));
10626
10627 return CallCapture(angle::EntryPoint::GLIsRenderbufferOES, std::move(paramBuffer));
10628 }
10629
CaptureRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)10630 CallCapture CaptureRenderbufferStorageOES(const State &glState,
10631 bool isCallValid,
10632 GLenum target,
10633 GLenum internalformat,
10634 GLsizei width,
10635 GLsizei height)
10636 {
10637 ParamBuffer paramBuffer;
10638
10639 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10640 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
10641 internalformat);
10642 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
10643 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
10644
10645 return CallCapture(angle::EntryPoint::GLRenderbufferStorageOES, std::move(paramBuffer));
10646 }
10647
CaptureFramebufferTextureOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)10648 CallCapture CaptureFramebufferTextureOES(const State &glState,
10649 bool isCallValid,
10650 GLenum target,
10651 GLenum attachment,
10652 TextureID texturePacked,
10653 GLint level)
10654 {
10655 ParamBuffer paramBuffer;
10656
10657 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10658 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10659 attachment);
10660 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
10661 paramBuffer.addValueParam("level", ParamType::TGLint, level);
10662
10663 return CallCapture(angle::EntryPoint::GLFramebufferTextureOES, std::move(paramBuffer));
10664 }
10665
CaptureGetProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)10666 CallCapture CaptureGetProgramBinaryOES(const State &glState,
10667 bool isCallValid,
10668 ShaderProgramID programPacked,
10669 GLsizei bufSize,
10670 GLsizei *length,
10671 GLenum *binaryFormat,
10672 void *binary)
10673 {
10674 ParamBuffer paramBuffer;
10675
10676 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
10677 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
10678
10679 if (isCallValid)
10680 {
10681 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
10682 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
10683 CaptureGetProgramBinaryOES_length(glState, isCallValid, programPacked, bufSize, length,
10684 binaryFormat, binary, &lengthParam);
10685 paramBuffer.addParam(std::move(lengthParam));
10686 }
10687 else
10688 {
10689 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
10690 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
10691 &lengthParam.value);
10692 paramBuffer.addParam(std::move(lengthParam));
10693 }
10694
10695 if (isCallValid)
10696 {
10697 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
10698 InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
10699 CaptureGetProgramBinaryOES_binaryFormat(glState, isCallValid, programPacked, bufSize,
10700 length, binaryFormat, binary, &binaryFormatParam);
10701 paramBuffer.addParam(std::move(binaryFormatParam));
10702 }
10703 else
10704 {
10705 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
10706 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
10707 &binaryFormatParam.value);
10708 paramBuffer.addParam(std::move(binaryFormatParam));
10709 }
10710
10711 if (isCallValid)
10712 {
10713 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
10714 InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
10715 CaptureGetProgramBinaryOES_binary(glState, isCallValid, programPacked, bufSize, length,
10716 binaryFormat, binary, &binaryParam);
10717 paramBuffer.addParam(std::move(binaryParam));
10718 }
10719 else
10720 {
10721 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
10722 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &binaryParam.value);
10723 paramBuffer.addParam(std::move(binaryParam));
10724 }
10725
10726 return CallCapture(angle::EntryPoint::GLGetProgramBinaryOES, std::move(paramBuffer));
10727 }
10728
CaptureProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum binaryFormat,const void * binary,GLint length)10729 CallCapture CaptureProgramBinaryOES(const State &glState,
10730 bool isCallValid,
10731 ShaderProgramID programPacked,
10732 GLenum binaryFormat,
10733 const void *binary,
10734 GLint length)
10735 {
10736 ParamBuffer paramBuffer;
10737
10738 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
10739 paramBuffer.addEnumParam("binaryFormat", GLESEnum::AllEnums, ParamType::TGLenum, binaryFormat);
10740
10741 if (isCallValid)
10742 {
10743 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
10744 InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
10745 CaptureProgramBinaryOES_binary(glState, isCallValid, programPacked, binaryFormat, binary,
10746 length, &binaryParam);
10747 paramBuffer.addParam(std::move(binaryParam));
10748 }
10749 else
10750 {
10751 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
10752 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10753 &binaryParam.value);
10754 paramBuffer.addParam(std::move(binaryParam));
10755 }
10756
10757 paramBuffer.addValueParam("length", ParamType::TGLint, length);
10758
10759 return CallCapture(angle::EntryPoint::GLProgramBinaryOES, std::move(paramBuffer));
10760 }
10761
CaptureGetBufferPointervOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,void ** params)10762 CallCapture CaptureGetBufferPointervOES(const State &glState,
10763 bool isCallValid,
10764 BufferBinding targetPacked,
10765 GLenum pname,
10766 void **params)
10767 {
10768 ParamBuffer paramBuffer;
10769
10770 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
10771 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
10772
10773 if (isCallValid)
10774 {
10775 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
10776 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
10777 CaptureGetBufferPointervOES_params(glState, isCallValid, targetPacked, pname, params,
10778 ¶msParam);
10779 paramBuffer.addParam(std::move(paramsParam));
10780 }
10781 else
10782 {
10783 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
10784 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
10785 ¶msParam.value);
10786 paramBuffer.addParam(std::move(paramsParam));
10787 }
10788
10789 return CallCapture(angle::EntryPoint::GLGetBufferPointervOES, std::move(paramBuffer));
10790 }
10791
CaptureMapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum access,void * returnValue)10792 CallCapture CaptureMapBufferOES(const State &glState,
10793 bool isCallValid,
10794 BufferBinding targetPacked,
10795 GLenum access,
10796 void *returnValue)
10797 {
10798 ParamBuffer paramBuffer;
10799
10800 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
10801 paramBuffer.addEnumParam("access", GLESEnum::BufferAccessARB, ParamType::TGLenum, access);
10802
10803 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
10804 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
10805 paramBuffer.addReturnValue(std::move(returnValueCapture));
10806
10807 return CallCapture(angle::EntryPoint::GLMapBufferOES, std::move(paramBuffer));
10808 }
10809
CaptureUnmapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLboolean returnValue)10810 CallCapture CaptureUnmapBufferOES(const State &glState,
10811 bool isCallValid,
10812 BufferBinding targetPacked,
10813 GLboolean returnValue)
10814 {
10815 ParamBuffer paramBuffer;
10816
10817 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
10818
10819 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10820 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10821 paramBuffer.addReturnValue(std::move(returnValueCapture));
10822
10823 return CallCapture(angle::EntryPoint::GLUnmapBufferOES, std::move(paramBuffer));
10824 }
10825
CaptureCurrentPaletteMatrixOES(const State & glState,bool isCallValid,GLuint matrixpaletteindex)10826 CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
10827 bool isCallValid,
10828 GLuint matrixpaletteindex)
10829 {
10830 ParamBuffer paramBuffer;
10831
10832 paramBuffer.addValueParam("matrixpaletteindex", ParamType::TGLuint, matrixpaletteindex);
10833
10834 return CallCapture(angle::EntryPoint::GLCurrentPaletteMatrixOES, std::move(paramBuffer));
10835 }
10836
CaptureLoadPaletteFromModelViewMatrixOES(const State & glState,bool isCallValid)10837 CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid)
10838 {
10839 ParamBuffer paramBuffer;
10840
10841 return CallCapture(angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES,
10842 std::move(paramBuffer));
10843 }
10844
CaptureMatrixIndexPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)10845 CallCapture CaptureMatrixIndexPointerOES(const State &glState,
10846 bool isCallValid,
10847 GLint size,
10848 GLenum type,
10849 GLsizei stride,
10850 const void *pointer)
10851 {
10852 ParamBuffer paramBuffer;
10853
10854 paramBuffer.addValueParam("size", ParamType::TGLint, size);
10855 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
10856 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
10857
10858 if (isCallValid)
10859 {
10860 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
10861 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
10862 CaptureMatrixIndexPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
10863 &pointerParam);
10864 paramBuffer.addParam(std::move(pointerParam));
10865 }
10866 else
10867 {
10868 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
10869 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10870 &pointerParam.value);
10871 paramBuffer.addParam(std::move(pointerParam));
10872 }
10873
10874 return CallCapture(angle::EntryPoint::GLMatrixIndexPointerOES, std::move(paramBuffer));
10875 }
10876
CaptureWeightPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)10877 CallCapture CaptureWeightPointerOES(const State &glState,
10878 bool isCallValid,
10879 GLint size,
10880 GLenum type,
10881 GLsizei stride,
10882 const void *pointer)
10883 {
10884 ParamBuffer paramBuffer;
10885
10886 paramBuffer.addValueParam("size", ParamType::TGLint, size);
10887 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
10888 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
10889
10890 if (isCallValid)
10891 {
10892 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
10893 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
10894 CaptureWeightPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
10895 &pointerParam);
10896 paramBuffer.addParam(std::move(pointerParam));
10897 }
10898 else
10899 {
10900 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
10901 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10902 &pointerParam.value);
10903 paramBuffer.addParam(std::move(pointerParam));
10904 }
10905
10906 return CallCapture(angle::EntryPoint::GLWeightPointerOES, std::move(paramBuffer));
10907 }
10908
CapturePointSizePointerOES(const State & glState,bool isCallValid,VertexAttribType typePacked,GLsizei stride,const void * pointer)10909 CallCapture CapturePointSizePointerOES(const State &glState,
10910 bool isCallValid,
10911 VertexAttribType typePacked,
10912 GLsizei stride,
10913 const void *pointer)
10914 {
10915 ParamBuffer paramBuffer;
10916
10917 paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
10918 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
10919
10920 if (isCallValid)
10921 {
10922 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
10923 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
10924 CapturePointSizePointerOES_pointer(glState, isCallValid, typePacked, stride, pointer,
10925 &pointerParam);
10926 paramBuffer.addParam(std::move(pointerParam));
10927 }
10928 else
10929 {
10930 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
10931 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10932 &pointerParam.value);
10933 paramBuffer.addParam(std::move(pointerParam));
10934 }
10935
10936 return CallCapture(angle::EntryPoint::GLPointSizePointerOES, std::move(paramBuffer));
10937 }
10938
CapturePrimitiveBoundingBoxOES(const State & glState,bool isCallValid,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)10939 CallCapture CapturePrimitiveBoundingBoxOES(const State &glState,
10940 bool isCallValid,
10941 GLfloat minX,
10942 GLfloat minY,
10943 GLfloat minZ,
10944 GLfloat minW,
10945 GLfloat maxX,
10946 GLfloat maxY,
10947 GLfloat maxZ,
10948 GLfloat maxW)
10949 {
10950 ParamBuffer paramBuffer;
10951
10952 paramBuffer.addValueParam("minX", ParamType::TGLfloat, minX);
10953 paramBuffer.addValueParam("minY", ParamType::TGLfloat, minY);
10954 paramBuffer.addValueParam("minZ", ParamType::TGLfloat, minZ);
10955 paramBuffer.addValueParam("minW", ParamType::TGLfloat, minW);
10956 paramBuffer.addValueParam("maxX", ParamType::TGLfloat, maxX);
10957 paramBuffer.addValueParam("maxY", ParamType::TGLfloat, maxY);
10958 paramBuffer.addValueParam("maxZ", ParamType::TGLfloat, maxZ);
10959 paramBuffer.addValueParam("maxW", ParamType::TGLfloat, maxW);
10960
10961 return CallCapture(angle::EntryPoint::GLPrimitiveBoundingBoxOES, std::move(paramBuffer));
10962 }
10963
CaptureQueryMatrixxOES(const State & glState,bool isCallValid,GLfixed * mantissa,GLint * exponent,GLbitfield returnValue)10964 CallCapture CaptureQueryMatrixxOES(const State &glState,
10965 bool isCallValid,
10966 GLfixed *mantissa,
10967 GLint *exponent,
10968 GLbitfield returnValue)
10969 {
10970 ParamBuffer paramBuffer;
10971
10972 if (isCallValid)
10973 {
10974 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
10975 InitParamValue(ParamType::TGLfixedPointer, mantissa, &mantissaParam.value);
10976 CaptureQueryMatrixxOES_mantissa(glState, isCallValid, mantissa, exponent, &mantissaParam);
10977 paramBuffer.addParam(std::move(mantissaParam));
10978 }
10979 else
10980 {
10981 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
10982 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
10983 &mantissaParam.value);
10984 paramBuffer.addParam(std::move(mantissaParam));
10985 }
10986
10987 if (isCallValid)
10988 {
10989 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
10990 InitParamValue(ParamType::TGLintPointer, exponent, &exponentParam.value);
10991 CaptureQueryMatrixxOES_exponent(glState, isCallValid, mantissa, exponent, &exponentParam);
10992 paramBuffer.addParam(std::move(exponentParam));
10993 }
10994 else
10995 {
10996 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
10997 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
10998 &exponentParam.value);
10999 paramBuffer.addParam(std::move(exponentParam));
11000 }
11001
11002 ParamCapture returnValueCapture("returnValue", ParamType::TGLbitfield);
11003 InitParamValue(ParamType::TGLbitfield, returnValue, &returnValueCapture.value);
11004 paramBuffer.addReturnValue(std::move(returnValueCapture));
11005
11006 return CallCapture(angle::EntryPoint::GLQueryMatrixxOES, std::move(paramBuffer));
11007 }
11008
CaptureMinSampleShadingOES(const State & glState,bool isCallValid,GLfloat value)11009 CallCapture CaptureMinSampleShadingOES(const State &glState, bool isCallValid, GLfloat value)
11010 {
11011 ParamBuffer paramBuffer;
11012
11013 paramBuffer.addValueParam("value", ParamType::TGLfloat, value);
11014
11015 return CallCapture(angle::EntryPoint::GLMinSampleShadingOES, std::move(paramBuffer));
11016 }
11017
CaptureCompressedTexImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)11018 CallCapture CaptureCompressedTexImage3DOES(const State &glState,
11019 bool isCallValid,
11020 TextureTarget targetPacked,
11021 GLint level,
11022 GLenum internalformat,
11023 GLsizei width,
11024 GLsizei height,
11025 GLsizei depth,
11026 GLint border,
11027 GLsizei imageSize,
11028 const void *data)
11029 {
11030 ParamBuffer paramBuffer;
11031
11032 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11033 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11034 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11035 internalformat);
11036 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11037 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11038 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11039 paramBuffer.addValueParam("border", ParamType::TGLint, border);
11040 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
11041
11042 if (isCallValid)
11043 {
11044 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11045 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
11046 CaptureCompressedTexImage3DOES_data(glState, isCallValid, targetPacked, level,
11047 internalformat, width, height, depth, border, imageSize,
11048 data, &dataParam);
11049 paramBuffer.addParam(std::move(dataParam));
11050 }
11051 else
11052 {
11053 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11054 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11055 &dataParam.value);
11056 paramBuffer.addParam(std::move(dataParam));
11057 }
11058
11059 return CallCapture(angle::EntryPoint::GLCompressedTexImage3DOES, std::move(paramBuffer));
11060 }
11061
CaptureCompressedTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)11062 CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
11063 bool isCallValid,
11064 TextureTarget targetPacked,
11065 GLint level,
11066 GLint xoffset,
11067 GLint yoffset,
11068 GLint zoffset,
11069 GLsizei width,
11070 GLsizei height,
11071 GLsizei depth,
11072 GLenum format,
11073 GLsizei imageSize,
11074 const void *data)
11075 {
11076 ParamBuffer paramBuffer;
11077
11078 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11079 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11080 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11081 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11082 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11083 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11084 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11085 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11086 paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format);
11087 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
11088
11089 if (isCallValid)
11090 {
11091 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11092 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
11093 CaptureCompressedTexSubImage3DOES_data(glState, isCallValid, targetPacked, level, xoffset,
11094 yoffset, zoffset, width, height, depth, format,
11095 imageSize, data, &dataParam);
11096 paramBuffer.addParam(std::move(dataParam));
11097 }
11098 else
11099 {
11100 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11101 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11102 &dataParam.value);
11103 paramBuffer.addParam(std::move(dataParam));
11104 }
11105
11106 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage3DOES, std::move(paramBuffer));
11107 }
11108
CaptureCopyTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)11109 CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
11110 bool isCallValid,
11111 TextureTarget targetPacked,
11112 GLint level,
11113 GLint xoffset,
11114 GLint yoffset,
11115 GLint zoffset,
11116 GLint x,
11117 GLint y,
11118 GLsizei width,
11119 GLsizei height)
11120 {
11121 ParamBuffer paramBuffer;
11122
11123 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11124 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11125 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11126 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11127 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11128 paramBuffer.addValueParam("x", ParamType::TGLint, x);
11129 paramBuffer.addValueParam("y", ParamType::TGLint, y);
11130 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11131 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11132
11133 return CallCapture(angle::EntryPoint::GLCopyTexSubImage3DOES, std::move(paramBuffer));
11134 }
11135
CaptureFramebufferTexture3DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLint zoffset)11136 CallCapture CaptureFramebufferTexture3DOES(const State &glState,
11137 bool isCallValid,
11138 GLenum target,
11139 GLenum attachment,
11140 TextureTarget textargetPacked,
11141 TextureID texturePacked,
11142 GLint level,
11143 GLint zoffset)
11144 {
11145 ParamBuffer paramBuffer;
11146
11147 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
11148 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
11149 attachment);
11150 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
11151 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
11152 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11153 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11154
11155 return CallCapture(angle::EntryPoint::GLFramebufferTexture3DOES, std::move(paramBuffer));
11156 }
11157
CaptureTexImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)11158 CallCapture CaptureTexImage3DOES(const State &glState,
11159 bool isCallValid,
11160 TextureTarget targetPacked,
11161 GLint level,
11162 GLenum internalformat,
11163 GLsizei width,
11164 GLsizei height,
11165 GLsizei depth,
11166 GLint border,
11167 GLenum format,
11168 GLenum type,
11169 const void *pixels)
11170 {
11171 ParamBuffer paramBuffer;
11172
11173 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11174 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11175 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11176 internalformat);
11177 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11178 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11179 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11180 paramBuffer.addValueParam("border", ParamType::TGLint, border);
11181 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
11182 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
11183
11184 if (isCallValid)
11185 {
11186 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11187 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
11188 CaptureTexImage3DOES_pixels(glState, isCallValid, targetPacked, level, internalformat,
11189 width, height, depth, border, format, type, pixels,
11190 &pixelsParam);
11191 paramBuffer.addParam(std::move(pixelsParam));
11192 }
11193 else
11194 {
11195 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11196 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11197 &pixelsParam.value);
11198 paramBuffer.addParam(std::move(pixelsParam));
11199 }
11200
11201 return CallCapture(angle::EntryPoint::GLTexImage3DOES, std::move(paramBuffer));
11202 }
11203
CaptureTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)11204 CallCapture CaptureTexSubImage3DOES(const State &glState,
11205 bool isCallValid,
11206 TextureTarget targetPacked,
11207 GLint level,
11208 GLint xoffset,
11209 GLint yoffset,
11210 GLint zoffset,
11211 GLsizei width,
11212 GLsizei height,
11213 GLsizei depth,
11214 GLenum format,
11215 GLenum type,
11216 const void *pixels)
11217 {
11218 ParamBuffer paramBuffer;
11219
11220 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11221 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11222 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11223 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11224 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11225 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11226 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11227 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11228 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
11229 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
11230
11231 if (isCallValid)
11232 {
11233 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11234 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
11235 CaptureTexSubImage3DOES_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
11236 zoffset, width, height, depth, format, type, pixels,
11237 &pixelsParam);
11238 paramBuffer.addParam(std::move(pixelsParam));
11239 }
11240 else
11241 {
11242 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11243 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11244 &pixelsParam.value);
11245 paramBuffer.addParam(std::move(pixelsParam));
11246 }
11247
11248 return CallCapture(angle::EntryPoint::GLTexSubImage3DOES, std::move(paramBuffer));
11249 }
11250
CaptureGetSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)11251 CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
11252 bool isCallValid,
11253 SamplerID samplerPacked,
11254 GLenum pname,
11255 GLint *params)
11256 {
11257 ParamBuffer paramBuffer;
11258
11259 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11260 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11261
11262 if (isCallValid)
11263 {
11264 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11265 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11266 CaptureGetSamplerParameterIivOES_params(glState, isCallValid, samplerPacked, pname, params,
11267 ¶msParam);
11268 paramBuffer.addParam(std::move(paramsParam));
11269 }
11270 else
11271 {
11272 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11273 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11274 paramBuffer.addParam(std::move(paramsParam));
11275 }
11276
11277 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivOES, std::move(paramBuffer));
11278 }
11279
CaptureGetSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)11280 CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
11281 bool isCallValid,
11282 SamplerID samplerPacked,
11283 GLenum pname,
11284 GLuint *params)
11285 {
11286 ParamBuffer paramBuffer;
11287
11288 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11289 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11290
11291 if (isCallValid)
11292 {
11293 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11294 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
11295 CaptureGetSamplerParameterIuivOES_params(glState, isCallValid, samplerPacked, pname, params,
11296 ¶msParam);
11297 paramBuffer.addParam(std::move(paramsParam));
11298 }
11299 else
11300 {
11301 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11302 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
11303 ¶msParam.value);
11304 paramBuffer.addParam(std::move(paramsParam));
11305 }
11306
11307 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivOES, std::move(paramBuffer));
11308 }
11309
CaptureGetTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)11310 CallCapture CaptureGetTexParameterIivOES(const State &glState,
11311 bool isCallValid,
11312 TextureType targetPacked,
11313 GLenum pname,
11314 GLint *params)
11315 {
11316 ParamBuffer paramBuffer;
11317
11318 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11319 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
11320
11321 if (isCallValid)
11322 {
11323 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11324 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11325 CaptureGetTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
11326 ¶msParam);
11327 paramBuffer.addParam(std::move(paramsParam));
11328 }
11329 else
11330 {
11331 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11332 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11333 paramBuffer.addParam(std::move(paramsParam));
11334 }
11335
11336 return CallCapture(angle::EntryPoint::GLGetTexParameterIivOES, std::move(paramBuffer));
11337 }
11338
CaptureGetTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)11339 CallCapture CaptureGetTexParameterIuivOES(const State &glState,
11340 bool isCallValid,
11341 TextureType targetPacked,
11342 GLenum pname,
11343 GLuint *params)
11344 {
11345 ParamBuffer paramBuffer;
11346
11347 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11348 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
11349
11350 if (isCallValid)
11351 {
11352 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11353 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
11354 CaptureGetTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
11355 ¶msParam);
11356 paramBuffer.addParam(std::move(paramsParam));
11357 }
11358 else
11359 {
11360 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11361 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
11362 ¶msParam.value);
11363 paramBuffer.addParam(std::move(paramsParam));
11364 }
11365
11366 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivOES, std::move(paramBuffer));
11367 }
11368
CaptureSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)11369 CallCapture CaptureSamplerParameterIivOES(const State &glState,
11370 bool isCallValid,
11371 SamplerID samplerPacked,
11372 GLenum pname,
11373 const GLint *param)
11374 {
11375 ParamBuffer paramBuffer;
11376
11377 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11378 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11379
11380 if (isCallValid)
11381 {
11382 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
11383 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
11384 CaptureSamplerParameterIivOES_param(glState, isCallValid, samplerPacked, pname, param,
11385 ¶mParam);
11386 paramBuffer.addParam(std::move(paramParam));
11387 }
11388 else
11389 {
11390 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
11391 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11392 ¶mParam.value);
11393 paramBuffer.addParam(std::move(paramParam));
11394 }
11395
11396 return CallCapture(angle::EntryPoint::GLSamplerParameterIivOES, std::move(paramBuffer));
11397 }
11398
CaptureSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)11399 CallCapture CaptureSamplerParameterIuivOES(const State &glState,
11400 bool isCallValid,
11401 SamplerID samplerPacked,
11402 GLenum pname,
11403 const GLuint *param)
11404 {
11405 ParamBuffer paramBuffer;
11406
11407 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11408 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11409
11410 if (isCallValid)
11411 {
11412 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
11413 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
11414 CaptureSamplerParameterIuivOES_param(glState, isCallValid, samplerPacked, pname, param,
11415 ¶mParam);
11416 paramBuffer.addParam(std::move(paramParam));
11417 }
11418 else
11419 {
11420 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
11421 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
11422 ¶mParam.value);
11423 paramBuffer.addParam(std::move(paramParam));
11424 }
11425
11426 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivOES, std::move(paramBuffer));
11427 }
11428
CaptureTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)11429 CallCapture CaptureTexParameterIivOES(const State &glState,
11430 bool isCallValid,
11431 TextureType targetPacked,
11432 GLenum pname,
11433 const GLint *params)
11434 {
11435 ParamBuffer paramBuffer;
11436
11437 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11438 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
11439
11440 if (isCallValid)
11441 {
11442 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11443 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
11444 CaptureTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
11445 ¶msParam);
11446 paramBuffer.addParam(std::move(paramsParam));
11447 }
11448 else
11449 {
11450 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11451 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11452 ¶msParam.value);
11453 paramBuffer.addParam(std::move(paramsParam));
11454 }
11455
11456 return CallCapture(angle::EntryPoint::GLTexParameterIivOES, std::move(paramBuffer));
11457 }
11458
CaptureTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)11459 CallCapture CaptureTexParameterIuivOES(const State &glState,
11460 bool isCallValid,
11461 TextureType targetPacked,
11462 GLenum pname,
11463 const GLuint *params)
11464 {
11465 ParamBuffer paramBuffer;
11466
11467 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11468 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
11469
11470 if (isCallValid)
11471 {
11472 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
11473 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
11474 CaptureTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
11475 ¶msParam);
11476 paramBuffer.addParam(std::move(paramsParam));
11477 }
11478 else
11479 {
11480 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
11481 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
11482 ¶msParam.value);
11483 paramBuffer.addParam(std::move(paramsParam));
11484 }
11485
11486 return CallCapture(angle::EntryPoint::GLTexParameterIuivOES, std::move(paramBuffer));
11487 }
11488
CaptureTexBufferOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)11489 CallCapture CaptureTexBufferOES(const State &glState,
11490 bool isCallValid,
11491 TextureType targetPacked,
11492 GLenum internalformat,
11493 BufferID bufferPacked)
11494 {
11495 ParamBuffer paramBuffer;
11496
11497 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11498 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11499 internalformat);
11500 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
11501
11502 return CallCapture(angle::EntryPoint::GLTexBufferOES, std::move(paramBuffer));
11503 }
11504
CaptureTexBufferRangeOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)11505 CallCapture CaptureTexBufferRangeOES(const State &glState,
11506 bool isCallValid,
11507 TextureType targetPacked,
11508 GLenum internalformat,
11509 BufferID bufferPacked,
11510 GLintptr offset,
11511 GLsizeiptr size)
11512 {
11513 ParamBuffer paramBuffer;
11514
11515 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11516 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11517 internalformat);
11518 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
11519 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
11520 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
11521
11522 return CallCapture(angle::EntryPoint::GLTexBufferRangeOES, std::move(paramBuffer));
11523 }
11524
CaptureGetTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat * params)11525 CallCapture CaptureGetTexGenfvOES(const State &glState,
11526 bool isCallValid,
11527 GLenum coord,
11528 GLenum pname,
11529 GLfloat *params)
11530 {
11531 ParamBuffer paramBuffer;
11532
11533 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11534 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11535
11536 if (isCallValid)
11537 {
11538 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
11539 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
11540 CaptureGetTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11541 paramBuffer.addParam(std::move(paramsParam));
11542 }
11543 else
11544 {
11545 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
11546 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
11547 ¶msParam.value);
11548 paramBuffer.addParam(std::move(paramsParam));
11549 }
11550
11551 return CallCapture(angle::EntryPoint::GLGetTexGenfvOES, std::move(paramBuffer));
11552 }
11553
CaptureGetTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint * params)11554 CallCapture CaptureGetTexGenivOES(const State &glState,
11555 bool isCallValid,
11556 GLenum coord,
11557 GLenum pname,
11558 GLint *params)
11559 {
11560 ParamBuffer paramBuffer;
11561
11562 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11563 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11564
11565 if (isCallValid)
11566 {
11567 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11568 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11569 CaptureGetTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11570 paramBuffer.addParam(std::move(paramsParam));
11571 }
11572 else
11573 {
11574 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11575 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11576 paramBuffer.addParam(std::move(paramsParam));
11577 }
11578
11579 return CallCapture(angle::EntryPoint::GLGetTexGenivOES, std::move(paramBuffer));
11580 }
11581
CaptureGetTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed * params)11582 CallCapture CaptureGetTexGenxvOES(const State &glState,
11583 bool isCallValid,
11584 GLenum coord,
11585 GLenum pname,
11586 GLfixed *params)
11587 {
11588 ParamBuffer paramBuffer;
11589
11590 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11591 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11592
11593 if (isCallValid)
11594 {
11595 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
11596 InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value);
11597 CaptureGetTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11598 paramBuffer.addParam(std::move(paramsParam));
11599 }
11600 else
11601 {
11602 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
11603 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
11604 ¶msParam.value);
11605 paramBuffer.addParam(std::move(paramsParam));
11606 }
11607
11608 return CallCapture(angle::EntryPoint::GLGetTexGenxvOES, std::move(paramBuffer));
11609 }
11610
CaptureTexGenfOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat param)11611 CallCapture CaptureTexGenfOES(const State &glState,
11612 bool isCallValid,
11613 GLenum coord,
11614 GLenum pname,
11615 GLfloat param)
11616 {
11617 ParamBuffer paramBuffer;
11618
11619 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11620 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11621 paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
11622
11623 return CallCapture(angle::EntryPoint::GLTexGenfOES, std::move(paramBuffer));
11624 }
11625
CaptureTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfloat * params)11626 CallCapture CaptureTexGenfvOES(const State &glState,
11627 bool isCallValid,
11628 GLenum coord,
11629 GLenum pname,
11630 const GLfloat *params)
11631 {
11632 ParamBuffer paramBuffer;
11633
11634 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11635 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11636
11637 if (isCallValid)
11638 {
11639 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
11640 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
11641 CaptureTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11642 paramBuffer.addParam(std::move(paramsParam));
11643 }
11644 else
11645 {
11646 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
11647 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
11648 ¶msParam.value);
11649 paramBuffer.addParam(std::move(paramsParam));
11650 }
11651
11652 return CallCapture(angle::EntryPoint::GLTexGenfvOES, std::move(paramBuffer));
11653 }
11654
CaptureTexGeniOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint param)11655 CallCapture CaptureTexGeniOES(const State &glState,
11656 bool isCallValid,
11657 GLenum coord,
11658 GLenum pname,
11659 GLint param)
11660 {
11661 ParamBuffer paramBuffer;
11662
11663 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11664 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11665 paramBuffer.addValueParam("param", ParamType::TGLint, param);
11666
11667 return CallCapture(angle::EntryPoint::GLTexGeniOES, std::move(paramBuffer));
11668 }
11669
CaptureTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLint * params)11670 CallCapture CaptureTexGenivOES(const State &glState,
11671 bool isCallValid,
11672 GLenum coord,
11673 GLenum pname,
11674 const GLint *params)
11675 {
11676 ParamBuffer paramBuffer;
11677
11678 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11679 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11680
11681 if (isCallValid)
11682 {
11683 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11684 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
11685 CaptureTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11686 paramBuffer.addParam(std::move(paramsParam));
11687 }
11688 else
11689 {
11690 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11691 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11692 ¶msParam.value);
11693 paramBuffer.addParam(std::move(paramsParam));
11694 }
11695
11696 return CallCapture(angle::EntryPoint::GLTexGenivOES, std::move(paramBuffer));
11697 }
11698
CaptureTexGenxOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed param)11699 CallCapture CaptureTexGenxOES(const State &glState,
11700 bool isCallValid,
11701 GLenum coord,
11702 GLenum pname,
11703 GLfixed param)
11704 {
11705 ParamBuffer paramBuffer;
11706
11707 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11708 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11709 paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
11710
11711 return CallCapture(angle::EntryPoint::GLTexGenxOES, std::move(paramBuffer));
11712 }
11713
CaptureTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfixed * params)11714 CallCapture CaptureTexGenxvOES(const State &glState,
11715 bool isCallValid,
11716 GLenum coord,
11717 GLenum pname,
11718 const GLfixed *params)
11719 {
11720 ParamBuffer paramBuffer;
11721
11722 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11723 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11724
11725 if (isCallValid)
11726 {
11727 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
11728 InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value);
11729 CaptureTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11730 paramBuffer.addParam(std::move(paramsParam));
11731 }
11732 else
11733 {
11734 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
11735 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
11736 ¶msParam.value);
11737 paramBuffer.addParam(std::move(paramsParam));
11738 }
11739
11740 return CallCapture(angle::EntryPoint::GLTexGenxvOES, std::move(paramBuffer));
11741 }
11742
CaptureTexStorage3DMultisampleOES(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)11743 CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
11744 bool isCallValid,
11745 TextureType targetPacked,
11746 GLsizei samples,
11747 GLenum internalformat,
11748 GLsizei width,
11749 GLsizei height,
11750 GLsizei depth,
11751 GLboolean fixedsamplelocations)
11752 {
11753 ParamBuffer paramBuffer;
11754
11755 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11756 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
11757 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11758 internalformat);
11759 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11760 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11761 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11762 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
11763
11764 return CallCapture(angle::EntryPoint::GLTexStorage3DMultisampleOES, std::move(paramBuffer));
11765 }
11766
CaptureBindVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked)11767 CallCapture CaptureBindVertexArrayOES(const State &glState,
11768 bool isCallValid,
11769 VertexArrayID arrayPacked)
11770 {
11771 ParamBuffer paramBuffer;
11772
11773 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
11774
11775 return CallCapture(angle::EntryPoint::GLBindVertexArrayOES, std::move(paramBuffer));
11776 }
11777
CaptureDeleteVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,const VertexArrayID * arraysPacked)11778 CallCapture CaptureDeleteVertexArraysOES(const State &glState,
11779 bool isCallValid,
11780 GLsizei n,
11781 const VertexArrayID *arraysPacked)
11782 {
11783 ParamBuffer paramBuffer;
11784
11785 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
11786
11787 if (isCallValid)
11788 {
11789 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
11790 InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked,
11791 &arraysPackedParam.value);
11792 CaptureDeleteVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
11793 &arraysPackedParam);
11794 paramBuffer.addParam(std::move(arraysPackedParam));
11795 }
11796 else
11797 {
11798 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
11799 InitParamValue(ParamType::TVertexArrayIDConstPointer,
11800 static_cast<const VertexArrayID *>(nullptr), &arraysPackedParam.value);
11801 paramBuffer.addParam(std::move(arraysPackedParam));
11802 }
11803
11804 return CallCapture(angle::EntryPoint::GLDeleteVertexArraysOES, std::move(paramBuffer));
11805 }
11806
CaptureGenVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,VertexArrayID * arraysPacked)11807 CallCapture CaptureGenVertexArraysOES(const State &glState,
11808 bool isCallValid,
11809 GLsizei n,
11810 VertexArrayID *arraysPacked)
11811 {
11812 ParamBuffer paramBuffer;
11813
11814 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
11815
11816 if (isCallValid)
11817 {
11818 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
11819 InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
11820 CaptureGenVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
11821 &arraysPackedParam);
11822 paramBuffer.addParam(std::move(arraysPackedParam));
11823 }
11824 else
11825 {
11826 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
11827 InitParamValue(ParamType::TVertexArrayIDPointer, static_cast<VertexArrayID *>(nullptr),
11828 &arraysPackedParam.value);
11829 paramBuffer.addParam(std::move(arraysPackedParam));
11830 }
11831
11832 return CallCapture(angle::EntryPoint::GLGenVertexArraysOES, std::move(paramBuffer));
11833 }
11834
CaptureIsVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked,GLboolean returnValue)11835 CallCapture CaptureIsVertexArrayOES(const State &glState,
11836 bool isCallValid,
11837 VertexArrayID arrayPacked,
11838 GLboolean returnValue)
11839 {
11840 ParamBuffer paramBuffer;
11841
11842 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
11843
11844 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
11845 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
11846 paramBuffer.addReturnValue(std::move(returnValueCapture));
11847
11848 return CallCapture(angle::EntryPoint::GLIsVertexArrayOES, std::move(paramBuffer));
11849 }
11850
CaptureFramebufferTextureMultiviewOVR(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level,GLint baseViewIndex,GLsizei numViews)11851 CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
11852 bool isCallValid,
11853 GLenum target,
11854 GLenum attachment,
11855 TextureID texturePacked,
11856 GLint level,
11857 GLint baseViewIndex,
11858 GLsizei numViews)
11859 {
11860 ParamBuffer paramBuffer;
11861
11862 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
11863 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
11864 attachment);
11865 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
11866 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11867 paramBuffer.addValueParam("baseViewIndex", ParamType::TGLint, baseViewIndex);
11868 paramBuffer.addValueParam("numViews", ParamType::TGLsizei, numViews);
11869
11870 return CallCapture(angle::EntryPoint::GLFramebufferTextureMultiviewOVR, std::move(paramBuffer));
11871 }
11872
CaptureShadingRateQCOM(const State & glState,bool isCallValid,GLenum rate)11873 CallCapture CaptureShadingRateQCOM(const State &glState, bool isCallValid, GLenum rate)
11874 {
11875 ParamBuffer paramBuffer;
11876
11877 paramBuffer.addEnumParam("rate", GLESEnum::ShadingRateQCOM, ParamType::TGLenum, rate);
11878
11879 return CallCapture(angle::EntryPoint::GLShadingRateQCOM, std::move(paramBuffer));
11880 }
11881
11882 } // namespace gl
11883