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
CaptureGetGraphicsResetStatusKHR(const State & glState,bool isCallValid,GLenum returnValue)9625 CallCapture CaptureGetGraphicsResetStatusKHR(const State &glState,
9626 bool isCallValid,
9627 GLenum returnValue)
9628 {
9629 ParamBuffer paramBuffer;
9630
9631 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
9632 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
9633 paramBuffer.addReturnValue(std::move(returnValueCapture));
9634
9635 return CallCapture(angle::EntryPoint::GLGetGraphicsResetStatusKHR, std::move(paramBuffer));
9636 }
9637
CaptureGetnUniformfvKHR(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)9638 CallCapture CaptureGetnUniformfvKHR(const State &glState,
9639 bool isCallValid,
9640 ShaderProgramID programPacked,
9641 UniformLocation locationPacked,
9642 GLsizei bufSize,
9643 GLfloat *params)
9644 {
9645 ParamBuffer paramBuffer;
9646
9647 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
9648 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
9649 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9650
9651 if (isCallValid)
9652 {
9653 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
9654 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
9655 CaptureGetnUniformfvKHR_params(glState, isCallValid, programPacked, locationPacked, bufSize,
9656 params, ¶msParam);
9657 paramBuffer.addParam(std::move(paramsParam));
9658 }
9659 else
9660 {
9661 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
9662 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
9663 ¶msParam.value);
9664 paramBuffer.addParam(std::move(paramsParam));
9665 }
9666
9667 return CallCapture(angle::EntryPoint::GLGetnUniformfvKHR, std::move(paramBuffer));
9668 }
9669
CaptureGetnUniformivKHR(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)9670 CallCapture CaptureGetnUniformivKHR(const State &glState,
9671 bool isCallValid,
9672 ShaderProgramID programPacked,
9673 UniformLocation locationPacked,
9674 GLsizei bufSize,
9675 GLint *params)
9676 {
9677 ParamBuffer paramBuffer;
9678
9679 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
9680 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
9681 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9682
9683 if (isCallValid)
9684 {
9685 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9686 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9687 CaptureGetnUniformivKHR_params(glState, isCallValid, programPacked, locationPacked, bufSize,
9688 params, ¶msParam);
9689 paramBuffer.addParam(std::move(paramsParam));
9690 }
9691 else
9692 {
9693 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9694 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9695 paramBuffer.addParam(std::move(paramsParam));
9696 }
9697
9698 return CallCapture(angle::EntryPoint::GLGetnUniformivKHR, std::move(paramBuffer));
9699 }
9700
CaptureGetnUniformuivKHR(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLuint * params)9701 CallCapture CaptureGetnUniformuivKHR(const State &glState,
9702 bool isCallValid,
9703 ShaderProgramID programPacked,
9704 UniformLocation locationPacked,
9705 GLsizei bufSize,
9706 GLuint *params)
9707 {
9708 ParamBuffer paramBuffer;
9709
9710 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
9711 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
9712 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9713
9714 if (isCallValid)
9715 {
9716 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
9717 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
9718 CaptureGetnUniformuivKHR_params(glState, isCallValid, programPacked, locationPacked,
9719 bufSize, params, ¶msParam);
9720 paramBuffer.addParam(std::move(paramsParam));
9721 }
9722 else
9723 {
9724 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
9725 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
9726 ¶msParam.value);
9727 paramBuffer.addParam(std::move(paramsParam));
9728 }
9729
9730 return CallCapture(angle::EntryPoint::GLGetnUniformuivKHR, std::move(paramBuffer));
9731 }
9732
CaptureReadnPixelsKHR(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)9733 CallCapture CaptureReadnPixelsKHR(const State &glState,
9734 bool isCallValid,
9735 GLint x,
9736 GLint y,
9737 GLsizei width,
9738 GLsizei height,
9739 GLenum format,
9740 GLenum type,
9741 GLsizei bufSize,
9742 void *data)
9743 {
9744 ParamBuffer paramBuffer;
9745
9746 paramBuffer.addValueParam("x", ParamType::TGLint, x);
9747 paramBuffer.addValueParam("y", ParamType::TGLint, y);
9748 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9749 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9750 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
9751 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
9752 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9753
9754 if (isCallValid)
9755 {
9756 ParamCapture dataParam("data", ParamType::TvoidPointer);
9757 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
9758 CaptureReadnPixelsKHR_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
9759 data, &dataParam);
9760 paramBuffer.addParam(std::move(dataParam));
9761 }
9762 else
9763 {
9764 ParamCapture dataParam("data", ParamType::TvoidPointer);
9765 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
9766 paramBuffer.addParam(std::move(dataParam));
9767 }
9768
9769 return CallCapture(angle::EntryPoint::GLReadnPixelsKHR, std::move(paramBuffer));
9770 }
9771
CaptureFramebufferParameteriMESA(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint param)9772 CallCapture CaptureFramebufferParameteriMESA(const State &glState,
9773 bool isCallValid,
9774 GLenum target,
9775 GLenum pname,
9776 GLint param)
9777 {
9778 ParamBuffer paramBuffer;
9779
9780 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
9781 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferParameterName, ParamType::TGLenum,
9782 pname);
9783 paramBuffer.addValueParam("param", ParamType::TGLint, param);
9784
9785 return CallCapture(angle::EntryPoint::GLFramebufferParameteriMESA, std::move(paramBuffer));
9786 }
9787
CaptureGetFramebufferParameterivMESA(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)9788 CallCapture CaptureGetFramebufferParameterivMESA(const State &glState,
9789 bool isCallValid,
9790 GLenum target,
9791 GLenum pname,
9792 GLint *params)
9793 {
9794 ParamBuffer paramBuffer;
9795
9796 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
9797 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName,
9798 ParamType::TGLenum, pname);
9799
9800 if (isCallValid)
9801 {
9802 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9803 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9804 CaptureGetFramebufferParameterivMESA_params(glState, isCallValid, target, pname, params,
9805 ¶msParam);
9806 paramBuffer.addParam(std::move(paramsParam));
9807 }
9808 else
9809 {
9810 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9811 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9812 paramBuffer.addParam(std::move(paramsParam));
9813 }
9814
9815 return CallCapture(angle::EntryPoint::GLGetFramebufferParameterivMESA, std::move(paramBuffer));
9816 }
9817
CaptureDeleteFencesNV(const State & glState,bool isCallValid,GLsizei n,const FenceNVID * fencesPacked)9818 CallCapture CaptureDeleteFencesNV(const State &glState,
9819 bool isCallValid,
9820 GLsizei n,
9821 const FenceNVID *fencesPacked)
9822 {
9823 ParamBuffer paramBuffer;
9824
9825 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
9826
9827 if (isCallValid)
9828 {
9829 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
9830 InitParamValue(ParamType::TFenceNVIDConstPointer, fencesPacked, &fencesPackedParam.value);
9831 CaptureDeleteFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked,
9832 &fencesPackedParam);
9833 paramBuffer.addParam(std::move(fencesPackedParam));
9834 }
9835 else
9836 {
9837 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
9838 InitParamValue(ParamType::TFenceNVIDConstPointer, static_cast<const FenceNVID *>(nullptr),
9839 &fencesPackedParam.value);
9840 paramBuffer.addParam(std::move(fencesPackedParam));
9841 }
9842
9843 return CallCapture(angle::EntryPoint::GLDeleteFencesNV, std::move(paramBuffer));
9844 }
9845
CaptureFinishFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked)9846 CallCapture CaptureFinishFenceNV(const State &glState, bool isCallValid, FenceNVID fencePacked)
9847 {
9848 ParamBuffer paramBuffer;
9849
9850 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9851
9852 return CallCapture(angle::EntryPoint::GLFinishFenceNV, std::move(paramBuffer));
9853 }
9854
CaptureGenFencesNV(const State & glState,bool isCallValid,GLsizei n,FenceNVID * fencesPacked)9855 CallCapture CaptureGenFencesNV(const State &glState,
9856 bool isCallValid,
9857 GLsizei n,
9858 FenceNVID *fencesPacked)
9859 {
9860 ParamBuffer paramBuffer;
9861
9862 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
9863
9864 if (isCallValid)
9865 {
9866 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
9867 InitParamValue(ParamType::TFenceNVIDPointer, fencesPacked, &fencesPackedParam.value);
9868 CaptureGenFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked, &fencesPackedParam);
9869 paramBuffer.addParam(std::move(fencesPackedParam));
9870 }
9871 else
9872 {
9873 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
9874 InitParamValue(ParamType::TFenceNVIDPointer, static_cast<FenceNVID *>(nullptr),
9875 &fencesPackedParam.value);
9876 paramBuffer.addParam(std::move(fencesPackedParam));
9877 }
9878
9879 return CallCapture(angle::EntryPoint::GLGenFencesNV, std::move(paramBuffer));
9880 }
9881
CaptureGetFenceivNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum pname,GLint * params)9882 CallCapture CaptureGetFenceivNV(const State &glState,
9883 bool isCallValid,
9884 FenceNVID fencePacked,
9885 GLenum pname,
9886 GLint *params)
9887 {
9888 ParamBuffer paramBuffer;
9889
9890 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9891 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
9892
9893 if (isCallValid)
9894 {
9895 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9896 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9897 CaptureGetFenceivNV_params(glState, isCallValid, fencePacked, pname, params, ¶msParam);
9898 paramBuffer.addParam(std::move(paramsParam));
9899 }
9900 else
9901 {
9902 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9903 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9904 paramBuffer.addParam(std::move(paramsParam));
9905 }
9906
9907 return CallCapture(angle::EntryPoint::GLGetFenceivNV, std::move(paramBuffer));
9908 }
9909
CaptureIsFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)9910 CallCapture CaptureIsFenceNV(const State &glState,
9911 bool isCallValid,
9912 FenceNVID fencePacked,
9913 GLboolean returnValue)
9914 {
9915 ParamBuffer paramBuffer;
9916
9917 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9918
9919 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
9920 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
9921 paramBuffer.addReturnValue(std::move(returnValueCapture));
9922
9923 return CallCapture(angle::EntryPoint::GLIsFenceNV, std::move(paramBuffer));
9924 }
9925
CaptureSetFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum condition)9926 CallCapture CaptureSetFenceNV(const State &glState,
9927 bool isCallValid,
9928 FenceNVID fencePacked,
9929 GLenum condition)
9930 {
9931 ParamBuffer paramBuffer;
9932
9933 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9934 paramBuffer.addEnumParam("condition", GLESEnum::AllEnums, ParamType::TGLenum, condition);
9935
9936 return CallCapture(angle::EntryPoint::GLSetFenceNV, std::move(paramBuffer));
9937 }
9938
CaptureTestFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)9939 CallCapture CaptureTestFenceNV(const State &glState,
9940 bool isCallValid,
9941 FenceNVID fencePacked,
9942 GLboolean returnValue)
9943 {
9944 ParamBuffer paramBuffer;
9945
9946 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
9947
9948 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
9949 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
9950 paramBuffer.addReturnValue(std::move(returnValueCapture));
9951
9952 return CallCapture(angle::EntryPoint::GLTestFenceNV, std::move(paramBuffer));
9953 }
9954
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)9955 CallCapture CaptureBlitFramebufferNV(const State &glState,
9956 bool isCallValid,
9957 GLint srcX0,
9958 GLint srcY0,
9959 GLint srcX1,
9960 GLint srcY1,
9961 GLint dstX0,
9962 GLint dstY0,
9963 GLint dstX1,
9964 GLint dstY1,
9965 GLbitfield mask,
9966 GLenum filter)
9967 {
9968 ParamBuffer paramBuffer;
9969
9970 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
9971 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
9972 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
9973 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
9974 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
9975 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
9976 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
9977 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
9978 paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask);
9979 paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter);
9980
9981 return CallCapture(angle::EntryPoint::GLBlitFramebufferNV, std::move(paramBuffer));
9982 }
9983
CapturePolygonModeNV(const State & glState,bool isCallValid,GLenum face,PolygonMode modePacked)9984 CallCapture CapturePolygonModeNV(const State &glState,
9985 bool isCallValid,
9986 GLenum face,
9987 PolygonMode modePacked)
9988 {
9989 ParamBuffer paramBuffer;
9990
9991 paramBuffer.addEnumParam("face", GLESEnum::TriangleFace, ParamType::TGLenum, face);
9992 paramBuffer.addValueParam("modePacked", ParamType::TPolygonMode, modePacked);
9993
9994 return CallCapture(angle::EntryPoint::GLPolygonModeNV, std::move(paramBuffer));
9995 }
9996
CaptureEGLImageTargetRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,egl::ImageID imagePacked)9997 CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
9998 bool isCallValid,
9999 GLenum target,
10000 egl::ImageID imagePacked)
10001 {
10002 ParamBuffer paramBuffer;
10003
10004 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
10005 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
10006
10007 return CallCapture(angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES,
10008 std::move(paramBuffer));
10009 }
10010
CaptureEGLImageTargetTexture2DOES(const State & glState,bool isCallValid,TextureType targetPacked,egl::ImageID imagePacked)10011 CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
10012 bool isCallValid,
10013 TextureType targetPacked,
10014 egl::ImageID imagePacked)
10015 {
10016 ParamBuffer paramBuffer;
10017
10018 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
10019 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
10020
10021 return CallCapture(angle::EntryPoint::GLEGLImageTargetTexture2DOES, std::move(paramBuffer));
10022 }
10023
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)10024 CallCapture CaptureCopyImageSubDataOES(const State &glState,
10025 bool isCallValid,
10026 GLuint srcName,
10027 GLenum srcTarget,
10028 GLint srcLevel,
10029 GLint srcX,
10030 GLint srcY,
10031 GLint srcZ,
10032 GLuint dstName,
10033 GLenum dstTarget,
10034 GLint dstLevel,
10035 GLint dstX,
10036 GLint dstY,
10037 GLint dstZ,
10038 GLsizei srcWidth,
10039 GLsizei srcHeight,
10040 GLsizei srcDepth)
10041 {
10042 ParamBuffer paramBuffer;
10043
10044 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
10045 paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
10046 srcTarget);
10047 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
10048 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
10049 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
10050 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
10051 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
10052 paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
10053 dstTarget);
10054 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
10055 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
10056 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
10057 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
10058 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
10059 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
10060 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
10061
10062 return CallCapture(angle::EntryPoint::GLCopyImageSubDataOES, std::move(paramBuffer));
10063 }
10064
CaptureBlendEquationSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)10065 CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
10066 bool isCallValid,
10067 GLuint buf,
10068 GLenum modeRGB,
10069 GLenum modeAlpha)
10070 {
10071 ParamBuffer paramBuffer;
10072
10073 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10074 paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
10075 modeRGB);
10076 paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
10077 modeAlpha);
10078
10079 return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiOES, std::move(paramBuffer));
10080 }
10081
CaptureBlendEquationiOES(const State & glState,bool isCallValid,GLuint buf,GLenum mode)10082 CallCapture CaptureBlendEquationiOES(const State &glState,
10083 bool isCallValid,
10084 GLuint buf,
10085 GLenum mode)
10086 {
10087 ParamBuffer paramBuffer;
10088
10089 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10090 paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode);
10091
10092 return CallCapture(angle::EntryPoint::GLBlendEquationiOES, std::move(paramBuffer));
10093 }
10094
CaptureBlendFuncSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)10095 CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
10096 bool isCallValid,
10097 GLuint buf,
10098 GLenum srcRGB,
10099 GLenum dstRGB,
10100 GLenum srcAlpha,
10101 GLenum dstAlpha)
10102 {
10103 ParamBuffer paramBuffer;
10104
10105 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10106 paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB);
10107 paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB);
10108 paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha);
10109 paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha);
10110
10111 return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiOES, std::move(paramBuffer));
10112 }
10113
CaptureBlendFunciOES(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)10114 CallCapture CaptureBlendFunciOES(const State &glState,
10115 bool isCallValid,
10116 GLuint buf,
10117 GLenum src,
10118 GLenum dst)
10119 {
10120 ParamBuffer paramBuffer;
10121
10122 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10123 paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src);
10124 paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst);
10125
10126 return CallCapture(angle::EntryPoint::GLBlendFunciOES, std::move(paramBuffer));
10127 }
10128
CaptureColorMaskiOES(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)10129 CallCapture CaptureColorMaskiOES(const State &glState,
10130 bool isCallValid,
10131 GLuint index,
10132 GLboolean r,
10133 GLboolean g,
10134 GLboolean b,
10135 GLboolean a)
10136 {
10137 ParamBuffer paramBuffer;
10138
10139 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10140 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
10141 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
10142 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
10143 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
10144
10145 return CallCapture(angle::EntryPoint::GLColorMaskiOES, std::move(paramBuffer));
10146 }
10147
CaptureDisableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)10148 CallCapture CaptureDisableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
10149 {
10150 ParamBuffer paramBuffer;
10151
10152 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10153 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10154
10155 return CallCapture(angle::EntryPoint::GLDisableiOES, std::move(paramBuffer));
10156 }
10157
CaptureEnableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)10158 CallCapture CaptureEnableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
10159 {
10160 ParamBuffer paramBuffer;
10161
10162 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10163 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10164
10165 return CallCapture(angle::EntryPoint::GLEnableiOES, std::move(paramBuffer));
10166 }
10167
CaptureIsEnablediOES(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)10168 CallCapture CaptureIsEnablediOES(const State &glState,
10169 bool isCallValid,
10170 GLenum target,
10171 GLuint index,
10172 GLboolean returnValue)
10173 {
10174 ParamBuffer paramBuffer;
10175
10176 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10177 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10178
10179 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10180 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10181 paramBuffer.addReturnValue(std::move(returnValueCapture));
10182
10183 return CallCapture(angle::EntryPoint::GLIsEnablediOES, std::move(paramBuffer));
10184 }
10185
CaptureDrawElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)10186 CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
10187 bool isCallValid,
10188 PrimitiveMode modePacked,
10189 GLsizei count,
10190 DrawElementsType typePacked,
10191 const void *indices,
10192 GLint basevertex)
10193 {
10194 ParamBuffer paramBuffer;
10195
10196 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10197 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10198 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10199
10200 if (isCallValid)
10201 {
10202 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10203 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10204 CaptureDrawElementsBaseVertexOES_indices(glState, isCallValid, modePacked, count,
10205 typePacked, indices, basevertex, &indicesParam);
10206 paramBuffer.addParam(std::move(indicesParam));
10207 }
10208 else
10209 {
10210 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10211 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10212 &indicesParam.value);
10213 paramBuffer.addParam(std::move(indicesParam));
10214 }
10215
10216 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10217
10218 return CallCapture(angle::EntryPoint::GLDrawElementsBaseVertexOES, std::move(paramBuffer));
10219 }
10220
CaptureDrawElementsInstancedBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)10221 CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
10222 bool isCallValid,
10223 PrimitiveMode modePacked,
10224 GLsizei count,
10225 DrawElementsType typePacked,
10226 const void *indices,
10227 GLsizei instancecount,
10228 GLint basevertex)
10229 {
10230 ParamBuffer paramBuffer;
10231
10232 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10233 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10234 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10235
10236 if (isCallValid)
10237 {
10238 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10239 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10240 CaptureDrawElementsInstancedBaseVertexOES_indices(glState, isCallValid, modePacked, count,
10241 typePacked, indices, instancecount,
10242 basevertex, &indicesParam);
10243 paramBuffer.addParam(std::move(indicesParam));
10244 }
10245 else
10246 {
10247 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10248 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10249 &indicesParam.value);
10250 paramBuffer.addParam(std::move(indicesParam));
10251 }
10252
10253 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
10254 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10255
10256 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexOES,
10257 std::move(paramBuffer));
10258 }
10259
CaptureDrawRangeElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)10260 CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
10261 bool isCallValid,
10262 PrimitiveMode modePacked,
10263 GLuint start,
10264 GLuint end,
10265 GLsizei count,
10266 DrawElementsType typePacked,
10267 const void *indices,
10268 GLint basevertex)
10269 {
10270 ParamBuffer paramBuffer;
10271
10272 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10273 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
10274 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
10275 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10276 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10277
10278 if (isCallValid)
10279 {
10280 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10281 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10282 CaptureDrawRangeElementsBaseVertexOES_indices(glState, isCallValid, modePacked, start, end,
10283 count, typePacked, indices, basevertex,
10284 &indicesParam);
10285 paramBuffer.addParam(std::move(indicesParam));
10286 }
10287 else
10288 {
10289 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10290 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10291 &indicesParam.value);
10292 paramBuffer.addParam(std::move(indicesParam));
10293 }
10294
10295 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10296
10297 return CallCapture(angle::EntryPoint::GLDrawRangeElementsBaseVertexOES, std::move(paramBuffer));
10298 }
10299
CaptureDrawTexfOES(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)10300 CallCapture CaptureDrawTexfOES(const State &glState,
10301 bool isCallValid,
10302 GLfloat x,
10303 GLfloat y,
10304 GLfloat z,
10305 GLfloat width,
10306 GLfloat height)
10307 {
10308 ParamBuffer paramBuffer;
10309
10310 paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
10311 paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
10312 paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
10313 paramBuffer.addValueParam("width", ParamType::TGLfloat, width);
10314 paramBuffer.addValueParam("height", ParamType::TGLfloat, height);
10315
10316 return CallCapture(angle::EntryPoint::GLDrawTexfOES, std::move(paramBuffer));
10317 }
10318
CaptureDrawTexfvOES(const State & glState,bool isCallValid,const GLfloat * coords)10319 CallCapture CaptureDrawTexfvOES(const State &glState, bool isCallValid, const GLfloat *coords)
10320 {
10321 ParamBuffer paramBuffer;
10322
10323 if (isCallValid)
10324 {
10325 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
10326 InitParamValue(ParamType::TGLfloatConstPointer, coords, &coordsParam.value);
10327 CaptureDrawTexfvOES_coords(glState, isCallValid, coords, &coordsParam);
10328 paramBuffer.addParam(std::move(coordsParam));
10329 }
10330 else
10331 {
10332 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
10333 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
10334 &coordsParam.value);
10335 paramBuffer.addParam(std::move(coordsParam));
10336 }
10337
10338 return CallCapture(angle::EntryPoint::GLDrawTexfvOES, std::move(paramBuffer));
10339 }
10340
CaptureDrawTexiOES(const State & glState,bool isCallValid,GLint x,GLint y,GLint z,GLint width,GLint height)10341 CallCapture CaptureDrawTexiOES(const State &glState,
10342 bool isCallValid,
10343 GLint x,
10344 GLint y,
10345 GLint z,
10346 GLint width,
10347 GLint height)
10348 {
10349 ParamBuffer paramBuffer;
10350
10351 paramBuffer.addValueParam("x", ParamType::TGLint, x);
10352 paramBuffer.addValueParam("y", ParamType::TGLint, y);
10353 paramBuffer.addValueParam("z", ParamType::TGLint, z);
10354 paramBuffer.addValueParam("width", ParamType::TGLint, width);
10355 paramBuffer.addValueParam("height", ParamType::TGLint, height);
10356
10357 return CallCapture(angle::EntryPoint::GLDrawTexiOES, std::move(paramBuffer));
10358 }
10359
CaptureDrawTexivOES(const State & glState,bool isCallValid,const GLint * coords)10360 CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords)
10361 {
10362 ParamBuffer paramBuffer;
10363
10364 if (isCallValid)
10365 {
10366 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
10367 InitParamValue(ParamType::TGLintConstPointer, coords, &coordsParam.value);
10368 CaptureDrawTexivOES_coords(glState, isCallValid, coords, &coordsParam);
10369 paramBuffer.addParam(std::move(coordsParam));
10370 }
10371 else
10372 {
10373 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
10374 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
10375 &coordsParam.value);
10376 paramBuffer.addParam(std::move(coordsParam));
10377 }
10378
10379 return CallCapture(angle::EntryPoint::GLDrawTexivOES, std::move(paramBuffer));
10380 }
10381
CaptureDrawTexsOES(const State & glState,bool isCallValid,GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)10382 CallCapture CaptureDrawTexsOES(const State &glState,
10383 bool isCallValid,
10384 GLshort x,
10385 GLshort y,
10386 GLshort z,
10387 GLshort width,
10388 GLshort height)
10389 {
10390 ParamBuffer paramBuffer;
10391
10392 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
10393 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
10394 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
10395 paramBuffer.addValueParam("width", ParamType::TGLshort, width);
10396 paramBuffer.addValueParam("height", ParamType::TGLshort, height);
10397
10398 return CallCapture(angle::EntryPoint::GLDrawTexsOES, std::move(paramBuffer));
10399 }
10400
CaptureDrawTexsvOES(const State & glState,bool isCallValid,const GLshort * coords)10401 CallCapture CaptureDrawTexsvOES(const State &glState, bool isCallValid, const GLshort *coords)
10402 {
10403 ParamBuffer paramBuffer;
10404
10405 if (isCallValid)
10406 {
10407 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
10408 InitParamValue(ParamType::TGLshortConstPointer, coords, &coordsParam.value);
10409 CaptureDrawTexsvOES_coords(glState, isCallValid, coords, &coordsParam);
10410 paramBuffer.addParam(std::move(coordsParam));
10411 }
10412 else
10413 {
10414 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
10415 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
10416 &coordsParam.value);
10417 paramBuffer.addParam(std::move(coordsParam));
10418 }
10419
10420 return CallCapture(angle::EntryPoint::GLDrawTexsvOES, std::move(paramBuffer));
10421 }
10422
CaptureDrawTexxOES(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)10423 CallCapture CaptureDrawTexxOES(const State &glState,
10424 bool isCallValid,
10425 GLfixed x,
10426 GLfixed y,
10427 GLfixed z,
10428 GLfixed width,
10429 GLfixed height)
10430 {
10431 ParamBuffer paramBuffer;
10432
10433 paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
10434 paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
10435 paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
10436 paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
10437 paramBuffer.addValueParam("height", ParamType::TGLfixed, height);
10438
10439 return CallCapture(angle::EntryPoint::GLDrawTexxOES, std::move(paramBuffer));
10440 }
10441
CaptureDrawTexxvOES(const State & glState,bool isCallValid,const GLfixed * coords)10442 CallCapture CaptureDrawTexxvOES(const State &glState, bool isCallValid, const GLfixed *coords)
10443 {
10444 ParamBuffer paramBuffer;
10445
10446 if (isCallValid)
10447 {
10448 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
10449 InitParamValue(ParamType::TGLfixedConstPointer, coords, &coordsParam.value);
10450 CaptureDrawTexxvOES_coords(glState, isCallValid, coords, &coordsParam);
10451 paramBuffer.addParam(std::move(coordsParam));
10452 }
10453 else
10454 {
10455 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
10456 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
10457 &coordsParam.value);
10458 paramBuffer.addParam(std::move(coordsParam));
10459 }
10460
10461 return CallCapture(angle::EntryPoint::GLDrawTexxvOES, std::move(paramBuffer));
10462 }
10463
CaptureBindFramebufferOES(const State & glState,bool isCallValid,GLenum target,FramebufferID framebufferPacked)10464 CallCapture CaptureBindFramebufferOES(const State &glState,
10465 bool isCallValid,
10466 GLenum target,
10467 FramebufferID framebufferPacked)
10468 {
10469 ParamBuffer paramBuffer;
10470
10471 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10472 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
10473
10474 return CallCapture(angle::EntryPoint::GLBindFramebufferOES, std::move(paramBuffer));
10475 }
10476
CaptureBindRenderbufferOES(const State & glState,bool isCallValid,GLenum target,RenderbufferID renderbufferPacked)10477 CallCapture CaptureBindRenderbufferOES(const State &glState,
10478 bool isCallValid,
10479 GLenum target,
10480 RenderbufferID renderbufferPacked)
10481 {
10482 ParamBuffer paramBuffer;
10483
10484 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10485 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10486
10487 return CallCapture(angle::EntryPoint::GLBindRenderbufferOES, std::move(paramBuffer));
10488 }
10489
CaptureCheckFramebufferStatusOES(const State & glState,bool isCallValid,GLenum target,GLenum returnValue)10490 CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
10491 bool isCallValid,
10492 GLenum target,
10493 GLenum returnValue)
10494 {
10495 ParamBuffer paramBuffer;
10496
10497 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10498
10499 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
10500 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
10501 paramBuffer.addReturnValue(std::move(returnValueCapture));
10502
10503 return CallCapture(angle::EntryPoint::GLCheckFramebufferStatusOES, std::move(paramBuffer));
10504 }
10505
CaptureDeleteFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,const FramebufferID * framebuffersPacked)10506 CallCapture CaptureDeleteFramebuffersOES(const State &glState,
10507 bool isCallValid,
10508 GLsizei n,
10509 const FramebufferID *framebuffersPacked)
10510 {
10511 ParamBuffer paramBuffer;
10512
10513 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10514
10515 if (isCallValid)
10516 {
10517 ParamCapture framebuffersPackedParam("framebuffersPacked",
10518 ParamType::TFramebufferIDConstPointer);
10519 InitParamValue(ParamType::TFramebufferIDConstPointer, framebuffersPacked,
10520 &framebuffersPackedParam.value);
10521 CaptureDeleteFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
10522 &framebuffersPackedParam);
10523 paramBuffer.addParam(std::move(framebuffersPackedParam));
10524 }
10525 else
10526 {
10527 ParamCapture framebuffersPackedParam("framebuffersPacked",
10528 ParamType::TFramebufferIDConstPointer);
10529 InitParamValue(ParamType::TFramebufferIDConstPointer,
10530 static_cast<const FramebufferID *>(nullptr), &framebuffersPackedParam.value);
10531 paramBuffer.addParam(std::move(framebuffersPackedParam));
10532 }
10533
10534 return CallCapture(angle::EntryPoint::GLDeleteFramebuffersOES, std::move(paramBuffer));
10535 }
10536
CaptureDeleteRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,const RenderbufferID * renderbuffersPacked)10537 CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
10538 bool isCallValid,
10539 GLsizei n,
10540 const RenderbufferID *renderbuffersPacked)
10541 {
10542 ParamBuffer paramBuffer;
10543
10544 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10545
10546 if (isCallValid)
10547 {
10548 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10549 ParamType::TRenderbufferIDConstPointer);
10550 InitParamValue(ParamType::TRenderbufferIDConstPointer, renderbuffersPacked,
10551 &renderbuffersPackedParam.value);
10552 CaptureDeleteRenderbuffersOES_renderbuffersPacked(
10553 glState, isCallValid, n, renderbuffersPacked, &renderbuffersPackedParam);
10554 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10555 }
10556 else
10557 {
10558 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10559 ParamType::TRenderbufferIDConstPointer);
10560 InitParamValue(ParamType::TRenderbufferIDConstPointer,
10561 static_cast<const RenderbufferID *>(nullptr),
10562 &renderbuffersPackedParam.value);
10563 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10564 }
10565
10566 return CallCapture(angle::EntryPoint::GLDeleteRenderbuffersOES, std::move(paramBuffer));
10567 }
10568
CaptureFramebufferRenderbufferOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum renderbuffertarget,RenderbufferID renderbufferPacked)10569 CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
10570 bool isCallValid,
10571 GLenum target,
10572 GLenum attachment,
10573 GLenum renderbuffertarget,
10574 RenderbufferID renderbufferPacked)
10575 {
10576 ParamBuffer paramBuffer;
10577
10578 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10579 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10580 attachment);
10581 paramBuffer.addEnumParam("renderbuffertarget", GLESEnum::RenderbufferTarget, ParamType::TGLenum,
10582 renderbuffertarget);
10583 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10584
10585 return CallCapture(angle::EntryPoint::GLFramebufferRenderbufferOES, std::move(paramBuffer));
10586 }
10587
CaptureFramebufferTexture2DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level)10588 CallCapture CaptureFramebufferTexture2DOES(const State &glState,
10589 bool isCallValid,
10590 GLenum target,
10591 GLenum attachment,
10592 TextureTarget textargetPacked,
10593 TextureID texturePacked,
10594 GLint level)
10595 {
10596 ParamBuffer paramBuffer;
10597
10598 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10599 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10600 attachment);
10601 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
10602 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
10603 paramBuffer.addValueParam("level", ParamType::TGLint, level);
10604
10605 return CallCapture(angle::EntryPoint::GLFramebufferTexture2DOES, std::move(paramBuffer));
10606 }
10607
CaptureGenFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,FramebufferID * framebuffersPacked)10608 CallCapture CaptureGenFramebuffersOES(const State &glState,
10609 bool isCallValid,
10610 GLsizei n,
10611 FramebufferID *framebuffersPacked)
10612 {
10613 ParamBuffer paramBuffer;
10614
10615 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10616
10617 if (isCallValid)
10618 {
10619 ParamCapture framebuffersPackedParam("framebuffersPacked",
10620 ParamType::TFramebufferIDPointer);
10621 InitParamValue(ParamType::TFramebufferIDPointer, framebuffersPacked,
10622 &framebuffersPackedParam.value);
10623 CaptureGenFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
10624 &framebuffersPackedParam);
10625 paramBuffer.addParam(std::move(framebuffersPackedParam));
10626 }
10627 else
10628 {
10629 ParamCapture framebuffersPackedParam("framebuffersPacked",
10630 ParamType::TFramebufferIDPointer);
10631 InitParamValue(ParamType::TFramebufferIDPointer, static_cast<FramebufferID *>(nullptr),
10632 &framebuffersPackedParam.value);
10633 paramBuffer.addParam(std::move(framebuffersPackedParam));
10634 }
10635
10636 return CallCapture(angle::EntryPoint::GLGenFramebuffersOES, std::move(paramBuffer));
10637 }
10638
CaptureGenRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,RenderbufferID * renderbuffersPacked)10639 CallCapture CaptureGenRenderbuffersOES(const State &glState,
10640 bool isCallValid,
10641 GLsizei n,
10642 RenderbufferID *renderbuffersPacked)
10643 {
10644 ParamBuffer paramBuffer;
10645
10646 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10647
10648 if (isCallValid)
10649 {
10650 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10651 ParamType::TRenderbufferIDPointer);
10652 InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
10653 &renderbuffersPackedParam.value);
10654 CaptureGenRenderbuffersOES_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
10655 &renderbuffersPackedParam);
10656 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10657 }
10658 else
10659 {
10660 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10661 ParamType::TRenderbufferIDPointer);
10662 InitParamValue(ParamType::TRenderbufferIDPointer, static_cast<RenderbufferID *>(nullptr),
10663 &renderbuffersPackedParam.value);
10664 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10665 }
10666
10667 return CallCapture(angle::EntryPoint::GLGenRenderbuffersOES, std::move(paramBuffer));
10668 }
10669
CaptureGenerateMipmapOES(const State & glState,bool isCallValid,TextureType targetPacked)10670 CallCapture CaptureGenerateMipmapOES(const State &glState,
10671 bool isCallValid,
10672 TextureType targetPacked)
10673 {
10674 ParamBuffer paramBuffer;
10675
10676 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
10677
10678 return CallCapture(angle::EntryPoint::GLGenerateMipmapOES, std::move(paramBuffer));
10679 }
10680
CaptureGetFramebufferAttachmentParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLint * params)10681 CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
10682 bool isCallValid,
10683 GLenum target,
10684 GLenum attachment,
10685 GLenum pname,
10686 GLint *params)
10687 {
10688 ParamBuffer paramBuffer;
10689
10690 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10691 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10692 attachment);
10693 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName,
10694 ParamType::TGLenum, pname);
10695
10696 if (isCallValid)
10697 {
10698 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10699 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10700 CaptureGetFramebufferAttachmentParameterivOES_params(
10701 glState, isCallValid, target, attachment, pname, params, ¶msParam);
10702 paramBuffer.addParam(std::move(paramsParam));
10703 }
10704 else
10705 {
10706 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10707 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10708 paramBuffer.addParam(std::move(paramsParam));
10709 }
10710
10711 return CallCapture(angle::EntryPoint::GLGetFramebufferAttachmentParameterivOES,
10712 std::move(paramBuffer));
10713 }
10714
CaptureGetRenderbufferParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)10715 CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
10716 bool isCallValid,
10717 GLenum target,
10718 GLenum pname,
10719 GLint *params)
10720 {
10721 ParamBuffer paramBuffer;
10722
10723 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10724 paramBuffer.addEnumParam("pname", GLESEnum::RenderbufferParameterName, ParamType::TGLenum,
10725 pname);
10726
10727 if (isCallValid)
10728 {
10729 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10730 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10731 CaptureGetRenderbufferParameterivOES_params(glState, isCallValid, target, pname, params,
10732 ¶msParam);
10733 paramBuffer.addParam(std::move(paramsParam));
10734 }
10735 else
10736 {
10737 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10738 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10739 paramBuffer.addParam(std::move(paramsParam));
10740 }
10741
10742 return CallCapture(angle::EntryPoint::GLGetRenderbufferParameterivOES, std::move(paramBuffer));
10743 }
10744
CaptureIsFramebufferOES(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLboolean returnValue)10745 CallCapture CaptureIsFramebufferOES(const State &glState,
10746 bool isCallValid,
10747 FramebufferID framebufferPacked,
10748 GLboolean returnValue)
10749 {
10750 ParamBuffer paramBuffer;
10751
10752 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
10753
10754 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10755 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10756 paramBuffer.addReturnValue(std::move(returnValueCapture));
10757
10758 return CallCapture(angle::EntryPoint::GLIsFramebufferOES, std::move(paramBuffer));
10759 }
10760
CaptureIsRenderbufferOES(const State & glState,bool isCallValid,RenderbufferID renderbufferPacked,GLboolean returnValue)10761 CallCapture CaptureIsRenderbufferOES(const State &glState,
10762 bool isCallValid,
10763 RenderbufferID renderbufferPacked,
10764 GLboolean returnValue)
10765 {
10766 ParamBuffer paramBuffer;
10767
10768 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10769
10770 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10771 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10772 paramBuffer.addReturnValue(std::move(returnValueCapture));
10773
10774 return CallCapture(angle::EntryPoint::GLIsRenderbufferOES, std::move(paramBuffer));
10775 }
10776
CaptureRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)10777 CallCapture CaptureRenderbufferStorageOES(const State &glState,
10778 bool isCallValid,
10779 GLenum target,
10780 GLenum internalformat,
10781 GLsizei width,
10782 GLsizei height)
10783 {
10784 ParamBuffer paramBuffer;
10785
10786 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10787 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
10788 internalformat);
10789 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
10790 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
10791
10792 return CallCapture(angle::EntryPoint::GLRenderbufferStorageOES, std::move(paramBuffer));
10793 }
10794
CaptureFramebufferTextureOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)10795 CallCapture CaptureFramebufferTextureOES(const State &glState,
10796 bool isCallValid,
10797 GLenum target,
10798 GLenum attachment,
10799 TextureID texturePacked,
10800 GLint level)
10801 {
10802 ParamBuffer paramBuffer;
10803
10804 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10805 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10806 attachment);
10807 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
10808 paramBuffer.addValueParam("level", ParamType::TGLint, level);
10809
10810 return CallCapture(angle::EntryPoint::GLFramebufferTextureOES, std::move(paramBuffer));
10811 }
10812
CaptureGetProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)10813 CallCapture CaptureGetProgramBinaryOES(const State &glState,
10814 bool isCallValid,
10815 ShaderProgramID programPacked,
10816 GLsizei bufSize,
10817 GLsizei *length,
10818 GLenum *binaryFormat,
10819 void *binary)
10820 {
10821 ParamBuffer paramBuffer;
10822
10823 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
10824 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
10825
10826 if (isCallValid)
10827 {
10828 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
10829 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
10830 CaptureGetProgramBinaryOES_length(glState, isCallValid, programPacked, bufSize, length,
10831 binaryFormat, binary, &lengthParam);
10832 paramBuffer.addParam(std::move(lengthParam));
10833 }
10834 else
10835 {
10836 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
10837 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
10838 &lengthParam.value);
10839 paramBuffer.addParam(std::move(lengthParam));
10840 }
10841
10842 if (isCallValid)
10843 {
10844 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
10845 InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
10846 CaptureGetProgramBinaryOES_binaryFormat(glState, isCallValid, programPacked, bufSize,
10847 length, binaryFormat, binary, &binaryFormatParam);
10848 paramBuffer.addParam(std::move(binaryFormatParam));
10849 }
10850 else
10851 {
10852 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
10853 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
10854 &binaryFormatParam.value);
10855 paramBuffer.addParam(std::move(binaryFormatParam));
10856 }
10857
10858 if (isCallValid)
10859 {
10860 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
10861 InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
10862 CaptureGetProgramBinaryOES_binary(glState, isCallValid, programPacked, bufSize, length,
10863 binaryFormat, binary, &binaryParam);
10864 paramBuffer.addParam(std::move(binaryParam));
10865 }
10866 else
10867 {
10868 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
10869 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &binaryParam.value);
10870 paramBuffer.addParam(std::move(binaryParam));
10871 }
10872
10873 return CallCapture(angle::EntryPoint::GLGetProgramBinaryOES, std::move(paramBuffer));
10874 }
10875
CaptureProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum binaryFormat,const void * binary,GLint length)10876 CallCapture CaptureProgramBinaryOES(const State &glState,
10877 bool isCallValid,
10878 ShaderProgramID programPacked,
10879 GLenum binaryFormat,
10880 const void *binary,
10881 GLint length)
10882 {
10883 ParamBuffer paramBuffer;
10884
10885 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
10886 paramBuffer.addEnumParam("binaryFormat", GLESEnum::AllEnums, ParamType::TGLenum, binaryFormat);
10887
10888 if (isCallValid)
10889 {
10890 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
10891 InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
10892 CaptureProgramBinaryOES_binary(glState, isCallValid, programPacked, binaryFormat, binary,
10893 length, &binaryParam);
10894 paramBuffer.addParam(std::move(binaryParam));
10895 }
10896 else
10897 {
10898 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
10899 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10900 &binaryParam.value);
10901 paramBuffer.addParam(std::move(binaryParam));
10902 }
10903
10904 paramBuffer.addValueParam("length", ParamType::TGLint, length);
10905
10906 return CallCapture(angle::EntryPoint::GLProgramBinaryOES, std::move(paramBuffer));
10907 }
10908
CaptureGetBufferPointervOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,void ** params)10909 CallCapture CaptureGetBufferPointervOES(const State &glState,
10910 bool isCallValid,
10911 BufferBinding targetPacked,
10912 GLenum pname,
10913 void **params)
10914 {
10915 ParamBuffer paramBuffer;
10916
10917 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
10918 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
10919
10920 if (isCallValid)
10921 {
10922 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
10923 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
10924 CaptureGetBufferPointervOES_params(glState, isCallValid, targetPacked, pname, params,
10925 ¶msParam);
10926 paramBuffer.addParam(std::move(paramsParam));
10927 }
10928 else
10929 {
10930 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
10931 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
10932 ¶msParam.value);
10933 paramBuffer.addParam(std::move(paramsParam));
10934 }
10935
10936 return CallCapture(angle::EntryPoint::GLGetBufferPointervOES, std::move(paramBuffer));
10937 }
10938
CaptureMapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum access,void * returnValue)10939 CallCapture CaptureMapBufferOES(const State &glState,
10940 bool isCallValid,
10941 BufferBinding targetPacked,
10942 GLenum access,
10943 void *returnValue)
10944 {
10945 ParamBuffer paramBuffer;
10946
10947 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
10948 paramBuffer.addEnumParam("access", GLESEnum::BufferAccessARB, ParamType::TGLenum, access);
10949
10950 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
10951 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
10952 paramBuffer.addReturnValue(std::move(returnValueCapture));
10953
10954 return CallCapture(angle::EntryPoint::GLMapBufferOES, std::move(paramBuffer));
10955 }
10956
CaptureUnmapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLboolean returnValue)10957 CallCapture CaptureUnmapBufferOES(const State &glState,
10958 bool isCallValid,
10959 BufferBinding targetPacked,
10960 GLboolean returnValue)
10961 {
10962 ParamBuffer paramBuffer;
10963
10964 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
10965
10966 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10967 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10968 paramBuffer.addReturnValue(std::move(returnValueCapture));
10969
10970 return CallCapture(angle::EntryPoint::GLUnmapBufferOES, std::move(paramBuffer));
10971 }
10972
CaptureCurrentPaletteMatrixOES(const State & glState,bool isCallValid,GLuint matrixpaletteindex)10973 CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
10974 bool isCallValid,
10975 GLuint matrixpaletteindex)
10976 {
10977 ParamBuffer paramBuffer;
10978
10979 paramBuffer.addValueParam("matrixpaletteindex", ParamType::TGLuint, matrixpaletteindex);
10980
10981 return CallCapture(angle::EntryPoint::GLCurrentPaletteMatrixOES, std::move(paramBuffer));
10982 }
10983
CaptureLoadPaletteFromModelViewMatrixOES(const State & glState,bool isCallValid)10984 CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid)
10985 {
10986 ParamBuffer paramBuffer;
10987
10988 return CallCapture(angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES,
10989 std::move(paramBuffer));
10990 }
10991
CaptureMatrixIndexPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)10992 CallCapture CaptureMatrixIndexPointerOES(const State &glState,
10993 bool isCallValid,
10994 GLint size,
10995 GLenum type,
10996 GLsizei stride,
10997 const void *pointer)
10998 {
10999 ParamBuffer paramBuffer;
11000
11001 paramBuffer.addValueParam("size", ParamType::TGLint, size);
11002 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
11003 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
11004
11005 if (isCallValid)
11006 {
11007 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11008 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
11009 CaptureMatrixIndexPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
11010 &pointerParam);
11011 paramBuffer.addParam(std::move(pointerParam));
11012 }
11013 else
11014 {
11015 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11016 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11017 &pointerParam.value);
11018 paramBuffer.addParam(std::move(pointerParam));
11019 }
11020
11021 return CallCapture(angle::EntryPoint::GLMatrixIndexPointerOES, std::move(paramBuffer));
11022 }
11023
CaptureWeightPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)11024 CallCapture CaptureWeightPointerOES(const State &glState,
11025 bool isCallValid,
11026 GLint size,
11027 GLenum type,
11028 GLsizei stride,
11029 const void *pointer)
11030 {
11031 ParamBuffer paramBuffer;
11032
11033 paramBuffer.addValueParam("size", ParamType::TGLint, size);
11034 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
11035 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
11036
11037 if (isCallValid)
11038 {
11039 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11040 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
11041 CaptureWeightPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
11042 &pointerParam);
11043 paramBuffer.addParam(std::move(pointerParam));
11044 }
11045 else
11046 {
11047 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11048 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11049 &pointerParam.value);
11050 paramBuffer.addParam(std::move(pointerParam));
11051 }
11052
11053 return CallCapture(angle::EntryPoint::GLWeightPointerOES, std::move(paramBuffer));
11054 }
11055
CapturePointSizePointerOES(const State & glState,bool isCallValid,VertexAttribType typePacked,GLsizei stride,const void * pointer)11056 CallCapture CapturePointSizePointerOES(const State &glState,
11057 bool isCallValid,
11058 VertexAttribType typePacked,
11059 GLsizei stride,
11060 const void *pointer)
11061 {
11062 ParamBuffer paramBuffer;
11063
11064 paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
11065 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
11066
11067 if (isCallValid)
11068 {
11069 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11070 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
11071 CapturePointSizePointerOES_pointer(glState, isCallValid, typePacked, stride, pointer,
11072 &pointerParam);
11073 paramBuffer.addParam(std::move(pointerParam));
11074 }
11075 else
11076 {
11077 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11078 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11079 &pointerParam.value);
11080 paramBuffer.addParam(std::move(pointerParam));
11081 }
11082
11083 return CallCapture(angle::EntryPoint::GLPointSizePointerOES, std::move(paramBuffer));
11084 }
11085
CapturePrimitiveBoundingBoxOES(const State & glState,bool isCallValid,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)11086 CallCapture CapturePrimitiveBoundingBoxOES(const State &glState,
11087 bool isCallValid,
11088 GLfloat minX,
11089 GLfloat minY,
11090 GLfloat minZ,
11091 GLfloat minW,
11092 GLfloat maxX,
11093 GLfloat maxY,
11094 GLfloat maxZ,
11095 GLfloat maxW)
11096 {
11097 ParamBuffer paramBuffer;
11098
11099 paramBuffer.addValueParam("minX", ParamType::TGLfloat, minX);
11100 paramBuffer.addValueParam("minY", ParamType::TGLfloat, minY);
11101 paramBuffer.addValueParam("minZ", ParamType::TGLfloat, minZ);
11102 paramBuffer.addValueParam("minW", ParamType::TGLfloat, minW);
11103 paramBuffer.addValueParam("maxX", ParamType::TGLfloat, maxX);
11104 paramBuffer.addValueParam("maxY", ParamType::TGLfloat, maxY);
11105 paramBuffer.addValueParam("maxZ", ParamType::TGLfloat, maxZ);
11106 paramBuffer.addValueParam("maxW", ParamType::TGLfloat, maxW);
11107
11108 return CallCapture(angle::EntryPoint::GLPrimitiveBoundingBoxOES, std::move(paramBuffer));
11109 }
11110
CaptureQueryMatrixxOES(const State & glState,bool isCallValid,GLfixed * mantissa,GLint * exponent,GLbitfield returnValue)11111 CallCapture CaptureQueryMatrixxOES(const State &glState,
11112 bool isCallValid,
11113 GLfixed *mantissa,
11114 GLint *exponent,
11115 GLbitfield returnValue)
11116 {
11117 ParamBuffer paramBuffer;
11118
11119 if (isCallValid)
11120 {
11121 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
11122 InitParamValue(ParamType::TGLfixedPointer, mantissa, &mantissaParam.value);
11123 CaptureQueryMatrixxOES_mantissa(glState, isCallValid, mantissa, exponent, &mantissaParam);
11124 paramBuffer.addParam(std::move(mantissaParam));
11125 }
11126 else
11127 {
11128 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
11129 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
11130 &mantissaParam.value);
11131 paramBuffer.addParam(std::move(mantissaParam));
11132 }
11133
11134 if (isCallValid)
11135 {
11136 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
11137 InitParamValue(ParamType::TGLintPointer, exponent, &exponentParam.value);
11138 CaptureQueryMatrixxOES_exponent(glState, isCallValid, mantissa, exponent, &exponentParam);
11139 paramBuffer.addParam(std::move(exponentParam));
11140 }
11141 else
11142 {
11143 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
11144 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
11145 &exponentParam.value);
11146 paramBuffer.addParam(std::move(exponentParam));
11147 }
11148
11149 ParamCapture returnValueCapture("returnValue", ParamType::TGLbitfield);
11150 InitParamValue(ParamType::TGLbitfield, returnValue, &returnValueCapture.value);
11151 paramBuffer.addReturnValue(std::move(returnValueCapture));
11152
11153 return CallCapture(angle::EntryPoint::GLQueryMatrixxOES, std::move(paramBuffer));
11154 }
11155
CaptureMinSampleShadingOES(const State & glState,bool isCallValid,GLfloat value)11156 CallCapture CaptureMinSampleShadingOES(const State &glState, bool isCallValid, GLfloat value)
11157 {
11158 ParamBuffer paramBuffer;
11159
11160 paramBuffer.addValueParam("value", ParamType::TGLfloat, value);
11161
11162 return CallCapture(angle::EntryPoint::GLMinSampleShadingOES, std::move(paramBuffer));
11163 }
11164
CapturePatchParameteriOES(const State & glState,bool isCallValid,GLenum pname,GLint value)11165 CallCapture CapturePatchParameteriOES(const State &glState,
11166 bool isCallValid,
11167 GLenum pname,
11168 GLint value)
11169 {
11170 ParamBuffer paramBuffer;
11171
11172 paramBuffer.addEnumParam("pname", GLESEnum::PatchParameterName, ParamType::TGLenum, pname);
11173 paramBuffer.addValueParam("value", ParamType::TGLint, value);
11174
11175 return CallCapture(angle::EntryPoint::GLPatchParameteriOES, std::move(paramBuffer));
11176 }
11177
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)11178 CallCapture CaptureCompressedTexImage3DOES(const State &glState,
11179 bool isCallValid,
11180 TextureTarget targetPacked,
11181 GLint level,
11182 GLenum internalformat,
11183 GLsizei width,
11184 GLsizei height,
11185 GLsizei depth,
11186 GLint border,
11187 GLsizei imageSize,
11188 const void *data)
11189 {
11190 ParamBuffer paramBuffer;
11191
11192 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11193 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11194 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11195 internalformat);
11196 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11197 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11198 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11199 paramBuffer.addValueParam("border", ParamType::TGLint, border);
11200 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
11201
11202 if (isCallValid)
11203 {
11204 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11205 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
11206 CaptureCompressedTexImage3DOES_data(glState, isCallValid, targetPacked, level,
11207 internalformat, width, height, depth, border, imageSize,
11208 data, &dataParam);
11209 paramBuffer.addParam(std::move(dataParam));
11210 }
11211 else
11212 {
11213 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11214 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11215 &dataParam.value);
11216 paramBuffer.addParam(std::move(dataParam));
11217 }
11218
11219 return CallCapture(angle::EntryPoint::GLCompressedTexImage3DOES, std::move(paramBuffer));
11220 }
11221
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)11222 CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
11223 bool isCallValid,
11224 TextureTarget targetPacked,
11225 GLint level,
11226 GLint xoffset,
11227 GLint yoffset,
11228 GLint zoffset,
11229 GLsizei width,
11230 GLsizei height,
11231 GLsizei depth,
11232 GLenum format,
11233 GLsizei imageSize,
11234 const void *data)
11235 {
11236 ParamBuffer paramBuffer;
11237
11238 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11239 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11240 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11241 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11242 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11243 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11244 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11245 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11246 paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format);
11247 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
11248
11249 if (isCallValid)
11250 {
11251 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11252 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
11253 CaptureCompressedTexSubImage3DOES_data(glState, isCallValid, targetPacked, level, xoffset,
11254 yoffset, zoffset, width, height, depth, format,
11255 imageSize, data, &dataParam);
11256 paramBuffer.addParam(std::move(dataParam));
11257 }
11258 else
11259 {
11260 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11261 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11262 &dataParam.value);
11263 paramBuffer.addParam(std::move(dataParam));
11264 }
11265
11266 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage3DOES, std::move(paramBuffer));
11267 }
11268
CaptureCopyTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)11269 CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
11270 bool isCallValid,
11271 TextureTarget targetPacked,
11272 GLint level,
11273 GLint xoffset,
11274 GLint yoffset,
11275 GLint zoffset,
11276 GLint x,
11277 GLint y,
11278 GLsizei width,
11279 GLsizei height)
11280 {
11281 ParamBuffer paramBuffer;
11282
11283 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11284 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11285 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11286 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11287 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11288 paramBuffer.addValueParam("x", ParamType::TGLint, x);
11289 paramBuffer.addValueParam("y", ParamType::TGLint, y);
11290 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11291 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11292
11293 return CallCapture(angle::EntryPoint::GLCopyTexSubImage3DOES, std::move(paramBuffer));
11294 }
11295
CaptureFramebufferTexture3DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLint zoffset)11296 CallCapture CaptureFramebufferTexture3DOES(const State &glState,
11297 bool isCallValid,
11298 GLenum target,
11299 GLenum attachment,
11300 TextureTarget textargetPacked,
11301 TextureID texturePacked,
11302 GLint level,
11303 GLint zoffset)
11304 {
11305 ParamBuffer paramBuffer;
11306
11307 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
11308 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
11309 attachment);
11310 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
11311 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
11312 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11313 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11314
11315 return CallCapture(angle::EntryPoint::GLFramebufferTexture3DOES, std::move(paramBuffer));
11316 }
11317
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)11318 CallCapture CaptureTexImage3DOES(const State &glState,
11319 bool isCallValid,
11320 TextureTarget targetPacked,
11321 GLint level,
11322 GLenum internalformat,
11323 GLsizei width,
11324 GLsizei height,
11325 GLsizei depth,
11326 GLint border,
11327 GLenum format,
11328 GLenum type,
11329 const void *pixels)
11330 {
11331 ParamBuffer paramBuffer;
11332
11333 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11334 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11335 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11336 internalformat);
11337 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11338 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11339 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11340 paramBuffer.addValueParam("border", ParamType::TGLint, border);
11341 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
11342 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
11343
11344 if (isCallValid)
11345 {
11346 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11347 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
11348 CaptureTexImage3DOES_pixels(glState, isCallValid, targetPacked, level, internalformat,
11349 width, height, depth, border, format, type, pixels,
11350 &pixelsParam);
11351 paramBuffer.addParam(std::move(pixelsParam));
11352 }
11353 else
11354 {
11355 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11356 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11357 &pixelsParam.value);
11358 paramBuffer.addParam(std::move(pixelsParam));
11359 }
11360
11361 return CallCapture(angle::EntryPoint::GLTexImage3DOES, std::move(paramBuffer));
11362 }
11363
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)11364 CallCapture CaptureTexSubImage3DOES(const State &glState,
11365 bool isCallValid,
11366 TextureTarget targetPacked,
11367 GLint level,
11368 GLint xoffset,
11369 GLint yoffset,
11370 GLint zoffset,
11371 GLsizei width,
11372 GLsizei height,
11373 GLsizei depth,
11374 GLenum format,
11375 GLenum type,
11376 const void *pixels)
11377 {
11378 ParamBuffer paramBuffer;
11379
11380 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11381 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11382 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11383 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11384 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11385 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11386 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11387 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11388 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
11389 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
11390
11391 if (isCallValid)
11392 {
11393 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11394 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
11395 CaptureTexSubImage3DOES_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
11396 zoffset, width, height, depth, format, type, pixels,
11397 &pixelsParam);
11398 paramBuffer.addParam(std::move(pixelsParam));
11399 }
11400 else
11401 {
11402 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11403 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11404 &pixelsParam.value);
11405 paramBuffer.addParam(std::move(pixelsParam));
11406 }
11407
11408 return CallCapture(angle::EntryPoint::GLTexSubImage3DOES, std::move(paramBuffer));
11409 }
11410
CaptureGetSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)11411 CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
11412 bool isCallValid,
11413 SamplerID samplerPacked,
11414 GLenum pname,
11415 GLint *params)
11416 {
11417 ParamBuffer paramBuffer;
11418
11419 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11420 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11421
11422 if (isCallValid)
11423 {
11424 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11425 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11426 CaptureGetSamplerParameterIivOES_params(glState, isCallValid, samplerPacked, pname, params,
11427 ¶msParam);
11428 paramBuffer.addParam(std::move(paramsParam));
11429 }
11430 else
11431 {
11432 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11433 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11434 paramBuffer.addParam(std::move(paramsParam));
11435 }
11436
11437 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivOES, std::move(paramBuffer));
11438 }
11439
CaptureGetSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)11440 CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
11441 bool isCallValid,
11442 SamplerID samplerPacked,
11443 GLenum pname,
11444 GLuint *params)
11445 {
11446 ParamBuffer paramBuffer;
11447
11448 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11449 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11450
11451 if (isCallValid)
11452 {
11453 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11454 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
11455 CaptureGetSamplerParameterIuivOES_params(glState, isCallValid, samplerPacked, pname, params,
11456 ¶msParam);
11457 paramBuffer.addParam(std::move(paramsParam));
11458 }
11459 else
11460 {
11461 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11462 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
11463 ¶msParam.value);
11464 paramBuffer.addParam(std::move(paramsParam));
11465 }
11466
11467 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivOES, std::move(paramBuffer));
11468 }
11469
CaptureGetTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)11470 CallCapture CaptureGetTexParameterIivOES(const State &glState,
11471 bool isCallValid,
11472 TextureType targetPacked,
11473 GLenum pname,
11474 GLint *params)
11475 {
11476 ParamBuffer paramBuffer;
11477
11478 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11479 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
11480
11481 if (isCallValid)
11482 {
11483 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11484 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11485 CaptureGetTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
11486 ¶msParam);
11487 paramBuffer.addParam(std::move(paramsParam));
11488 }
11489 else
11490 {
11491 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11492 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11493 paramBuffer.addParam(std::move(paramsParam));
11494 }
11495
11496 return CallCapture(angle::EntryPoint::GLGetTexParameterIivOES, std::move(paramBuffer));
11497 }
11498
CaptureGetTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)11499 CallCapture CaptureGetTexParameterIuivOES(const State &glState,
11500 bool isCallValid,
11501 TextureType targetPacked,
11502 GLenum pname,
11503 GLuint *params)
11504 {
11505 ParamBuffer paramBuffer;
11506
11507 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11508 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
11509
11510 if (isCallValid)
11511 {
11512 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11513 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
11514 CaptureGetTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
11515 ¶msParam);
11516 paramBuffer.addParam(std::move(paramsParam));
11517 }
11518 else
11519 {
11520 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11521 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
11522 ¶msParam.value);
11523 paramBuffer.addParam(std::move(paramsParam));
11524 }
11525
11526 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivOES, std::move(paramBuffer));
11527 }
11528
CaptureSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)11529 CallCapture CaptureSamplerParameterIivOES(const State &glState,
11530 bool isCallValid,
11531 SamplerID samplerPacked,
11532 GLenum pname,
11533 const GLint *param)
11534 {
11535 ParamBuffer paramBuffer;
11536
11537 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11538 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11539
11540 if (isCallValid)
11541 {
11542 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
11543 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
11544 CaptureSamplerParameterIivOES_param(glState, isCallValid, samplerPacked, pname, param,
11545 ¶mParam);
11546 paramBuffer.addParam(std::move(paramParam));
11547 }
11548 else
11549 {
11550 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
11551 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11552 ¶mParam.value);
11553 paramBuffer.addParam(std::move(paramParam));
11554 }
11555
11556 return CallCapture(angle::EntryPoint::GLSamplerParameterIivOES, std::move(paramBuffer));
11557 }
11558
CaptureSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)11559 CallCapture CaptureSamplerParameterIuivOES(const State &glState,
11560 bool isCallValid,
11561 SamplerID samplerPacked,
11562 GLenum pname,
11563 const GLuint *param)
11564 {
11565 ParamBuffer paramBuffer;
11566
11567 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11568 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11569
11570 if (isCallValid)
11571 {
11572 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
11573 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
11574 CaptureSamplerParameterIuivOES_param(glState, isCallValid, samplerPacked, pname, param,
11575 ¶mParam);
11576 paramBuffer.addParam(std::move(paramParam));
11577 }
11578 else
11579 {
11580 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
11581 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
11582 ¶mParam.value);
11583 paramBuffer.addParam(std::move(paramParam));
11584 }
11585
11586 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivOES, std::move(paramBuffer));
11587 }
11588
CaptureTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)11589 CallCapture CaptureTexParameterIivOES(const State &glState,
11590 bool isCallValid,
11591 TextureType targetPacked,
11592 GLenum pname,
11593 const GLint *params)
11594 {
11595 ParamBuffer paramBuffer;
11596
11597 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11598 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
11599
11600 if (isCallValid)
11601 {
11602 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11603 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
11604 CaptureTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
11605 ¶msParam);
11606 paramBuffer.addParam(std::move(paramsParam));
11607 }
11608 else
11609 {
11610 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11611 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11612 ¶msParam.value);
11613 paramBuffer.addParam(std::move(paramsParam));
11614 }
11615
11616 return CallCapture(angle::EntryPoint::GLTexParameterIivOES, std::move(paramBuffer));
11617 }
11618
CaptureTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)11619 CallCapture CaptureTexParameterIuivOES(const State &glState,
11620 bool isCallValid,
11621 TextureType targetPacked,
11622 GLenum pname,
11623 const GLuint *params)
11624 {
11625 ParamBuffer paramBuffer;
11626
11627 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11628 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
11629
11630 if (isCallValid)
11631 {
11632 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
11633 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
11634 CaptureTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
11635 ¶msParam);
11636 paramBuffer.addParam(std::move(paramsParam));
11637 }
11638 else
11639 {
11640 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
11641 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
11642 ¶msParam.value);
11643 paramBuffer.addParam(std::move(paramsParam));
11644 }
11645
11646 return CallCapture(angle::EntryPoint::GLTexParameterIuivOES, std::move(paramBuffer));
11647 }
11648
CaptureTexBufferOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)11649 CallCapture CaptureTexBufferOES(const State &glState,
11650 bool isCallValid,
11651 TextureType targetPacked,
11652 GLenum internalformat,
11653 BufferID bufferPacked)
11654 {
11655 ParamBuffer paramBuffer;
11656
11657 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11658 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11659 internalformat);
11660 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
11661
11662 return CallCapture(angle::EntryPoint::GLTexBufferOES, std::move(paramBuffer));
11663 }
11664
CaptureTexBufferRangeOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)11665 CallCapture CaptureTexBufferRangeOES(const State &glState,
11666 bool isCallValid,
11667 TextureType targetPacked,
11668 GLenum internalformat,
11669 BufferID bufferPacked,
11670 GLintptr offset,
11671 GLsizeiptr size)
11672 {
11673 ParamBuffer paramBuffer;
11674
11675 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11676 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11677 internalformat);
11678 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
11679 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
11680 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
11681
11682 return CallCapture(angle::EntryPoint::GLTexBufferRangeOES, std::move(paramBuffer));
11683 }
11684
CaptureGetTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat * params)11685 CallCapture CaptureGetTexGenfvOES(const State &glState,
11686 bool isCallValid,
11687 GLenum coord,
11688 GLenum pname,
11689 GLfloat *params)
11690 {
11691 ParamBuffer paramBuffer;
11692
11693 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11694 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11695
11696 if (isCallValid)
11697 {
11698 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
11699 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
11700 CaptureGetTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11701 paramBuffer.addParam(std::move(paramsParam));
11702 }
11703 else
11704 {
11705 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
11706 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
11707 ¶msParam.value);
11708 paramBuffer.addParam(std::move(paramsParam));
11709 }
11710
11711 return CallCapture(angle::EntryPoint::GLGetTexGenfvOES, std::move(paramBuffer));
11712 }
11713
CaptureGetTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint * params)11714 CallCapture CaptureGetTexGenivOES(const State &glState,
11715 bool isCallValid,
11716 GLenum coord,
11717 GLenum pname,
11718 GLint *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::TGLintPointer);
11728 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11729 CaptureGetTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11730 paramBuffer.addParam(std::move(paramsParam));
11731 }
11732 else
11733 {
11734 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11735 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11736 paramBuffer.addParam(std::move(paramsParam));
11737 }
11738
11739 return CallCapture(angle::EntryPoint::GLGetTexGenivOES, std::move(paramBuffer));
11740 }
11741
CaptureGetTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed * params)11742 CallCapture CaptureGetTexGenxvOES(const State &glState,
11743 bool isCallValid,
11744 GLenum coord,
11745 GLenum pname,
11746 GLfixed *params)
11747 {
11748 ParamBuffer paramBuffer;
11749
11750 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11751 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11752
11753 if (isCallValid)
11754 {
11755 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
11756 InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value);
11757 CaptureGetTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11758 paramBuffer.addParam(std::move(paramsParam));
11759 }
11760 else
11761 {
11762 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
11763 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
11764 ¶msParam.value);
11765 paramBuffer.addParam(std::move(paramsParam));
11766 }
11767
11768 return CallCapture(angle::EntryPoint::GLGetTexGenxvOES, std::move(paramBuffer));
11769 }
11770
CaptureTexGenfOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat param)11771 CallCapture CaptureTexGenfOES(const State &glState,
11772 bool isCallValid,
11773 GLenum coord,
11774 GLenum pname,
11775 GLfloat param)
11776 {
11777 ParamBuffer paramBuffer;
11778
11779 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11780 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11781 paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
11782
11783 return CallCapture(angle::EntryPoint::GLTexGenfOES, std::move(paramBuffer));
11784 }
11785
CaptureTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfloat * params)11786 CallCapture CaptureTexGenfvOES(const State &glState,
11787 bool isCallValid,
11788 GLenum coord,
11789 GLenum pname,
11790 const GLfloat *params)
11791 {
11792 ParamBuffer paramBuffer;
11793
11794 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11795 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11796
11797 if (isCallValid)
11798 {
11799 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
11800 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
11801 CaptureTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11802 paramBuffer.addParam(std::move(paramsParam));
11803 }
11804 else
11805 {
11806 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
11807 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
11808 ¶msParam.value);
11809 paramBuffer.addParam(std::move(paramsParam));
11810 }
11811
11812 return CallCapture(angle::EntryPoint::GLTexGenfvOES, std::move(paramBuffer));
11813 }
11814
CaptureTexGeniOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint param)11815 CallCapture CaptureTexGeniOES(const State &glState,
11816 bool isCallValid,
11817 GLenum coord,
11818 GLenum pname,
11819 GLint param)
11820 {
11821 ParamBuffer paramBuffer;
11822
11823 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11824 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11825 paramBuffer.addValueParam("param", ParamType::TGLint, param);
11826
11827 return CallCapture(angle::EntryPoint::GLTexGeniOES, std::move(paramBuffer));
11828 }
11829
CaptureTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLint * params)11830 CallCapture CaptureTexGenivOES(const State &glState,
11831 bool isCallValid,
11832 GLenum coord,
11833 GLenum pname,
11834 const GLint *params)
11835 {
11836 ParamBuffer paramBuffer;
11837
11838 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11839 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11840
11841 if (isCallValid)
11842 {
11843 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11844 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
11845 CaptureTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11846 paramBuffer.addParam(std::move(paramsParam));
11847 }
11848 else
11849 {
11850 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11851 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11852 ¶msParam.value);
11853 paramBuffer.addParam(std::move(paramsParam));
11854 }
11855
11856 return CallCapture(angle::EntryPoint::GLTexGenivOES, std::move(paramBuffer));
11857 }
11858
CaptureTexGenxOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed param)11859 CallCapture CaptureTexGenxOES(const State &glState,
11860 bool isCallValid,
11861 GLenum coord,
11862 GLenum pname,
11863 GLfixed param)
11864 {
11865 ParamBuffer paramBuffer;
11866
11867 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11868 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11869 paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
11870
11871 return CallCapture(angle::EntryPoint::GLTexGenxOES, std::move(paramBuffer));
11872 }
11873
CaptureTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfixed * params)11874 CallCapture CaptureTexGenxvOES(const State &glState,
11875 bool isCallValid,
11876 GLenum coord,
11877 GLenum pname,
11878 const GLfixed *params)
11879 {
11880 ParamBuffer paramBuffer;
11881
11882 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11883 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11884
11885 if (isCallValid)
11886 {
11887 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
11888 InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value);
11889 CaptureTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11890 paramBuffer.addParam(std::move(paramsParam));
11891 }
11892 else
11893 {
11894 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
11895 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
11896 ¶msParam.value);
11897 paramBuffer.addParam(std::move(paramsParam));
11898 }
11899
11900 return CallCapture(angle::EntryPoint::GLTexGenxvOES, std::move(paramBuffer));
11901 }
11902
CaptureTexStorage3DMultisampleOES(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)11903 CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
11904 bool isCallValid,
11905 TextureType targetPacked,
11906 GLsizei samples,
11907 GLenum internalformat,
11908 GLsizei width,
11909 GLsizei height,
11910 GLsizei depth,
11911 GLboolean fixedsamplelocations)
11912 {
11913 ParamBuffer paramBuffer;
11914
11915 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11916 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
11917 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11918 internalformat);
11919 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11920 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11921 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11922 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
11923
11924 return CallCapture(angle::EntryPoint::GLTexStorage3DMultisampleOES, std::move(paramBuffer));
11925 }
11926
CaptureBindVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked)11927 CallCapture CaptureBindVertexArrayOES(const State &glState,
11928 bool isCallValid,
11929 VertexArrayID arrayPacked)
11930 {
11931 ParamBuffer paramBuffer;
11932
11933 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
11934
11935 return CallCapture(angle::EntryPoint::GLBindVertexArrayOES, std::move(paramBuffer));
11936 }
11937
CaptureDeleteVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,const VertexArrayID * arraysPacked)11938 CallCapture CaptureDeleteVertexArraysOES(const State &glState,
11939 bool isCallValid,
11940 GLsizei n,
11941 const VertexArrayID *arraysPacked)
11942 {
11943 ParamBuffer paramBuffer;
11944
11945 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
11946
11947 if (isCallValid)
11948 {
11949 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
11950 InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked,
11951 &arraysPackedParam.value);
11952 CaptureDeleteVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
11953 &arraysPackedParam);
11954 paramBuffer.addParam(std::move(arraysPackedParam));
11955 }
11956 else
11957 {
11958 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
11959 InitParamValue(ParamType::TVertexArrayIDConstPointer,
11960 static_cast<const VertexArrayID *>(nullptr), &arraysPackedParam.value);
11961 paramBuffer.addParam(std::move(arraysPackedParam));
11962 }
11963
11964 return CallCapture(angle::EntryPoint::GLDeleteVertexArraysOES, std::move(paramBuffer));
11965 }
11966
CaptureGenVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,VertexArrayID * arraysPacked)11967 CallCapture CaptureGenVertexArraysOES(const State &glState,
11968 bool isCallValid,
11969 GLsizei n,
11970 VertexArrayID *arraysPacked)
11971 {
11972 ParamBuffer paramBuffer;
11973
11974 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
11975
11976 if (isCallValid)
11977 {
11978 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
11979 InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
11980 CaptureGenVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
11981 &arraysPackedParam);
11982 paramBuffer.addParam(std::move(arraysPackedParam));
11983 }
11984 else
11985 {
11986 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
11987 InitParamValue(ParamType::TVertexArrayIDPointer, static_cast<VertexArrayID *>(nullptr),
11988 &arraysPackedParam.value);
11989 paramBuffer.addParam(std::move(arraysPackedParam));
11990 }
11991
11992 return CallCapture(angle::EntryPoint::GLGenVertexArraysOES, std::move(paramBuffer));
11993 }
11994
CaptureIsVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked,GLboolean returnValue)11995 CallCapture CaptureIsVertexArrayOES(const State &glState,
11996 bool isCallValid,
11997 VertexArrayID arrayPacked,
11998 GLboolean returnValue)
11999 {
12000 ParamBuffer paramBuffer;
12001
12002 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
12003
12004 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
12005 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
12006 paramBuffer.addReturnValue(std::move(returnValueCapture));
12007
12008 return CallCapture(angle::EntryPoint::GLIsVertexArrayOES, std::move(paramBuffer));
12009 }
12010
CaptureFramebufferTextureMultiviewOVR(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level,GLint baseViewIndex,GLsizei numViews)12011 CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
12012 bool isCallValid,
12013 GLenum target,
12014 GLenum attachment,
12015 TextureID texturePacked,
12016 GLint level,
12017 GLint baseViewIndex,
12018 GLsizei numViews)
12019 {
12020 ParamBuffer paramBuffer;
12021
12022 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
12023 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
12024 attachment);
12025 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
12026 paramBuffer.addValueParam("level", ParamType::TGLint, level);
12027 paramBuffer.addValueParam("baseViewIndex", ParamType::TGLint, baseViewIndex);
12028 paramBuffer.addValueParam("numViews", ParamType::TGLsizei, numViews);
12029
12030 return CallCapture(angle::EntryPoint::GLFramebufferTextureMultiviewOVR, std::move(paramBuffer));
12031 }
12032
CaptureFramebufferFoveationConfigQCOM(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLuint numLayers,GLuint focalPointsPerLayer,GLuint requestedFeatures,GLuint * providedFeatures)12033 CallCapture CaptureFramebufferFoveationConfigQCOM(const State &glState,
12034 bool isCallValid,
12035 FramebufferID framebufferPacked,
12036 GLuint numLayers,
12037 GLuint focalPointsPerLayer,
12038 GLuint requestedFeatures,
12039 GLuint *providedFeatures)
12040 {
12041 ParamBuffer paramBuffer;
12042
12043 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
12044 paramBuffer.addValueParam("numLayers", ParamType::TGLuint, numLayers);
12045 paramBuffer.addValueParam("focalPointsPerLayer", ParamType::TGLuint, focalPointsPerLayer);
12046 paramBuffer.addValueParam("requestedFeatures", ParamType::TGLuint, requestedFeatures);
12047
12048 if (isCallValid)
12049 {
12050 ParamCapture providedFeaturesParam("providedFeatures", ParamType::TGLuintPointer);
12051 InitParamValue(ParamType::TGLuintPointer, providedFeatures, &providedFeaturesParam.value);
12052 CaptureFramebufferFoveationConfigQCOM_providedFeatures(
12053 glState, isCallValid, framebufferPacked, numLayers, focalPointsPerLayer,
12054 requestedFeatures, providedFeatures, &providedFeaturesParam);
12055 paramBuffer.addParam(std::move(providedFeaturesParam));
12056 }
12057 else
12058 {
12059 ParamCapture providedFeaturesParam("providedFeatures", ParamType::TGLuintPointer);
12060 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
12061 &providedFeaturesParam.value);
12062 paramBuffer.addParam(std::move(providedFeaturesParam));
12063 }
12064
12065 return CallCapture(angle::EntryPoint::GLFramebufferFoveationConfigQCOM, std::move(paramBuffer));
12066 }
12067
CaptureFramebufferFoveationParametersQCOM(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLuint layer,GLuint focalPoint,GLfloat focalX,GLfloat focalY,GLfloat gainX,GLfloat gainY,GLfloat foveaArea)12068 CallCapture CaptureFramebufferFoveationParametersQCOM(const State &glState,
12069 bool isCallValid,
12070 FramebufferID framebufferPacked,
12071 GLuint layer,
12072 GLuint focalPoint,
12073 GLfloat focalX,
12074 GLfloat focalY,
12075 GLfloat gainX,
12076 GLfloat gainY,
12077 GLfloat foveaArea)
12078 {
12079 ParamBuffer paramBuffer;
12080
12081 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
12082 paramBuffer.addValueParam("layer", ParamType::TGLuint, layer);
12083 paramBuffer.addValueParam("focalPoint", ParamType::TGLuint, focalPoint);
12084 paramBuffer.addValueParam("focalX", ParamType::TGLfloat, focalX);
12085 paramBuffer.addValueParam("focalY", ParamType::TGLfloat, focalY);
12086 paramBuffer.addValueParam("gainX", ParamType::TGLfloat, gainX);
12087 paramBuffer.addValueParam("gainY", ParamType::TGLfloat, gainY);
12088 paramBuffer.addValueParam("foveaArea", ParamType::TGLfloat, foveaArea);
12089
12090 return CallCapture(angle::EntryPoint::GLFramebufferFoveationParametersQCOM,
12091 std::move(paramBuffer));
12092 }
12093
CaptureShadingRateQCOM(const State & glState,bool isCallValid,GLenum rate)12094 CallCapture CaptureShadingRateQCOM(const State &glState, bool isCallValid, GLenum rate)
12095 {
12096 ParamBuffer paramBuffer;
12097
12098 paramBuffer.addEnumParam("rate", GLESEnum::ShadingRateQCOM, ParamType::TGLenum, rate);
12099
12100 return CallCapture(angle::EntryPoint::GLShadingRateQCOM, std::move(paramBuffer));
12101 }
12102
CaptureTextureFoveationParametersQCOM(const State & glState,bool isCallValid,TextureID texturePacked,GLuint layer,GLuint focalPoint,GLfloat focalX,GLfloat focalY,GLfloat gainX,GLfloat gainY,GLfloat foveaArea)12103 CallCapture CaptureTextureFoveationParametersQCOM(const State &glState,
12104 bool isCallValid,
12105 TextureID texturePacked,
12106 GLuint layer,
12107 GLuint focalPoint,
12108 GLfloat focalX,
12109 GLfloat focalY,
12110 GLfloat gainX,
12111 GLfloat gainY,
12112 GLfloat foveaArea)
12113 {
12114 ParamBuffer paramBuffer;
12115
12116 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
12117 paramBuffer.addValueParam("layer", ParamType::TGLuint, layer);
12118 paramBuffer.addValueParam("focalPoint", ParamType::TGLuint, focalPoint);
12119 paramBuffer.addValueParam("focalX", ParamType::TGLfloat, focalX);
12120 paramBuffer.addValueParam("focalY", ParamType::TGLfloat, focalY);
12121 paramBuffer.addValueParam("gainX", ParamType::TGLfloat, gainX);
12122 paramBuffer.addValueParam("gainY", ParamType::TGLfloat, gainY);
12123 paramBuffer.addValueParam("foveaArea", ParamType::TGLfloat, foveaArea);
12124
12125 return CallCapture(angle::EntryPoint::GLTextureFoveationParametersQCOM, std::move(paramBuffer));
12126 }
12127
12128 } // namespace gl
12129