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
CaptureBlobCacheCallbacksANGLE(const State & glState,bool isCallValid,GLSETBLOBPROCANGLE set,GLGETBLOBPROCANGLE get,const void * userParam)675 CallCapture CaptureBlobCacheCallbacksANGLE(const State &glState,
676 bool isCallValid,
677 GLSETBLOBPROCANGLE set,
678 GLGETBLOBPROCANGLE get,
679 const void *userParam)
680 {
681 ParamBuffer paramBuffer;
682
683 paramBuffer.addValueParam("set", ParamType::TGLSETBLOBPROCANGLE, set);
684 paramBuffer.addValueParam("get", ParamType::TGLGETBLOBPROCANGLE, get);
685
686 if (isCallValid)
687 {
688 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
689 InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
690 CaptureBlobCacheCallbacksANGLE_userParam(glState, isCallValid, set, get, userParam,
691 &userParamParam);
692 paramBuffer.addParam(std::move(userParamParam));
693 }
694 else
695 {
696 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
697 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
698 &userParamParam.value);
699 paramBuffer.addParam(std::move(userParamParam));
700 }
701
702 return CallCapture(angle::EntryPoint::GLBlobCacheCallbacksANGLE, std::move(paramBuffer));
703 }
704
CaptureGetPointervANGLE(const State & glState,bool isCallValid,GLenum pname,void ** params)705 CallCapture CaptureGetPointervANGLE(const State &glState,
706 bool isCallValid,
707 GLenum pname,
708 void **params)
709 {
710 ParamBuffer paramBuffer;
711
712 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
713
714 if (isCallValid)
715 {
716 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
717 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
718 CaptureGetPointervANGLE_params(glState, isCallValid, pname, params, ¶msParam);
719 paramBuffer.addParam(std::move(paramsParam));
720 }
721 else
722 {
723 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
724 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
725 ¶msParam.value);
726 paramBuffer.addParam(std::move(paramsParam));
727 }
728
729 return CallCapture(angle::EntryPoint::GLGetPointervANGLE, std::move(paramBuffer));
730 }
731
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)732 CallCapture CaptureCopyTexture3DANGLE(const State &glState,
733 bool isCallValid,
734 TextureID sourceIdPacked,
735 GLint sourceLevel,
736 TextureTarget destTargetPacked,
737 TextureID destIdPacked,
738 GLint destLevel,
739 GLint internalFormat,
740 GLenum destType,
741 GLboolean unpackFlipY,
742 GLboolean unpackPremultiplyAlpha,
743 GLboolean unpackUnmultiplyAlpha)
744 {
745 ParamBuffer paramBuffer;
746
747 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
748 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
749 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
750 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
751 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
752 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
753 paramBuffer.addEnumParam("destType", GLESEnum::AllEnums, ParamType::TGLenum, destType);
754 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
755 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
756 unpackPremultiplyAlpha);
757 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
758 unpackUnmultiplyAlpha);
759
760 return CallCapture(angle::EntryPoint::GLCopyTexture3DANGLE, std::move(paramBuffer));
761 }
762
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)763 CallCapture CaptureCopySubTexture3DANGLE(const State &glState,
764 bool isCallValid,
765 TextureID sourceIdPacked,
766 GLint sourceLevel,
767 TextureTarget destTargetPacked,
768 TextureID destIdPacked,
769 GLint destLevel,
770 GLint xoffset,
771 GLint yoffset,
772 GLint zoffset,
773 GLint x,
774 GLint y,
775 GLint z,
776 GLint width,
777 GLint height,
778 GLint depth,
779 GLboolean unpackFlipY,
780 GLboolean unpackPremultiplyAlpha,
781 GLboolean unpackUnmultiplyAlpha)
782 {
783 ParamBuffer paramBuffer;
784
785 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
786 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
787 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
788 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
789 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
790 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
791 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
792 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
793 paramBuffer.addValueParam("x", ParamType::TGLint, x);
794 paramBuffer.addValueParam("y", ParamType::TGLint, y);
795 paramBuffer.addValueParam("z", ParamType::TGLint, z);
796 paramBuffer.addValueParam("width", ParamType::TGLint, width);
797 paramBuffer.addValueParam("height", ParamType::TGLint, height);
798 paramBuffer.addValueParam("depth", ParamType::TGLint, depth);
799 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
800 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
801 unpackPremultiplyAlpha);
802 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
803 unpackUnmultiplyAlpha);
804
805 return CallCapture(angle::EntryPoint::GLCopySubTexture3DANGLE, std::move(paramBuffer));
806 }
807
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)808 CallCapture CaptureBlitFramebufferANGLE(const State &glState,
809 bool isCallValid,
810 GLint srcX0,
811 GLint srcY0,
812 GLint srcX1,
813 GLint srcY1,
814 GLint dstX0,
815 GLint dstY0,
816 GLint dstX1,
817 GLint dstY1,
818 GLbitfield mask,
819 GLenum filter)
820 {
821 ParamBuffer paramBuffer;
822
823 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
824 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
825 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
826 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
827 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
828 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
829 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
830 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
831 paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask);
832 paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter);
833
834 return CallCapture(angle::EntryPoint::GLBlitFramebufferANGLE, std::move(paramBuffer));
835 }
836
CaptureRenderbufferStorageMultisampleANGLE(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)837 CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
838 bool isCallValid,
839 GLenum target,
840 GLsizei samples,
841 GLenum internalformat,
842 GLsizei width,
843 GLsizei height)
844 {
845 ParamBuffer paramBuffer;
846
847 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
848 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
849 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
850 internalformat);
851 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
852 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
853
854 return CallCapture(angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE,
855 std::move(paramBuffer));
856 }
857
CaptureGetTexImageANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum format,GLenum type,void * pixels)858 CallCapture CaptureGetTexImageANGLE(const State &glState,
859 bool isCallValid,
860 TextureTarget targetPacked,
861 GLint level,
862 GLenum format,
863 GLenum type,
864 void *pixels)
865 {
866 ParamBuffer paramBuffer;
867
868 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
869 paramBuffer.addValueParam("level", ParamType::TGLint, level);
870 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
871 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
872
873 if (isCallValid)
874 {
875 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
876 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
877 CaptureGetTexImageANGLE_pixels(glState, isCallValid, targetPacked, level, format, type,
878 pixels, &pixelsParam);
879 paramBuffer.addParam(std::move(pixelsParam));
880 }
881 else
882 {
883 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
884 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
885 paramBuffer.addParam(std::move(pixelsParam));
886 }
887
888 return CallCapture(angle::EntryPoint::GLGetTexImageANGLE, std::move(paramBuffer));
889 }
890
CaptureGetCompressedTexImageANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,void * pixels)891 CallCapture CaptureGetCompressedTexImageANGLE(const State &glState,
892 bool isCallValid,
893 TextureTarget targetPacked,
894 GLint level,
895 void *pixels)
896 {
897 ParamBuffer paramBuffer;
898
899 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
900 paramBuffer.addValueParam("level", ParamType::TGLint, level);
901
902 if (isCallValid)
903 {
904 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
905 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
906 CaptureGetCompressedTexImageANGLE_pixels(glState, isCallValid, targetPacked, level, pixels,
907 &pixelsParam);
908 paramBuffer.addParam(std::move(pixelsParam));
909 }
910 else
911 {
912 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
913 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
914 paramBuffer.addParam(std::move(pixelsParam));
915 }
916
917 return CallCapture(angle::EntryPoint::GLGetCompressedTexImageANGLE, std::move(paramBuffer));
918 }
919
CaptureGetRenderbufferImageANGLE(const State & glState,bool isCallValid,GLenum target,GLenum format,GLenum type,void * pixels)920 CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
921 bool isCallValid,
922 GLenum target,
923 GLenum format,
924 GLenum type,
925 void *pixels)
926 {
927 ParamBuffer paramBuffer;
928
929 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
930 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
931 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
932
933 if (isCallValid)
934 {
935 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
936 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
937 CaptureGetRenderbufferImageANGLE_pixels(glState, isCallValid, target, format, type, pixels,
938 &pixelsParam);
939 paramBuffer.addParam(std::move(pixelsParam));
940 }
941 else
942 {
943 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
944 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
945 paramBuffer.addParam(std::move(pixelsParam));
946 }
947
948 return CallCapture(angle::EntryPoint::GLGetRenderbufferImageANGLE, std::move(paramBuffer));
949 }
950
CaptureGetTexLevelParameterivANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLint * params)951 CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
952 bool isCallValid,
953 TextureTarget targetPacked,
954 GLint level,
955 GLenum pname,
956 GLint *params)
957 {
958 ParamBuffer paramBuffer;
959
960 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
961 paramBuffer.addValueParam("level", ParamType::TGLint, level);
962 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
963
964 if (isCallValid)
965 {
966 ParamCapture paramsParam("params", ParamType::TGLintPointer);
967 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
968 CaptureGetTexLevelParameterivANGLE_params(glState, isCallValid, targetPacked, level, pname,
969 params, ¶msParam);
970 paramBuffer.addParam(std::move(paramsParam));
971 }
972 else
973 {
974 ParamCapture paramsParam("params", ParamType::TGLintPointer);
975 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
976 paramBuffer.addParam(std::move(paramsParam));
977 }
978
979 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterivANGLE, std::move(paramBuffer));
980 }
981
CaptureGetTexLevelParameterfvANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLfloat * params)982 CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
983 bool isCallValid,
984 TextureTarget targetPacked,
985 GLint level,
986 GLenum pname,
987 GLfloat *params)
988 {
989 ParamBuffer paramBuffer;
990
991 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
992 paramBuffer.addValueParam("level", ParamType::TGLint, level);
993 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
994
995 if (isCallValid)
996 {
997 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
998 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
999 CaptureGetTexLevelParameterfvANGLE_params(glState, isCallValid, targetPacked, level, pname,
1000 params, ¶msParam);
1001 paramBuffer.addParam(std::move(paramsParam));
1002 }
1003 else
1004 {
1005 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1006 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1007 ¶msParam.value);
1008 paramBuffer.addParam(std::move(paramsParam));
1009 }
1010
1011 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterfvANGLE, std::move(paramBuffer));
1012 }
1013
CaptureDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei primcount)1014 CallCapture CaptureDrawArraysInstancedANGLE(const State &glState,
1015 bool isCallValid,
1016 PrimitiveMode modePacked,
1017 GLint first,
1018 GLsizei count,
1019 GLsizei primcount)
1020 {
1021 ParamBuffer paramBuffer;
1022
1023 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1024 paramBuffer.addValueParam("first", ParamType::TGLint, first);
1025 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1026 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
1027
1028 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedANGLE, std::move(paramBuffer));
1029 }
1030
CaptureDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)1031 CallCapture CaptureDrawElementsInstancedANGLE(const State &glState,
1032 bool isCallValid,
1033 PrimitiveMode modePacked,
1034 GLsizei count,
1035 DrawElementsType typePacked,
1036 const void *indices,
1037 GLsizei primcount)
1038 {
1039 ParamBuffer paramBuffer;
1040
1041 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1042 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1043 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
1044
1045 if (isCallValid)
1046 {
1047 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
1048 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
1049 CaptureDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, count,
1050 typePacked, indices, primcount, &indicesParam);
1051 paramBuffer.addParam(std::move(indicesParam));
1052 }
1053 else
1054 {
1055 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
1056 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1057 &indicesParam.value);
1058 paramBuffer.addParam(std::move(indicesParam));
1059 }
1060
1061 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
1062
1063 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedANGLE, std::move(paramBuffer));
1064 }
1065
CaptureVertexAttribDivisorANGLE(const State & glState,bool isCallValid,GLuint index,GLuint divisor)1066 CallCapture CaptureVertexAttribDivisorANGLE(const State &glState,
1067 bool isCallValid,
1068 GLuint index,
1069 GLuint divisor)
1070 {
1071 ParamBuffer paramBuffer;
1072
1073 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1074 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
1075
1076 return CallCapture(angle::EntryPoint::GLVertexAttribDivisorANGLE, std::move(paramBuffer));
1077 }
1078
CaptureLogicOpANGLE(const State & glState,bool isCallValid,LogicalOperation opcodePacked)1079 CallCapture CaptureLogicOpANGLE(const State &glState,
1080 bool isCallValid,
1081 LogicalOperation opcodePacked)
1082 {
1083 ParamBuffer paramBuffer;
1084
1085 paramBuffer.addValueParam("opcodePacked", ParamType::TLogicalOperation, opcodePacked);
1086
1087 return CallCapture(angle::EntryPoint::GLLogicOpANGLE, std::move(paramBuffer));
1088 }
1089
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)1090 CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState,
1091 bool isCallValid,
1092 TextureType targetPacked,
1093 GLsizei levels,
1094 GLenum internalFormat,
1095 GLsizei width,
1096 GLsizei height,
1097 MemoryObjectID memoryPacked,
1098 GLuint64 offset,
1099 GLbitfield createFlags,
1100 GLbitfield usageFlags,
1101 const void *imageCreateInfoPNext)
1102 {
1103 ParamBuffer paramBuffer;
1104
1105 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1106 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
1107 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1108 internalFormat);
1109 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1110 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1111 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1112 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1113 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1114 createFlags);
1115 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1116
1117 if (isCallValid)
1118 {
1119 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1120 ParamType::TvoidConstPointer);
1121 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1122 &imageCreateInfoPNextParam.value);
1123 CaptureTexStorageMemFlags2DANGLE_imageCreateInfoPNext(
1124 glState, isCallValid, targetPacked, levels, internalFormat, width, height, memoryPacked,
1125 offset, createFlags, usageFlags, imageCreateInfoPNext, &imageCreateInfoPNextParam);
1126 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1127 }
1128 else
1129 {
1130 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1131 ParamType::TvoidConstPointer);
1132 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1133 &imageCreateInfoPNextParam.value);
1134 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1135 }
1136
1137 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags2DANGLE, std::move(paramBuffer));
1138 }
1139
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)1140 CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState,
1141 bool isCallValid,
1142 TextureType targetPacked,
1143 GLsizei samples,
1144 GLenum internalFormat,
1145 GLsizei width,
1146 GLsizei height,
1147 GLboolean fixedSampleLocations,
1148 MemoryObjectID memoryPacked,
1149 GLuint64 offset,
1150 GLbitfield createFlags,
1151 GLbitfield usageFlags,
1152 const void *imageCreateInfoPNext)
1153 {
1154 ParamBuffer paramBuffer;
1155
1156 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1157 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
1158 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1159 internalFormat);
1160 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1161 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1162 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
1163 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1164 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1165 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1166 createFlags);
1167 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1168
1169 if (isCallValid)
1170 {
1171 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1172 ParamType::TvoidConstPointer);
1173 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1174 &imageCreateInfoPNextParam.value);
1175 CaptureTexStorageMemFlags2DMultisampleANGLE_imageCreateInfoPNext(
1176 glState, isCallValid, targetPacked, samples, internalFormat, width, height,
1177 fixedSampleLocations, memoryPacked, offset, createFlags, usageFlags,
1178 imageCreateInfoPNext, &imageCreateInfoPNextParam);
1179 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1180 }
1181 else
1182 {
1183 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1184 ParamType::TvoidConstPointer);
1185 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1186 &imageCreateInfoPNextParam.value);
1187 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1188 }
1189
1190 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE,
1191 std::move(paramBuffer));
1192 }
1193
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)1194 CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState,
1195 bool isCallValid,
1196 TextureType targetPacked,
1197 GLsizei levels,
1198 GLenum internalFormat,
1199 GLsizei width,
1200 GLsizei height,
1201 GLsizei depth,
1202 MemoryObjectID memoryPacked,
1203 GLuint64 offset,
1204 GLbitfield createFlags,
1205 GLbitfield usageFlags,
1206 const void *imageCreateInfoPNext)
1207 {
1208 ParamBuffer paramBuffer;
1209
1210 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1211 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
1212 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1213 internalFormat);
1214 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1215 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1216 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1217 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1218 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1219 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1220 createFlags);
1221 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1222
1223 if (isCallValid)
1224 {
1225 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1226 ParamType::TvoidConstPointer);
1227 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1228 &imageCreateInfoPNextParam.value);
1229 CaptureTexStorageMemFlags3DANGLE_imageCreateInfoPNext(
1230 glState, isCallValid, targetPacked, levels, internalFormat, width, height, depth,
1231 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext,
1232 &imageCreateInfoPNextParam);
1233 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1234 }
1235 else
1236 {
1237 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1238 ParamType::TvoidConstPointer);
1239 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1240 &imageCreateInfoPNextParam.value);
1241 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1242 }
1243
1244 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags3DANGLE, std::move(paramBuffer));
1245 }
1246
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)1247 CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState,
1248 bool isCallValid,
1249 TextureType targetPacked,
1250 GLsizei samples,
1251 GLenum internalFormat,
1252 GLsizei width,
1253 GLsizei height,
1254 GLsizei depth,
1255 GLboolean fixedSampleLocations,
1256 MemoryObjectID memoryPacked,
1257 GLuint64 offset,
1258 GLbitfield createFlags,
1259 GLbitfield usageFlags,
1260 const void *imageCreateInfoPNext)
1261 {
1262 ParamBuffer paramBuffer;
1263
1264 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1265 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
1266 paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum,
1267 internalFormat);
1268 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1269 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1270 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1271 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
1272 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1273 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
1274 paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield,
1275 createFlags);
1276 paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags);
1277
1278 if (isCallValid)
1279 {
1280 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1281 ParamType::TvoidConstPointer);
1282 InitParamValue(ParamType::TvoidConstPointer, imageCreateInfoPNext,
1283 &imageCreateInfoPNextParam.value);
1284 CaptureTexStorageMemFlags3DMultisampleANGLE_imageCreateInfoPNext(
1285 glState, isCallValid, targetPacked, samples, internalFormat, width, height, depth,
1286 fixedSampleLocations, memoryPacked, offset, createFlags, usageFlags,
1287 imageCreateInfoPNext, &imageCreateInfoPNextParam);
1288 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1289 }
1290 else
1291 {
1292 ParamCapture imageCreateInfoPNextParam("imageCreateInfoPNext",
1293 ParamType::TvoidConstPointer);
1294 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1295 &imageCreateInfoPNextParam.value);
1296 paramBuffer.addParam(std::move(imageCreateInfoPNextParam));
1297 }
1298
1299 return CallCapture(angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE,
1300 std::move(paramBuffer));
1301 }
1302
CaptureImportMemoryZirconHandleANGLE(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLuint handle)1303 CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
1304 bool isCallValid,
1305 MemoryObjectID memoryPacked,
1306 GLuint64 size,
1307 HandleType handleTypePacked,
1308 GLuint handle)
1309 {
1310 ParamBuffer paramBuffer;
1311
1312 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
1313 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
1314 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
1315 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
1316
1317 return CallCapture(angle::EntryPoint::GLImportMemoryZirconHandleANGLE, std::move(paramBuffer));
1318 }
1319
CaptureMultiDrawArraysANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)1320 CallCapture CaptureMultiDrawArraysANGLE(const State &glState,
1321 bool isCallValid,
1322 PrimitiveMode modePacked,
1323 const GLint *firsts,
1324 const GLsizei *counts,
1325 GLsizei drawcount)
1326 {
1327 ParamBuffer paramBuffer;
1328
1329 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1330
1331 if (isCallValid)
1332 {
1333 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1334 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
1335 CaptureMultiDrawArraysANGLE_firsts(glState, isCallValid, modePacked, firsts, counts,
1336 drawcount, &firstsParam);
1337 paramBuffer.addParam(std::move(firstsParam));
1338 }
1339 else
1340 {
1341 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1342 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
1343 &firstsParam.value);
1344 paramBuffer.addParam(std::move(firstsParam));
1345 }
1346
1347 if (isCallValid)
1348 {
1349 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1350 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1351 CaptureMultiDrawArraysANGLE_counts(glState, isCallValid, modePacked, firsts, counts,
1352 drawcount, &countsParam);
1353 paramBuffer.addParam(std::move(countsParam));
1354 }
1355 else
1356 {
1357 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1358 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1359 &countsParam.value);
1360 paramBuffer.addParam(std::move(countsParam));
1361 }
1362
1363 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1364
1365 return CallCapture(angle::EntryPoint::GLMultiDrawArraysANGLE, std::move(paramBuffer));
1366 }
1367
CaptureMultiDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)1368 CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState,
1369 bool isCallValid,
1370 PrimitiveMode modePacked,
1371 const GLint *firsts,
1372 const GLsizei *counts,
1373 const GLsizei *instanceCounts,
1374 GLsizei drawcount)
1375 {
1376 ParamBuffer paramBuffer;
1377
1378 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1379
1380 if (isCallValid)
1381 {
1382 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1383 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
1384 CaptureMultiDrawArraysInstancedANGLE_firsts(glState, isCallValid, modePacked, firsts,
1385 counts, instanceCounts, drawcount,
1386 &firstsParam);
1387 paramBuffer.addParam(std::move(firstsParam));
1388 }
1389 else
1390 {
1391 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
1392 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
1393 &firstsParam.value);
1394 paramBuffer.addParam(std::move(firstsParam));
1395 }
1396
1397 if (isCallValid)
1398 {
1399 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1400 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1401 CaptureMultiDrawArraysInstancedANGLE_counts(glState, isCallValid, modePacked, firsts,
1402 counts, instanceCounts, drawcount,
1403 &countsParam);
1404 paramBuffer.addParam(std::move(countsParam));
1405 }
1406 else
1407 {
1408 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1409 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1410 &countsParam.value);
1411 paramBuffer.addParam(std::move(countsParam));
1412 }
1413
1414 if (isCallValid)
1415 {
1416 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1417 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
1418 CaptureMultiDrawArraysInstancedANGLE_instanceCounts(glState, isCallValid, modePacked,
1419 firsts, counts, instanceCounts,
1420 drawcount, &instanceCountsParam);
1421 paramBuffer.addParam(std::move(instanceCountsParam));
1422 }
1423 else
1424 {
1425 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1426 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1427 &instanceCountsParam.value);
1428 paramBuffer.addParam(std::move(instanceCountsParam));
1429 }
1430
1431 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1432
1433 return CallCapture(angle::EntryPoint::GLMultiDrawArraysInstancedANGLE, std::move(paramBuffer));
1434 }
1435
CaptureMultiDrawElementsANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount)1436 CallCapture CaptureMultiDrawElementsANGLE(const State &glState,
1437 bool isCallValid,
1438 PrimitiveMode modePacked,
1439 const GLsizei *counts,
1440 DrawElementsType typePacked,
1441 const void *const *indices,
1442 GLsizei drawcount)
1443 {
1444 ParamBuffer paramBuffer;
1445
1446 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1447
1448 if (isCallValid)
1449 {
1450 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1451 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1452 CaptureMultiDrawElementsANGLE_counts(glState, isCallValid, modePacked, counts, typePacked,
1453 indices, drawcount, &countsParam);
1454 paramBuffer.addParam(std::move(countsParam));
1455 }
1456 else
1457 {
1458 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1459 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1460 &countsParam.value);
1461 paramBuffer.addParam(std::move(countsParam));
1462 }
1463
1464 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
1465
1466 if (isCallValid)
1467 {
1468 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1469 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
1470 CaptureMultiDrawElementsANGLE_indices(glState, isCallValid, modePacked, counts, typePacked,
1471 indices, drawcount, &indicesParam);
1472 paramBuffer.addParam(std::move(indicesParam));
1473 }
1474 else
1475 {
1476 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1477 InitParamValue(ParamType::TvoidConstPointerPointer,
1478 static_cast<const void *const *>(nullptr), &indicesParam.value);
1479 paramBuffer.addParam(std::move(indicesParam));
1480 }
1481
1482 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1483
1484 return CallCapture(angle::EntryPoint::GLMultiDrawElementsANGLE, std::move(paramBuffer));
1485 }
1486
CaptureMultiDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const void * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)1487 CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
1488 bool isCallValid,
1489 PrimitiveMode modePacked,
1490 const GLsizei *counts,
1491 DrawElementsType typePacked,
1492 const void *const *indices,
1493 const GLsizei *instanceCounts,
1494 GLsizei drawcount)
1495 {
1496 ParamBuffer paramBuffer;
1497
1498 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
1499
1500 if (isCallValid)
1501 {
1502 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1503 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
1504 CaptureMultiDrawElementsInstancedANGLE_counts(glState, isCallValid, modePacked, counts,
1505 typePacked, indices, instanceCounts,
1506 drawcount, &countsParam);
1507 paramBuffer.addParam(std::move(countsParam));
1508 }
1509 else
1510 {
1511 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
1512 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1513 &countsParam.value);
1514 paramBuffer.addParam(std::move(countsParam));
1515 }
1516
1517 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
1518
1519 if (isCallValid)
1520 {
1521 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1522 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
1523 CaptureMultiDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, counts,
1524 typePacked, indices, instanceCounts,
1525 drawcount, &indicesParam);
1526 paramBuffer.addParam(std::move(indicesParam));
1527 }
1528 else
1529 {
1530 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
1531 InitParamValue(ParamType::TvoidConstPointerPointer,
1532 static_cast<const void *const *>(nullptr), &indicesParam.value);
1533 paramBuffer.addParam(std::move(indicesParam));
1534 }
1535
1536 if (isCallValid)
1537 {
1538 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1539 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
1540 CaptureMultiDrawElementsInstancedANGLE_instanceCounts(
1541 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
1542 drawcount, &instanceCountsParam);
1543 paramBuffer.addParam(std::move(instanceCountsParam));
1544 }
1545 else
1546 {
1547 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
1548 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
1549 &instanceCountsParam.value);
1550 paramBuffer.addParam(std::move(instanceCountsParam));
1551 }
1552
1553 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
1554
1555 return CallCapture(angle::EntryPoint::GLMultiDrawElementsInstancedANGLE,
1556 std::move(paramBuffer));
1557 }
1558
CapturePolygonModeANGLE(const State & glState,bool isCallValid,GLenum face,PolygonMode modePacked)1559 CallCapture CapturePolygonModeANGLE(const State &glState,
1560 bool isCallValid,
1561 GLenum face,
1562 PolygonMode modePacked)
1563 {
1564 ParamBuffer paramBuffer;
1565
1566 paramBuffer.addEnumParam("face", GLESEnum::TriangleFace, ParamType::TGLenum, face);
1567 paramBuffer.addValueParam("modePacked", ParamType::TPolygonMode, modePacked);
1568
1569 return CallCapture(angle::EntryPoint::GLPolygonModeANGLE, std::move(paramBuffer));
1570 }
1571
CaptureProvokingVertexANGLE(const State & glState,bool isCallValid,ProvokingVertexConvention provokeModePacked)1572 CallCapture CaptureProvokingVertexANGLE(const State &glState,
1573 bool isCallValid,
1574 ProvokingVertexConvention provokeModePacked)
1575 {
1576 ParamBuffer paramBuffer;
1577
1578 paramBuffer.addValueParam("provokeModePacked", ParamType::TProvokingVertexConvention,
1579 provokeModePacked);
1580
1581 return CallCapture(angle::EntryPoint::GLProvokingVertexANGLE, std::move(paramBuffer));
1582 }
1583
CaptureRequestExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)1584 CallCapture CaptureRequestExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
1585 {
1586 ParamBuffer paramBuffer;
1587
1588 if (isCallValid)
1589 {
1590 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1591 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
1592 CaptureRequestExtensionANGLE_name(glState, isCallValid, name, &nameParam);
1593 paramBuffer.addParam(std::move(nameParam));
1594 }
1595 else
1596 {
1597 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1598 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
1599 &nameParam.value);
1600 paramBuffer.addParam(std::move(nameParam));
1601 }
1602
1603 return CallCapture(angle::EntryPoint::GLRequestExtensionANGLE, std::move(paramBuffer));
1604 }
1605
CaptureDisableExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)1606 CallCapture CaptureDisableExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
1607 {
1608 ParamBuffer paramBuffer;
1609
1610 if (isCallValid)
1611 {
1612 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1613 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
1614 CaptureDisableExtensionANGLE_name(glState, isCallValid, name, &nameParam);
1615 paramBuffer.addParam(std::move(nameParam));
1616 }
1617 else
1618 {
1619 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1620 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
1621 &nameParam.value);
1622 paramBuffer.addParam(std::move(nameParam));
1623 }
1624
1625 return CallCapture(angle::EntryPoint::GLDisableExtensionANGLE, std::move(paramBuffer));
1626 }
1627
CaptureGetBooleanvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)1628 CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
1629 bool isCallValid,
1630 GLenum pname,
1631 GLsizei bufSize,
1632 GLsizei *length,
1633 GLboolean *params)
1634 {
1635 ParamBuffer paramBuffer;
1636
1637 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1638 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1639
1640 if (isCallValid)
1641 {
1642 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1643 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1644 CaptureGetBooleanvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
1645 &lengthParam);
1646 paramBuffer.addParam(std::move(lengthParam));
1647 }
1648 else
1649 {
1650 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1651 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1652 &lengthParam.value);
1653 paramBuffer.addParam(std::move(lengthParam));
1654 }
1655
1656 if (isCallValid)
1657 {
1658 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
1659 InitParamValue(ParamType::TGLbooleanPointer, params, ¶msParam.value);
1660 CaptureGetBooleanvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
1661 ¶msParam);
1662 paramBuffer.addParam(std::move(paramsParam));
1663 }
1664 else
1665 {
1666 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
1667 InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
1668 ¶msParam.value);
1669 paramBuffer.addParam(std::move(paramsParam));
1670 }
1671
1672 return CallCapture(angle::EntryPoint::GLGetBooleanvRobustANGLE, std::move(paramBuffer));
1673 }
1674
CaptureGetBufferParameterivRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1675 CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
1676 bool isCallValid,
1677 BufferBinding targetPacked,
1678 GLenum pname,
1679 GLsizei bufSize,
1680 GLsizei *length,
1681 GLint *params)
1682 {
1683 ParamBuffer paramBuffer;
1684
1685 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1686 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1687 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1688
1689 if (isCallValid)
1690 {
1691 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1692 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1693 CaptureGetBufferParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1694 bufSize, length, params, &lengthParam);
1695 paramBuffer.addParam(std::move(lengthParam));
1696 }
1697 else
1698 {
1699 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1700 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1701 &lengthParam.value);
1702 paramBuffer.addParam(std::move(lengthParam));
1703 }
1704
1705 if (isCallValid)
1706 {
1707 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1708 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1709 CaptureGetBufferParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1710 bufSize, length, params, ¶msParam);
1711 paramBuffer.addParam(std::move(paramsParam));
1712 }
1713 else
1714 {
1715 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1716 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1717 paramBuffer.addParam(std::move(paramsParam));
1718 }
1719
1720 return CallCapture(angle::EntryPoint::GLGetBufferParameterivRobustANGLE,
1721 std::move(paramBuffer));
1722 }
1723
CaptureGetFloatvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1724 CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
1725 bool isCallValid,
1726 GLenum pname,
1727 GLsizei bufSize,
1728 GLsizei *length,
1729 GLfloat *params)
1730 {
1731 ParamBuffer paramBuffer;
1732
1733 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1734 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1735
1736 if (isCallValid)
1737 {
1738 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1739 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1740 CaptureGetFloatvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
1741 &lengthParam);
1742 paramBuffer.addParam(std::move(lengthParam));
1743 }
1744 else
1745 {
1746 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1747 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1748 &lengthParam.value);
1749 paramBuffer.addParam(std::move(lengthParam));
1750 }
1751
1752 if (isCallValid)
1753 {
1754 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1755 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1756 CaptureGetFloatvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
1757 ¶msParam);
1758 paramBuffer.addParam(std::move(paramsParam));
1759 }
1760 else
1761 {
1762 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1763 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1764 ¶msParam.value);
1765 paramBuffer.addParam(std::move(paramsParam));
1766 }
1767
1768 return CallCapture(angle::EntryPoint::GLGetFloatvRobustANGLE, std::move(paramBuffer));
1769 }
1770
CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1771 CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
1772 bool isCallValid,
1773 GLenum target,
1774 GLenum attachment,
1775 GLenum pname,
1776 GLsizei bufSize,
1777 GLsizei *length,
1778 GLint *params)
1779 {
1780 ParamBuffer paramBuffer;
1781
1782 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
1783 paramBuffer.addEnumParam("attachment", GLESEnum::AllEnums, ParamType::TGLenum, attachment);
1784 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1785 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1786
1787 if (isCallValid)
1788 {
1789 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1790 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1791 CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
1792 glState, isCallValid, target, attachment, pname, bufSize, length, params, &lengthParam);
1793 paramBuffer.addParam(std::move(lengthParam));
1794 }
1795 else
1796 {
1797 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1798 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1799 &lengthParam.value);
1800 paramBuffer.addParam(std::move(lengthParam));
1801 }
1802
1803 if (isCallValid)
1804 {
1805 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1806 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1807 CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
1808 glState, isCallValid, target, attachment, pname, bufSize, length, params, ¶msParam);
1809 paramBuffer.addParam(std::move(paramsParam));
1810 }
1811 else
1812 {
1813 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1814 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1815 paramBuffer.addParam(std::move(paramsParam));
1816 }
1817
1818 return CallCapture(angle::EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
1819 std::move(paramBuffer));
1820 }
1821
CaptureGetIntegervRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)1822 CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
1823 bool isCallValid,
1824 GLenum pname,
1825 GLsizei bufSize,
1826 GLsizei *length,
1827 GLint *data)
1828 {
1829 ParamBuffer paramBuffer;
1830
1831 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1832 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1833
1834 if (isCallValid)
1835 {
1836 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1837 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1838 CaptureGetIntegervRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
1839 &lengthParam);
1840 paramBuffer.addParam(std::move(lengthParam));
1841 }
1842 else
1843 {
1844 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1845 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1846 &lengthParam.value);
1847 paramBuffer.addParam(std::move(lengthParam));
1848 }
1849
1850 if (isCallValid)
1851 {
1852 ParamCapture dataParam("data", ParamType::TGLintPointer);
1853 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
1854 CaptureGetIntegervRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
1855 &dataParam);
1856 paramBuffer.addParam(std::move(dataParam));
1857 }
1858 else
1859 {
1860 ParamCapture dataParam("data", ParamType::TGLintPointer);
1861 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
1862 paramBuffer.addParam(std::move(dataParam));
1863 }
1864
1865 return CallCapture(angle::EntryPoint::GLGetIntegervRobustANGLE, std::move(paramBuffer));
1866 }
1867
CaptureGetProgramivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1868 CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
1869 bool isCallValid,
1870 ShaderProgramID programPacked,
1871 GLenum pname,
1872 GLsizei bufSize,
1873 GLsizei *length,
1874 GLint *params)
1875 {
1876 ParamBuffer paramBuffer;
1877
1878 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1879 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1880 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1881
1882 if (isCallValid)
1883 {
1884 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1885 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1886 CaptureGetProgramivRobustANGLE_length(glState, isCallValid, programPacked, pname, bufSize,
1887 length, params, &lengthParam);
1888 paramBuffer.addParam(std::move(lengthParam));
1889 }
1890 else
1891 {
1892 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1893 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1894 &lengthParam.value);
1895 paramBuffer.addParam(std::move(lengthParam));
1896 }
1897
1898 if (isCallValid)
1899 {
1900 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1901 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1902 CaptureGetProgramivRobustANGLE_params(glState, isCallValid, programPacked, pname, bufSize,
1903 length, params, ¶msParam);
1904 paramBuffer.addParam(std::move(paramsParam));
1905 }
1906 else
1907 {
1908 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1909 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1910 paramBuffer.addParam(std::move(paramsParam));
1911 }
1912
1913 return CallCapture(angle::EntryPoint::GLGetProgramivRobustANGLE, std::move(paramBuffer));
1914 }
1915
CaptureGetRenderbufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1916 CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
1917 bool isCallValid,
1918 GLenum target,
1919 GLenum pname,
1920 GLsizei bufSize,
1921 GLsizei *length,
1922 GLint *params)
1923 {
1924 ParamBuffer paramBuffer;
1925
1926 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
1927 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1928 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1929
1930 if (isCallValid)
1931 {
1932 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1933 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1934 CaptureGetRenderbufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
1935 bufSize, length, params, &lengthParam);
1936 paramBuffer.addParam(std::move(lengthParam));
1937 }
1938 else
1939 {
1940 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1941 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1942 &lengthParam.value);
1943 paramBuffer.addParam(std::move(lengthParam));
1944 }
1945
1946 if (isCallValid)
1947 {
1948 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1949 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1950 CaptureGetRenderbufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
1951 bufSize, length, params, ¶msParam);
1952 paramBuffer.addParam(std::move(paramsParam));
1953 }
1954 else
1955 {
1956 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1957 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1958 paramBuffer.addParam(std::move(paramsParam));
1959 }
1960
1961 return CallCapture(angle::EntryPoint::GLGetRenderbufferParameterivRobustANGLE,
1962 std::move(paramBuffer));
1963 }
1964
CaptureGetShaderivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1965 CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
1966 bool isCallValid,
1967 ShaderProgramID shaderPacked,
1968 GLenum pname,
1969 GLsizei bufSize,
1970 GLsizei *length,
1971 GLint *params)
1972 {
1973 ParamBuffer paramBuffer;
1974
1975 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
1976 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
1977 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1978
1979 if (isCallValid)
1980 {
1981 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1982 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1983 CaptureGetShaderivRobustANGLE_length(glState, isCallValid, shaderPacked, pname, bufSize,
1984 length, params, &lengthParam);
1985 paramBuffer.addParam(std::move(lengthParam));
1986 }
1987 else
1988 {
1989 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1990 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1991 &lengthParam.value);
1992 paramBuffer.addParam(std::move(lengthParam));
1993 }
1994
1995 if (isCallValid)
1996 {
1997 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1998 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1999 CaptureGetShaderivRobustANGLE_params(glState, isCallValid, shaderPacked, pname, bufSize,
2000 length, params, ¶msParam);
2001 paramBuffer.addParam(std::move(paramsParam));
2002 }
2003 else
2004 {
2005 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2006 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2007 paramBuffer.addParam(std::move(paramsParam));
2008 }
2009
2010 return CallCapture(angle::EntryPoint::GLGetShaderivRobustANGLE, std::move(paramBuffer));
2011 }
2012
CaptureGetTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2013 CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
2014 bool isCallValid,
2015 TextureType targetPacked,
2016 GLenum pname,
2017 GLsizei bufSize,
2018 GLsizei *length,
2019 GLfloat *params)
2020 {
2021 ParamBuffer paramBuffer;
2022
2023 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2024 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2025 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2026
2027 if (isCallValid)
2028 {
2029 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2030 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2031 CaptureGetTexParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2032 bufSize, length, params, &lengthParam);
2033 paramBuffer.addParam(std::move(lengthParam));
2034 }
2035 else
2036 {
2037 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2038 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2039 &lengthParam.value);
2040 paramBuffer.addParam(std::move(lengthParam));
2041 }
2042
2043 if (isCallValid)
2044 {
2045 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2046 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2047 CaptureGetTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname,
2048 bufSize, length, params, ¶msParam);
2049 paramBuffer.addParam(std::move(paramsParam));
2050 }
2051 else
2052 {
2053 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2054 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
2055 ¶msParam.value);
2056 paramBuffer.addParam(std::move(paramsParam));
2057 }
2058
2059 return CallCapture(angle::EntryPoint::GLGetTexParameterfvRobustANGLE, std::move(paramBuffer));
2060 }
2061
CaptureGetTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2062 CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
2063 bool isCallValid,
2064 TextureType targetPacked,
2065 GLenum pname,
2066 GLsizei bufSize,
2067 GLsizei *length,
2068 GLint *params)
2069 {
2070 ParamBuffer paramBuffer;
2071
2072 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2073 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2074 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2075
2076 if (isCallValid)
2077 {
2078 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2079 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2080 CaptureGetTexParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2081 bufSize, length, params, &lengthParam);
2082 paramBuffer.addParam(std::move(lengthParam));
2083 }
2084 else
2085 {
2086 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2087 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2088 &lengthParam.value);
2089 paramBuffer.addParam(std::move(lengthParam));
2090 }
2091
2092 if (isCallValid)
2093 {
2094 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2095 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2096 CaptureGetTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
2097 bufSize, length, params, ¶msParam);
2098 paramBuffer.addParam(std::move(paramsParam));
2099 }
2100 else
2101 {
2102 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2103 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2104 paramBuffer.addParam(std::move(paramsParam));
2105 }
2106
2107 return CallCapture(angle::EntryPoint::GLGetTexParameterivRobustANGLE, std::move(paramBuffer));
2108 }
2109
CaptureGetUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)2110 CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
2111 bool isCallValid,
2112 ShaderProgramID programPacked,
2113 UniformLocation locationPacked,
2114 GLsizei bufSize,
2115 GLsizei *length,
2116 GLfloat *params)
2117 {
2118 ParamBuffer paramBuffer;
2119
2120 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2121 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2122 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2123
2124 if (isCallValid)
2125 {
2126 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2127 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2128 CaptureGetUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2129 bufSize, length, params, &lengthParam);
2130 paramBuffer.addParam(std::move(lengthParam));
2131 }
2132 else
2133 {
2134 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2135 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2136 &lengthParam.value);
2137 paramBuffer.addParam(std::move(lengthParam));
2138 }
2139
2140 if (isCallValid)
2141 {
2142 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2143 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2144 CaptureGetUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2145 bufSize, length, params, ¶msParam);
2146 paramBuffer.addParam(std::move(paramsParam));
2147 }
2148 else
2149 {
2150 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2151 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
2152 ¶msParam.value);
2153 paramBuffer.addParam(std::move(paramsParam));
2154 }
2155
2156 return CallCapture(angle::EntryPoint::GLGetUniformfvRobustANGLE, std::move(paramBuffer));
2157 }
2158
CaptureGetUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)2159 CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
2160 bool isCallValid,
2161 ShaderProgramID programPacked,
2162 UniformLocation locationPacked,
2163 GLsizei bufSize,
2164 GLsizei *length,
2165 GLint *params)
2166 {
2167 ParamBuffer paramBuffer;
2168
2169 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2170 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2171 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2172
2173 if (isCallValid)
2174 {
2175 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2176 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2177 CaptureGetUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2178 bufSize, length, params, &lengthParam);
2179 paramBuffer.addParam(std::move(lengthParam));
2180 }
2181 else
2182 {
2183 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2184 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2185 &lengthParam.value);
2186 paramBuffer.addParam(std::move(lengthParam));
2187 }
2188
2189 if (isCallValid)
2190 {
2191 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2192 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2193 CaptureGetUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2194 bufSize, length, params, ¶msParam);
2195 paramBuffer.addParam(std::move(paramsParam));
2196 }
2197 else
2198 {
2199 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2200 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2201 paramBuffer.addParam(std::move(paramsParam));
2202 }
2203
2204 return CallCapture(angle::EntryPoint::GLGetUniformivRobustANGLE, std::move(paramBuffer));
2205 }
2206
CaptureGetVertexAttribfvRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2207 CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
2208 bool isCallValid,
2209 GLuint index,
2210 GLenum pname,
2211 GLsizei bufSize,
2212 GLsizei *length,
2213 GLfloat *params)
2214 {
2215 ParamBuffer paramBuffer;
2216
2217 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2218 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2219 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2220
2221 if (isCallValid)
2222 {
2223 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2224 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2225 CaptureGetVertexAttribfvRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
2226 length, params, &lengthParam);
2227 paramBuffer.addParam(std::move(lengthParam));
2228 }
2229 else
2230 {
2231 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2232 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2233 &lengthParam.value);
2234 paramBuffer.addParam(std::move(lengthParam));
2235 }
2236
2237 if (isCallValid)
2238 {
2239 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2240 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2241 CaptureGetVertexAttribfvRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
2242 length, params, ¶msParam);
2243 paramBuffer.addParam(std::move(paramsParam));
2244 }
2245 else
2246 {
2247 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2248 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
2249 ¶msParam.value);
2250 paramBuffer.addParam(std::move(paramsParam));
2251 }
2252
2253 return CallCapture(angle::EntryPoint::GLGetVertexAttribfvRobustANGLE, std::move(paramBuffer));
2254 }
2255
CaptureGetVertexAttribivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2256 CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
2257 bool isCallValid,
2258 GLuint index,
2259 GLenum pname,
2260 GLsizei bufSize,
2261 GLsizei *length,
2262 GLint *params)
2263 {
2264 ParamBuffer paramBuffer;
2265
2266 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2267 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2268 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2269
2270 if (isCallValid)
2271 {
2272 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2273 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2274 CaptureGetVertexAttribivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
2275 length, params, &lengthParam);
2276 paramBuffer.addParam(std::move(lengthParam));
2277 }
2278 else
2279 {
2280 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2281 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2282 &lengthParam.value);
2283 paramBuffer.addParam(std::move(lengthParam));
2284 }
2285
2286 if (isCallValid)
2287 {
2288 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2289 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2290 CaptureGetVertexAttribivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
2291 length, params, ¶msParam);
2292 paramBuffer.addParam(std::move(paramsParam));
2293 }
2294 else
2295 {
2296 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2297 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2298 paramBuffer.addParam(std::move(paramsParam));
2299 }
2300
2301 return CallCapture(angle::EntryPoint::GLGetVertexAttribivRobustANGLE, std::move(paramBuffer));
2302 }
2303
CaptureGetVertexAttribPointervRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)2304 CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
2305 bool isCallValid,
2306 GLuint index,
2307 GLenum pname,
2308 GLsizei bufSize,
2309 GLsizei *length,
2310 void **pointer)
2311 {
2312 ParamBuffer paramBuffer;
2313
2314 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2315 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2316 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2317
2318 if (isCallValid)
2319 {
2320 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2321 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2322 CaptureGetVertexAttribPointervRobustANGLE_length(glState, isCallValid, index, pname,
2323 bufSize, length, pointer, &lengthParam);
2324 paramBuffer.addParam(std::move(lengthParam));
2325 }
2326 else
2327 {
2328 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2329 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2330 &lengthParam.value);
2331 paramBuffer.addParam(std::move(lengthParam));
2332 }
2333
2334 if (isCallValid)
2335 {
2336 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
2337 InitParamValue(ParamType::TvoidPointerPointer, pointer, &pointerParam.value);
2338 CaptureGetVertexAttribPointervRobustANGLE_pointer(glState, isCallValid, index, pname,
2339 bufSize, length, pointer, &pointerParam);
2340 paramBuffer.addParam(std::move(pointerParam));
2341 }
2342 else
2343 {
2344 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
2345 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
2346 &pointerParam.value);
2347 paramBuffer.addParam(std::move(pointerParam));
2348 }
2349
2350 return CallCapture(angle::EntryPoint::GLGetVertexAttribPointervRobustANGLE,
2351 std::move(paramBuffer));
2352 }
2353
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)2354 CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
2355 bool isCallValid,
2356 GLint x,
2357 GLint y,
2358 GLsizei width,
2359 GLsizei height,
2360 GLenum format,
2361 GLenum type,
2362 GLsizei bufSize,
2363 GLsizei *length,
2364 GLsizei *columns,
2365 GLsizei *rows,
2366 void *pixels)
2367 {
2368 ParamBuffer paramBuffer;
2369
2370 paramBuffer.addValueParam("x", ParamType::TGLint, x);
2371 paramBuffer.addValueParam("y", ParamType::TGLint, y);
2372 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2373 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2374 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2375 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2376 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2377
2378 if (isCallValid)
2379 {
2380 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2381 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2382 CaptureReadPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format, type,
2383 bufSize, length, columns, rows, pixels, &lengthParam);
2384 paramBuffer.addParam(std::move(lengthParam));
2385 }
2386 else
2387 {
2388 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2389 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2390 &lengthParam.value);
2391 paramBuffer.addParam(std::move(lengthParam));
2392 }
2393
2394 if (isCallValid)
2395 {
2396 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
2397 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
2398 CaptureReadPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format,
2399 type, bufSize, length, columns, rows, pixels,
2400 &columnsParam);
2401 paramBuffer.addParam(std::move(columnsParam));
2402 }
2403 else
2404 {
2405 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
2406 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2407 &columnsParam.value);
2408 paramBuffer.addParam(std::move(columnsParam));
2409 }
2410
2411 if (isCallValid)
2412 {
2413 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
2414 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
2415 CaptureReadPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
2416 bufSize, length, columns, rows, pixels, &rowsParam);
2417 paramBuffer.addParam(std::move(rowsParam));
2418 }
2419 else
2420 {
2421 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
2422 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2423 &rowsParam.value);
2424 paramBuffer.addParam(std::move(rowsParam));
2425 }
2426
2427 if (isCallValid)
2428 {
2429 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
2430 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
2431 CaptureReadPixelsRobustANGLE_pixels(glState, isCallValid, x, y, width, height, format, type,
2432 bufSize, length, columns, rows, pixels, &pixelsParam);
2433 paramBuffer.addParam(std::move(pixelsParam));
2434 }
2435 else
2436 {
2437 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
2438 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
2439 paramBuffer.addParam(std::move(pixelsParam));
2440 }
2441
2442 return CallCapture(angle::EntryPoint::GLReadPixelsRobustANGLE, std::move(paramBuffer));
2443 }
2444
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)2445 CallCapture CaptureTexImage2DRobustANGLE(const State &glState,
2446 bool isCallValid,
2447 TextureTarget targetPacked,
2448 GLint level,
2449 GLint internalformat,
2450 GLsizei width,
2451 GLsizei height,
2452 GLint border,
2453 GLenum format,
2454 GLenum type,
2455 GLsizei bufSize,
2456 const void *pixels)
2457 {
2458 ParamBuffer paramBuffer;
2459
2460 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2461 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2462 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
2463 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2464 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2465 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2466 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2467 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2468 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2469
2470 if (isCallValid)
2471 {
2472 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2473 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2474 CaptureTexImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level,
2475 internalformat, width, height, border, format, type,
2476 bufSize, pixels, &pixelsParam);
2477 paramBuffer.addParam(std::move(pixelsParam));
2478 }
2479 else
2480 {
2481 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2482 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2483 &pixelsParam.value);
2484 paramBuffer.addParam(std::move(pixelsParam));
2485 }
2486
2487 return CallCapture(angle::EntryPoint::GLTexImage2DRobustANGLE, std::move(paramBuffer));
2488 }
2489
CaptureTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLfloat * params)2490 CallCapture CaptureTexParameterfvRobustANGLE(const State &glState,
2491 bool isCallValid,
2492 TextureType targetPacked,
2493 GLenum pname,
2494 GLsizei bufSize,
2495 const GLfloat *params)
2496 {
2497 ParamBuffer paramBuffer;
2498
2499 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2500 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2501 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2502
2503 if (isCallValid)
2504 {
2505 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
2506 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
2507 CaptureTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2508 params, ¶msParam);
2509 paramBuffer.addParam(std::move(paramsParam));
2510 }
2511 else
2512 {
2513 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
2514 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
2515 ¶msParam.value);
2516 paramBuffer.addParam(std::move(paramsParam));
2517 }
2518
2519 return CallCapture(angle::EntryPoint::GLTexParameterfvRobustANGLE, std::move(paramBuffer));
2520 }
2521
CaptureTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)2522 CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
2523 bool isCallValid,
2524 TextureType targetPacked,
2525 GLenum pname,
2526 GLsizei bufSize,
2527 const GLint *params)
2528 {
2529 ParamBuffer paramBuffer;
2530
2531 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2532 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2533 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2534
2535 if (isCallValid)
2536 {
2537 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
2538 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
2539 CaptureTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2540 params, ¶msParam);
2541 paramBuffer.addParam(std::move(paramsParam));
2542 }
2543 else
2544 {
2545 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
2546 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
2547 ¶msParam.value);
2548 paramBuffer.addParam(std::move(paramsParam));
2549 }
2550
2551 return CallCapture(angle::EntryPoint::GLTexParameterivRobustANGLE, std::move(paramBuffer));
2552 }
2553
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)2554 CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
2555 bool isCallValid,
2556 TextureTarget targetPacked,
2557 GLint level,
2558 GLint xoffset,
2559 GLint yoffset,
2560 GLsizei width,
2561 GLsizei height,
2562 GLenum format,
2563 GLenum type,
2564 GLsizei bufSize,
2565 const void *pixels)
2566 {
2567 ParamBuffer paramBuffer;
2568
2569 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2570 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2571 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2572 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2573 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2574 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2575 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2576 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2577 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2578
2579 if (isCallValid)
2580 {
2581 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2582 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2583 CaptureTexSubImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
2584 yoffset, width, height, format, type, bufSize,
2585 pixels, &pixelsParam);
2586 paramBuffer.addParam(std::move(pixelsParam));
2587 }
2588 else
2589 {
2590 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2591 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2592 &pixelsParam.value);
2593 paramBuffer.addParam(std::move(pixelsParam));
2594 }
2595
2596 return CallCapture(angle::EntryPoint::GLTexSubImage2DRobustANGLE, std::move(paramBuffer));
2597 }
2598
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)2599 CallCapture CaptureTexImage3DRobustANGLE(const State &glState,
2600 bool isCallValid,
2601 TextureTarget targetPacked,
2602 GLint level,
2603 GLint internalformat,
2604 GLsizei width,
2605 GLsizei height,
2606 GLsizei depth,
2607 GLint border,
2608 GLenum format,
2609 GLenum type,
2610 GLsizei bufSize,
2611 const void *pixels)
2612 {
2613 ParamBuffer paramBuffer;
2614
2615 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2616 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2617 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
2618 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2619 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2620 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2621 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2622 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2623 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2624 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2625
2626 if (isCallValid)
2627 {
2628 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2629 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2630 CaptureTexImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level,
2631 internalformat, width, height, depth, border, format,
2632 type, bufSize, pixels, &pixelsParam);
2633 paramBuffer.addParam(std::move(pixelsParam));
2634 }
2635 else
2636 {
2637 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2638 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2639 &pixelsParam.value);
2640 paramBuffer.addParam(std::move(pixelsParam));
2641 }
2642
2643 return CallCapture(angle::EntryPoint::GLTexImage3DRobustANGLE, std::move(paramBuffer));
2644 }
2645
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)2646 CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState,
2647 bool isCallValid,
2648 TextureTarget targetPacked,
2649 GLint level,
2650 GLint xoffset,
2651 GLint yoffset,
2652 GLint zoffset,
2653 GLsizei width,
2654 GLsizei height,
2655 GLsizei depth,
2656 GLenum format,
2657 GLenum type,
2658 GLsizei bufSize,
2659 const void *pixels)
2660 {
2661 ParamBuffer paramBuffer;
2662
2663 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2664 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2665 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2666 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2667 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
2668 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2669 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2670 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2671 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2672 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
2673 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2674
2675 if (isCallValid)
2676 {
2677 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2678 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2679 CaptureTexSubImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
2680 yoffset, zoffset, width, height, depth, format, type,
2681 bufSize, pixels, &pixelsParam);
2682 paramBuffer.addParam(std::move(pixelsParam));
2683 }
2684 else
2685 {
2686 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2687 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2688 &pixelsParam.value);
2689 paramBuffer.addParam(std::move(pixelsParam));
2690 }
2691
2692 return CallCapture(angle::EntryPoint::GLTexSubImage3DRobustANGLE, std::move(paramBuffer));
2693 }
2694
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)2695 CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState,
2696 bool isCallValid,
2697 TextureTarget targetPacked,
2698 GLint level,
2699 GLenum internalformat,
2700 GLsizei width,
2701 GLsizei height,
2702 GLint border,
2703 GLsizei imageSize,
2704 GLsizei dataSize,
2705 const void *data)
2706 {
2707 ParamBuffer paramBuffer;
2708
2709 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2710 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2711 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
2712 internalformat);
2713 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2714 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2715 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2716 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2717 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2718
2719 if (isCallValid)
2720 {
2721 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2722 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2723 CaptureCompressedTexImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2724 internalformat, width, height, border,
2725 imageSize, dataSize, data, &dataParam);
2726 paramBuffer.addParam(std::move(dataParam));
2727 }
2728 else
2729 {
2730 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2731 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2732 &dataParam.value);
2733 paramBuffer.addParam(std::move(dataParam));
2734 }
2735
2736 return CallCapture(angle::EntryPoint::GLCompressedTexImage2DRobustANGLE,
2737 std::move(paramBuffer));
2738 }
2739
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)2740 CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState,
2741 bool isCallValid,
2742 TextureTarget targetPacked,
2743 GLint level,
2744 GLsizei xoffset,
2745 GLsizei yoffset,
2746 GLsizei width,
2747 GLsizei height,
2748 GLenum format,
2749 GLsizei imageSize,
2750 GLsizei dataSize,
2751 const void *data)
2752 {
2753 ParamBuffer paramBuffer;
2754
2755 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2756 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2757 paramBuffer.addValueParam("xoffset", ParamType::TGLsizei, xoffset);
2758 paramBuffer.addValueParam("yoffset", ParamType::TGLsizei, yoffset);
2759 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2760 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2761 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2762 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2763 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2764
2765 if (isCallValid)
2766 {
2767 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2768 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2769 CaptureCompressedTexSubImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2770 xoffset, yoffset, width, height, format,
2771 imageSize, dataSize, data, &dataParam);
2772 paramBuffer.addParam(std::move(dataParam));
2773 }
2774 else
2775 {
2776 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2777 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2778 &dataParam.value);
2779 paramBuffer.addParam(std::move(dataParam));
2780 }
2781
2782 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE,
2783 std::move(paramBuffer));
2784 }
2785
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)2786 CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState,
2787 bool isCallValid,
2788 TextureTarget targetPacked,
2789 GLint level,
2790 GLenum internalformat,
2791 GLsizei width,
2792 GLsizei height,
2793 GLsizei depth,
2794 GLint border,
2795 GLsizei imageSize,
2796 GLsizei dataSize,
2797 const void *data)
2798 {
2799 ParamBuffer paramBuffer;
2800
2801 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2802 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2803 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
2804 internalformat);
2805 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2806 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2807 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2808 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2809 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2810 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2811
2812 if (isCallValid)
2813 {
2814 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2815 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2816 CaptureCompressedTexImage3DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2817 internalformat, width, height, depth, border,
2818 imageSize, dataSize, data, &dataParam);
2819 paramBuffer.addParam(std::move(dataParam));
2820 }
2821 else
2822 {
2823 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2824 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2825 &dataParam.value);
2826 paramBuffer.addParam(std::move(dataParam));
2827 }
2828
2829 return CallCapture(angle::EntryPoint::GLCompressedTexImage3DRobustANGLE,
2830 std::move(paramBuffer));
2831 }
2832
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)2833 CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState,
2834 bool isCallValid,
2835 TextureTarget targetPacked,
2836 GLint level,
2837 GLint xoffset,
2838 GLint yoffset,
2839 GLint zoffset,
2840 GLsizei width,
2841 GLsizei height,
2842 GLsizei depth,
2843 GLenum format,
2844 GLsizei imageSize,
2845 GLsizei dataSize,
2846 const void *data)
2847 {
2848 ParamBuffer paramBuffer;
2849
2850 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2851 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2852 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2853 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2854 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
2855 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2856 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2857 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2858 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
2859 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2860 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2861
2862 if (isCallValid)
2863 {
2864 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2865 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
2866 CaptureCompressedTexSubImage3DRobustANGLE_data(
2867 glState, isCallValid, targetPacked, level, xoffset, yoffset, zoffset, width, height,
2868 depth, format, imageSize, dataSize, data, &dataParam);
2869 paramBuffer.addParam(std::move(dataParam));
2870 }
2871 else
2872 {
2873 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
2874 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2875 &dataParam.value);
2876 paramBuffer.addParam(std::move(dataParam));
2877 }
2878
2879 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE,
2880 std::move(paramBuffer));
2881 }
2882
CaptureGetQueryivRobustANGLE(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2883 CallCapture CaptureGetQueryivRobustANGLE(const State &glState,
2884 bool isCallValid,
2885 QueryType targetPacked,
2886 GLenum pname,
2887 GLsizei bufSize,
2888 GLsizei *length,
2889 GLint *params)
2890 {
2891 ParamBuffer paramBuffer;
2892
2893 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
2894 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2895 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2896
2897 if (isCallValid)
2898 {
2899 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2900 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2901 CaptureGetQueryivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
2902 length, params, &lengthParam);
2903 paramBuffer.addParam(std::move(lengthParam));
2904 }
2905 else
2906 {
2907 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2908 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2909 &lengthParam.value);
2910 paramBuffer.addParam(std::move(lengthParam));
2911 }
2912
2913 if (isCallValid)
2914 {
2915 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2916 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2917 CaptureGetQueryivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2918 length, params, ¶msParam);
2919 paramBuffer.addParam(std::move(paramsParam));
2920 }
2921 else
2922 {
2923 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2924 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2925 paramBuffer.addParam(std::move(paramsParam));
2926 }
2927
2928 return CallCapture(angle::EntryPoint::GLGetQueryivRobustANGLE, std::move(paramBuffer));
2929 }
2930
CaptureGetQueryObjectuivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2931 CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
2932 bool isCallValid,
2933 QueryID idPacked,
2934 GLenum pname,
2935 GLsizei bufSize,
2936 GLsizei *length,
2937 GLuint *params)
2938 {
2939 ParamBuffer paramBuffer;
2940
2941 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2942 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2943 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2944
2945 if (isCallValid)
2946 {
2947 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2948 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2949 CaptureGetQueryObjectuivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
2950 length, params, &lengthParam);
2951 paramBuffer.addParam(std::move(lengthParam));
2952 }
2953 else
2954 {
2955 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2956 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2957 &lengthParam.value);
2958 paramBuffer.addParam(std::move(lengthParam));
2959 }
2960
2961 if (isCallValid)
2962 {
2963 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2964 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2965 CaptureGetQueryObjectuivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
2966 length, params, ¶msParam);
2967 paramBuffer.addParam(std::move(paramsParam));
2968 }
2969 else
2970 {
2971 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2972 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
2973 ¶msParam.value);
2974 paramBuffer.addParam(std::move(paramsParam));
2975 }
2976
2977 return CallCapture(angle::EntryPoint::GLGetQueryObjectuivRobustANGLE, std::move(paramBuffer));
2978 }
2979
CaptureGetBufferPointervRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2980 CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
2981 bool isCallValid,
2982 BufferBinding targetPacked,
2983 GLenum pname,
2984 GLsizei bufSize,
2985 GLsizei *length,
2986 void **params)
2987 {
2988 ParamBuffer paramBuffer;
2989
2990 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
2991 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
2992 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2993
2994 if (isCallValid)
2995 {
2996 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2997 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2998 CaptureGetBufferPointervRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2999 bufSize, length, params, &lengthParam);
3000 paramBuffer.addParam(std::move(lengthParam));
3001 }
3002 else
3003 {
3004 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3005 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3006 &lengthParam.value);
3007 paramBuffer.addParam(std::move(lengthParam));
3008 }
3009
3010 if (isCallValid)
3011 {
3012 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3013 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
3014 CaptureGetBufferPointervRobustANGLE_params(glState, isCallValid, targetPacked, pname,
3015 bufSize, length, params, ¶msParam);
3016 paramBuffer.addParam(std::move(paramsParam));
3017 }
3018 else
3019 {
3020 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3021 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
3022 ¶msParam.value);
3023 paramBuffer.addParam(std::move(paramsParam));
3024 }
3025
3026 return CallCapture(angle::EntryPoint::GLGetBufferPointervRobustANGLE, std::move(paramBuffer));
3027 }
3028
CaptureGetIntegeri_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)3029 CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
3030 bool isCallValid,
3031 GLenum target,
3032 GLuint index,
3033 GLsizei bufSize,
3034 GLsizei *length,
3035 GLint *data)
3036 {
3037 ParamBuffer paramBuffer;
3038
3039 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3040 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3041 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3042
3043 if (isCallValid)
3044 {
3045 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3046 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3047 CaptureGetIntegeri_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
3048 data, &lengthParam);
3049 paramBuffer.addParam(std::move(lengthParam));
3050 }
3051 else
3052 {
3053 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3054 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3055 &lengthParam.value);
3056 paramBuffer.addParam(std::move(lengthParam));
3057 }
3058
3059 if (isCallValid)
3060 {
3061 ParamCapture dataParam("data", ParamType::TGLintPointer);
3062 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
3063 CaptureGetIntegeri_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3064 data, &dataParam);
3065 paramBuffer.addParam(std::move(dataParam));
3066 }
3067 else
3068 {
3069 ParamCapture dataParam("data", ParamType::TGLintPointer);
3070 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
3071 paramBuffer.addParam(std::move(dataParam));
3072 }
3073
3074 return CallCapture(angle::EntryPoint::GLGetIntegeri_vRobustANGLE, std::move(paramBuffer));
3075 }
3076
CaptureGetInternalformativRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3077 CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
3078 bool isCallValid,
3079 GLenum target,
3080 GLenum internalformat,
3081 GLenum pname,
3082 GLsizei bufSize,
3083 GLsizei *length,
3084 GLint *params)
3085 {
3086 ParamBuffer paramBuffer;
3087
3088 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3089 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
3090 internalformat);
3091 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3092 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3093
3094 if (isCallValid)
3095 {
3096 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3097 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3098 CaptureGetInternalformativRobustANGLE_length(glState, isCallValid, target, internalformat,
3099 pname, bufSize, length, params, &lengthParam);
3100 paramBuffer.addParam(std::move(lengthParam));
3101 }
3102 else
3103 {
3104 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3105 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3106 &lengthParam.value);
3107 paramBuffer.addParam(std::move(lengthParam));
3108 }
3109
3110 if (isCallValid)
3111 {
3112 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3113 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3114 CaptureGetInternalformativRobustANGLE_params(glState, isCallValid, target, internalformat,
3115 pname, bufSize, length, params, ¶msParam);
3116 paramBuffer.addParam(std::move(paramsParam));
3117 }
3118 else
3119 {
3120 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3121 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3122 paramBuffer.addParam(std::move(paramsParam));
3123 }
3124
3125 return CallCapture(angle::EntryPoint::GLGetInternalformativRobustANGLE, std::move(paramBuffer));
3126 }
3127
CaptureGetVertexAttribIivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3128 CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
3129 bool isCallValid,
3130 GLuint index,
3131 GLenum pname,
3132 GLsizei bufSize,
3133 GLsizei *length,
3134 GLint *params)
3135 {
3136 ParamBuffer paramBuffer;
3137
3138 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3139 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3140 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3141
3142 if (isCallValid)
3143 {
3144 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3145 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3146 CaptureGetVertexAttribIivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
3147 length, params, &lengthParam);
3148 paramBuffer.addParam(std::move(lengthParam));
3149 }
3150 else
3151 {
3152 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3153 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3154 &lengthParam.value);
3155 paramBuffer.addParam(std::move(lengthParam));
3156 }
3157
3158 if (isCallValid)
3159 {
3160 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3161 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3162 CaptureGetVertexAttribIivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
3163 length, params, ¶msParam);
3164 paramBuffer.addParam(std::move(paramsParam));
3165 }
3166 else
3167 {
3168 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3169 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3170 paramBuffer.addParam(std::move(paramsParam));
3171 }
3172
3173 return CallCapture(angle::EntryPoint::GLGetVertexAttribIivRobustANGLE, std::move(paramBuffer));
3174 }
3175
CaptureGetVertexAttribIuivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3176 CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
3177 bool isCallValid,
3178 GLuint index,
3179 GLenum pname,
3180 GLsizei bufSize,
3181 GLsizei *length,
3182 GLuint *params)
3183 {
3184 ParamBuffer paramBuffer;
3185
3186 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3187 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3188 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3189
3190 if (isCallValid)
3191 {
3192 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3193 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3194 CaptureGetVertexAttribIuivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
3195 length, params, &lengthParam);
3196 paramBuffer.addParam(std::move(lengthParam));
3197 }
3198 else
3199 {
3200 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3201 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3202 &lengthParam.value);
3203 paramBuffer.addParam(std::move(lengthParam));
3204 }
3205
3206 if (isCallValid)
3207 {
3208 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3209 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3210 CaptureGetVertexAttribIuivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
3211 length, params, ¶msParam);
3212 paramBuffer.addParam(std::move(paramsParam));
3213 }
3214 else
3215 {
3216 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3217 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3218 ¶msParam.value);
3219 paramBuffer.addParam(std::move(paramsParam));
3220 }
3221
3222 return CallCapture(angle::EntryPoint::GLGetVertexAttribIuivRobustANGLE, std::move(paramBuffer));
3223 }
3224
CaptureGetUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)3225 CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
3226 bool isCallValid,
3227 ShaderProgramID programPacked,
3228 UniformLocation locationPacked,
3229 GLsizei bufSize,
3230 GLsizei *length,
3231 GLuint *params)
3232 {
3233 ParamBuffer paramBuffer;
3234
3235 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3236 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3237 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3238
3239 if (isCallValid)
3240 {
3241 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3242 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3243 CaptureGetUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
3244 bufSize, length, params, &lengthParam);
3245 paramBuffer.addParam(std::move(lengthParam));
3246 }
3247 else
3248 {
3249 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3250 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3251 &lengthParam.value);
3252 paramBuffer.addParam(std::move(lengthParam));
3253 }
3254
3255 if (isCallValid)
3256 {
3257 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3258 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3259 CaptureGetUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
3260 bufSize, length, params, ¶msParam);
3261 paramBuffer.addParam(std::move(paramsParam));
3262 }
3263 else
3264 {
3265 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3266 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3267 ¶msParam.value);
3268 paramBuffer.addParam(std::move(paramsParam));
3269 }
3270
3271 return CallCapture(angle::EntryPoint::GLGetUniformuivRobustANGLE, std::move(paramBuffer));
3272 }
3273
CaptureGetActiveUniformBlockivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformBlockIndex uniformBlockIndexPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3274 CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState,
3275 bool isCallValid,
3276 ShaderProgramID programPacked,
3277 UniformBlockIndex uniformBlockIndexPacked,
3278 GLenum pname,
3279 GLsizei bufSize,
3280 GLsizei *length,
3281 GLint *params)
3282 {
3283 ParamBuffer paramBuffer;
3284
3285 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3286 paramBuffer.addValueParam("uniformBlockIndexPacked", ParamType::TUniformBlockIndex,
3287 uniformBlockIndexPacked);
3288 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3289 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3290
3291 if (isCallValid)
3292 {
3293 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3294 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3295 CaptureGetActiveUniformBlockivRobustANGLE_length(glState, isCallValid, programPacked,
3296 uniformBlockIndexPacked, pname, bufSize,
3297 length, params, &lengthParam);
3298 paramBuffer.addParam(std::move(lengthParam));
3299 }
3300 else
3301 {
3302 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3303 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3304 &lengthParam.value);
3305 paramBuffer.addParam(std::move(lengthParam));
3306 }
3307
3308 if (isCallValid)
3309 {
3310 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3311 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3312 CaptureGetActiveUniformBlockivRobustANGLE_params(glState, isCallValid, programPacked,
3313 uniformBlockIndexPacked, pname, bufSize,
3314 length, params, ¶msParam);
3315 paramBuffer.addParam(std::move(paramsParam));
3316 }
3317 else
3318 {
3319 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3320 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3321 paramBuffer.addParam(std::move(paramsParam));
3322 }
3323
3324 return CallCapture(angle::EntryPoint::GLGetActiveUniformBlockivRobustANGLE,
3325 std::move(paramBuffer));
3326 }
3327
CaptureGetInteger64vRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)3328 CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
3329 bool isCallValid,
3330 GLenum pname,
3331 GLsizei bufSize,
3332 GLsizei *length,
3333 GLint64 *data)
3334 {
3335 ParamBuffer paramBuffer;
3336
3337 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3338 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3339
3340 if (isCallValid)
3341 {
3342 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3343 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3344 CaptureGetInteger64vRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
3345 &lengthParam);
3346 paramBuffer.addParam(std::move(lengthParam));
3347 }
3348 else
3349 {
3350 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3351 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3352 &lengthParam.value);
3353 paramBuffer.addParam(std::move(lengthParam));
3354 }
3355
3356 if (isCallValid)
3357 {
3358 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3359 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
3360 CaptureGetInteger64vRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
3361 &dataParam);
3362 paramBuffer.addParam(std::move(dataParam));
3363 }
3364 else
3365 {
3366 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3367 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
3368 &dataParam.value);
3369 paramBuffer.addParam(std::move(dataParam));
3370 }
3371
3372 return CallCapture(angle::EntryPoint::GLGetInteger64vRobustANGLE, std::move(paramBuffer));
3373 }
3374
CaptureGetInteger64i_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)3375 CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
3376 bool isCallValid,
3377 GLenum target,
3378 GLuint index,
3379 GLsizei bufSize,
3380 GLsizei *length,
3381 GLint64 *data)
3382 {
3383 ParamBuffer paramBuffer;
3384
3385 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3386 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3387 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3388
3389 if (isCallValid)
3390 {
3391 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3392 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3393 CaptureGetInteger64i_vRobustANGLE_length(glState, isCallValid, target, index, bufSize,
3394 length, data, &lengthParam);
3395 paramBuffer.addParam(std::move(lengthParam));
3396 }
3397 else
3398 {
3399 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3400 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3401 &lengthParam.value);
3402 paramBuffer.addParam(std::move(lengthParam));
3403 }
3404
3405 if (isCallValid)
3406 {
3407 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3408 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
3409 CaptureGetInteger64i_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3410 data, &dataParam);
3411 paramBuffer.addParam(std::move(dataParam));
3412 }
3413 else
3414 {
3415 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3416 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
3417 &dataParam.value);
3418 paramBuffer.addParam(std::move(dataParam));
3419 }
3420
3421 return CallCapture(angle::EntryPoint::GLGetInteger64i_vRobustANGLE, std::move(paramBuffer));
3422 }
3423
CaptureGetBufferParameteri64vRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3424 CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
3425 bool isCallValid,
3426 BufferBinding targetPacked,
3427 GLenum pname,
3428 GLsizei bufSize,
3429 GLsizei *length,
3430 GLint64 *params)
3431 {
3432 ParamBuffer paramBuffer;
3433
3434 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
3435 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3436 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3437
3438 if (isCallValid)
3439 {
3440 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3441 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3442 CaptureGetBufferParameteri64vRobustANGLE_length(glState, isCallValid, targetPacked, pname,
3443 bufSize, length, params, &lengthParam);
3444 paramBuffer.addParam(std::move(lengthParam));
3445 }
3446 else
3447 {
3448 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3449 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3450 &lengthParam.value);
3451 paramBuffer.addParam(std::move(lengthParam));
3452 }
3453
3454 if (isCallValid)
3455 {
3456 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
3457 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
3458 CaptureGetBufferParameteri64vRobustANGLE_params(glState, isCallValid, targetPacked, pname,
3459 bufSize, length, params, ¶msParam);
3460 paramBuffer.addParam(std::move(paramsParam));
3461 }
3462 else
3463 {
3464 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
3465 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
3466 ¶msParam.value);
3467 paramBuffer.addParam(std::move(paramsParam));
3468 }
3469
3470 return CallCapture(angle::EntryPoint::GLGetBufferParameteri64vRobustANGLE,
3471 std::move(paramBuffer));
3472 }
3473
CaptureSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLuint pname,GLsizei bufSize,const GLint * param)3474 CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
3475 bool isCallValid,
3476 SamplerID samplerPacked,
3477 GLuint pname,
3478 GLsizei bufSize,
3479 const GLint *param)
3480 {
3481 ParamBuffer paramBuffer;
3482
3483 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3484 paramBuffer.addValueParam("pname", ParamType::TGLuint, pname);
3485 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3486
3487 if (isCallValid)
3488 {
3489 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
3490 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
3491 CaptureSamplerParameterivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
3492 bufSize, param, ¶mParam);
3493 paramBuffer.addParam(std::move(paramParam));
3494 }
3495 else
3496 {
3497 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
3498 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
3499 ¶mParam.value);
3500 paramBuffer.addParam(std::move(paramParam));
3501 }
3502
3503 return CallCapture(angle::EntryPoint::GLSamplerParameterivRobustANGLE, std::move(paramBuffer));
3504 }
3505
CaptureSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLfloat * param)3506 CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
3507 bool isCallValid,
3508 SamplerID samplerPacked,
3509 GLenum pname,
3510 GLsizei bufSize,
3511 const GLfloat *param)
3512 {
3513 ParamBuffer paramBuffer;
3514
3515 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3516 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3517 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3518
3519 if (isCallValid)
3520 {
3521 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
3522 InitParamValue(ParamType::TGLfloatConstPointer, param, ¶mParam.value);
3523 CaptureSamplerParameterfvRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
3524 bufSize, param, ¶mParam);
3525 paramBuffer.addParam(std::move(paramParam));
3526 }
3527 else
3528 {
3529 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
3530 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
3531 ¶mParam.value);
3532 paramBuffer.addParam(std::move(paramParam));
3533 }
3534
3535 return CallCapture(angle::EntryPoint::GLSamplerParameterfvRobustANGLE, std::move(paramBuffer));
3536 }
3537
CaptureGetSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3538 CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
3539 bool isCallValid,
3540 SamplerID samplerPacked,
3541 GLenum pname,
3542 GLsizei bufSize,
3543 GLsizei *length,
3544 GLint *params)
3545 {
3546 ParamBuffer paramBuffer;
3547
3548 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3549 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3550 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3551
3552 if (isCallValid)
3553 {
3554 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3555 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3556 CaptureGetSamplerParameterivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3557 bufSize, length, params, &lengthParam);
3558 paramBuffer.addParam(std::move(lengthParam));
3559 }
3560 else
3561 {
3562 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3563 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3564 &lengthParam.value);
3565 paramBuffer.addParam(std::move(lengthParam));
3566 }
3567
3568 if (isCallValid)
3569 {
3570 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3571 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3572 CaptureGetSamplerParameterivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3573 bufSize, length, params, ¶msParam);
3574 paramBuffer.addParam(std::move(paramsParam));
3575 }
3576 else
3577 {
3578 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3579 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3580 paramBuffer.addParam(std::move(paramsParam));
3581 }
3582
3583 return CallCapture(angle::EntryPoint::GLGetSamplerParameterivRobustANGLE,
3584 std::move(paramBuffer));
3585 }
3586
CaptureGetSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3587 CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
3588 bool isCallValid,
3589 SamplerID samplerPacked,
3590 GLenum pname,
3591 GLsizei bufSize,
3592 GLsizei *length,
3593 GLfloat *params)
3594 {
3595 ParamBuffer paramBuffer;
3596
3597 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3598 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3599 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3600
3601 if (isCallValid)
3602 {
3603 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3604 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3605 CaptureGetSamplerParameterfvRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3606 bufSize, length, params, &lengthParam);
3607 paramBuffer.addParam(std::move(lengthParam));
3608 }
3609 else
3610 {
3611 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3612 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3613 &lengthParam.value);
3614 paramBuffer.addParam(std::move(lengthParam));
3615 }
3616
3617 if (isCallValid)
3618 {
3619 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3620 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3621 CaptureGetSamplerParameterfvRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3622 bufSize, length, params, ¶msParam);
3623 paramBuffer.addParam(std::move(paramsParam));
3624 }
3625 else
3626 {
3627 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3628 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3629 ¶msParam.value);
3630 paramBuffer.addParam(std::move(paramsParam));
3631 }
3632
3633 return CallCapture(angle::EntryPoint::GLGetSamplerParameterfvRobustANGLE,
3634 std::move(paramBuffer));
3635 }
3636
CaptureGetFramebufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3637 CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
3638 bool isCallValid,
3639 GLenum target,
3640 GLenum pname,
3641 GLsizei bufSize,
3642 GLsizei *length,
3643 GLint *params)
3644 {
3645 ParamBuffer paramBuffer;
3646
3647 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3648 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3649 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3650
3651 if (isCallValid)
3652 {
3653 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3654 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3655 CaptureGetFramebufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
3656 bufSize, length, params, &lengthParam);
3657 paramBuffer.addParam(std::move(lengthParam));
3658 }
3659 else
3660 {
3661 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3662 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3663 &lengthParam.value);
3664 paramBuffer.addParam(std::move(lengthParam));
3665 }
3666
3667 if (isCallValid)
3668 {
3669 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3670 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3671 CaptureGetFramebufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
3672 bufSize, length, params, ¶msParam);
3673 paramBuffer.addParam(std::move(paramsParam));
3674 }
3675 else
3676 {
3677 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3678 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3679 paramBuffer.addParam(std::move(paramsParam));
3680 }
3681
3682 return CallCapture(angle::EntryPoint::GLGetFramebufferParameterivRobustANGLE,
3683 std::move(paramBuffer));
3684 }
3685
CaptureGetProgramInterfaceivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3686 CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
3687 bool isCallValid,
3688 ShaderProgramID programPacked,
3689 GLenum programInterface,
3690 GLenum pname,
3691 GLsizei bufSize,
3692 GLsizei *length,
3693 GLint *params)
3694 {
3695 ParamBuffer paramBuffer;
3696
3697 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3698 paramBuffer.addEnumParam("programInterface", GLESEnum::AllEnums, ParamType::TGLenum,
3699 programInterface);
3700 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3701 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3702
3703 if (isCallValid)
3704 {
3705 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3706 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3707 CaptureGetProgramInterfaceivRobustANGLE_length(glState, isCallValid, programPacked,
3708 programInterface, pname, bufSize, length,
3709 params, &lengthParam);
3710 paramBuffer.addParam(std::move(lengthParam));
3711 }
3712 else
3713 {
3714 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3715 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3716 &lengthParam.value);
3717 paramBuffer.addParam(std::move(lengthParam));
3718 }
3719
3720 if (isCallValid)
3721 {
3722 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3723 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3724 CaptureGetProgramInterfaceivRobustANGLE_params(glState, isCallValid, programPacked,
3725 programInterface, pname, bufSize, length,
3726 params, ¶msParam);
3727 paramBuffer.addParam(std::move(paramsParam));
3728 }
3729 else
3730 {
3731 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3732 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3733 paramBuffer.addParam(std::move(paramsParam));
3734 }
3735
3736 return CallCapture(angle::EntryPoint::GLGetProgramInterfaceivRobustANGLE,
3737 std::move(paramBuffer));
3738 }
3739
CaptureGetBooleani_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)3740 CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
3741 bool isCallValid,
3742 GLenum target,
3743 GLuint index,
3744 GLsizei bufSize,
3745 GLsizei *length,
3746 GLboolean *data)
3747 {
3748 ParamBuffer paramBuffer;
3749
3750 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
3751 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3752 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3753
3754 if (isCallValid)
3755 {
3756 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3757 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3758 CaptureGetBooleani_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
3759 data, &lengthParam);
3760 paramBuffer.addParam(std::move(lengthParam));
3761 }
3762 else
3763 {
3764 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3765 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3766 &lengthParam.value);
3767 paramBuffer.addParam(std::move(lengthParam));
3768 }
3769
3770 if (isCallValid)
3771 {
3772 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
3773 InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
3774 CaptureGetBooleani_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3775 data, &dataParam);
3776 paramBuffer.addParam(std::move(dataParam));
3777 }
3778 else
3779 {
3780 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
3781 InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
3782 &dataParam.value);
3783 paramBuffer.addParam(std::move(dataParam));
3784 }
3785
3786 return CallCapture(angle::EntryPoint::GLGetBooleani_vRobustANGLE, std::move(paramBuffer));
3787 }
3788
CaptureGetMultisamplefvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)3789 CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
3790 bool isCallValid,
3791 GLenum pname,
3792 GLuint index,
3793 GLsizei bufSize,
3794 GLsizei *length,
3795 GLfloat *val)
3796 {
3797 ParamBuffer paramBuffer;
3798
3799 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3800 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3801 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3802
3803 if (isCallValid)
3804 {
3805 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3806 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3807 CaptureGetMultisamplefvRobustANGLE_length(glState, isCallValid, pname, index, bufSize,
3808 length, val, &lengthParam);
3809 paramBuffer.addParam(std::move(lengthParam));
3810 }
3811 else
3812 {
3813 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3814 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3815 &lengthParam.value);
3816 paramBuffer.addParam(std::move(lengthParam));
3817 }
3818
3819 if (isCallValid)
3820 {
3821 ParamCapture valParam("val", ParamType::TGLfloatPointer);
3822 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
3823 CaptureGetMultisamplefvRobustANGLE_val(glState, isCallValid, pname, index, bufSize, length,
3824 val, &valParam);
3825 paramBuffer.addParam(std::move(valParam));
3826 }
3827 else
3828 {
3829 ParamCapture valParam("val", ParamType::TGLfloatPointer);
3830 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3831 &valParam.value);
3832 paramBuffer.addParam(std::move(valParam));
3833 }
3834
3835 return CallCapture(angle::EntryPoint::GLGetMultisamplefvRobustANGLE, std::move(paramBuffer));
3836 }
3837
CaptureGetTexLevelParameterivRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3838 CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
3839 bool isCallValid,
3840 TextureTarget targetPacked,
3841 GLint level,
3842 GLenum pname,
3843 GLsizei bufSize,
3844 GLsizei *length,
3845 GLint *params)
3846 {
3847 ParamBuffer paramBuffer;
3848
3849 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
3850 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3851 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3852 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3853
3854 if (isCallValid)
3855 {
3856 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3857 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3858 CaptureGetTexLevelParameterivRobustANGLE_length(glState, isCallValid, targetPacked, level,
3859 pname, bufSize, length, params,
3860 &lengthParam);
3861 paramBuffer.addParam(std::move(lengthParam));
3862 }
3863 else
3864 {
3865 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3866 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3867 &lengthParam.value);
3868 paramBuffer.addParam(std::move(lengthParam));
3869 }
3870
3871 if (isCallValid)
3872 {
3873 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3874 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3875 CaptureGetTexLevelParameterivRobustANGLE_params(glState, isCallValid, targetPacked, level,
3876 pname, bufSize, length, params,
3877 ¶msParam);
3878 paramBuffer.addParam(std::move(paramsParam));
3879 }
3880 else
3881 {
3882 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3883 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3884 paramBuffer.addParam(std::move(paramsParam));
3885 }
3886
3887 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterivRobustANGLE,
3888 std::move(paramBuffer));
3889 }
3890
CaptureGetTexLevelParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3891 CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
3892 bool isCallValid,
3893 TextureTarget targetPacked,
3894 GLint level,
3895 GLenum pname,
3896 GLsizei bufSize,
3897 GLsizei *length,
3898 GLfloat *params)
3899 {
3900 ParamBuffer paramBuffer;
3901
3902 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
3903 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3904 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3905 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3906
3907 if (isCallValid)
3908 {
3909 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3910 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3911 CaptureGetTexLevelParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, level,
3912 pname, bufSize, length, params,
3913 &lengthParam);
3914 paramBuffer.addParam(std::move(lengthParam));
3915 }
3916 else
3917 {
3918 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3919 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3920 &lengthParam.value);
3921 paramBuffer.addParam(std::move(lengthParam));
3922 }
3923
3924 if (isCallValid)
3925 {
3926 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3927 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3928 CaptureGetTexLevelParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, level,
3929 pname, bufSize, length, params,
3930 ¶msParam);
3931 paramBuffer.addParam(std::move(paramsParam));
3932 }
3933 else
3934 {
3935 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3936 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3937 ¶msParam.value);
3938 paramBuffer.addParam(std::move(paramsParam));
3939 }
3940
3941 return CallCapture(angle::EntryPoint::GLGetTexLevelParameterfvRobustANGLE,
3942 std::move(paramBuffer));
3943 }
3944
CaptureGetPointervRobustANGLERobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)3945 CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
3946 bool isCallValid,
3947 GLenum pname,
3948 GLsizei bufSize,
3949 GLsizei *length,
3950 void **params)
3951 {
3952 ParamBuffer paramBuffer;
3953
3954 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
3955 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3956
3957 if (isCallValid)
3958 {
3959 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3960 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3961 CaptureGetPointervRobustANGLERobustANGLE_length(glState, isCallValid, pname, bufSize,
3962 length, params, &lengthParam);
3963 paramBuffer.addParam(std::move(lengthParam));
3964 }
3965 else
3966 {
3967 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3968 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3969 &lengthParam.value);
3970 paramBuffer.addParam(std::move(lengthParam));
3971 }
3972
3973 if (isCallValid)
3974 {
3975 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3976 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
3977 CaptureGetPointervRobustANGLERobustANGLE_params(glState, isCallValid, pname, bufSize,
3978 length, params, ¶msParam);
3979 paramBuffer.addParam(std::move(paramsParam));
3980 }
3981 else
3982 {
3983 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3984 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
3985 ¶msParam.value);
3986 paramBuffer.addParam(std::move(paramsParam));
3987 }
3988
3989 return CallCapture(angle::EntryPoint::GLGetPointervRobustANGLERobustANGLE,
3990 std::move(paramBuffer));
3991 }
3992
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)3993 CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
3994 bool isCallValid,
3995 GLint x,
3996 GLint y,
3997 GLsizei width,
3998 GLsizei height,
3999 GLenum format,
4000 GLenum type,
4001 GLsizei bufSize,
4002 GLsizei *length,
4003 GLsizei *columns,
4004 GLsizei *rows,
4005 void *data)
4006 {
4007 ParamBuffer paramBuffer;
4008
4009 paramBuffer.addValueParam("x", ParamType::TGLint, x);
4010 paramBuffer.addValueParam("y", ParamType::TGLint, y);
4011 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
4012 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
4013 paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format);
4014 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
4015 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4016
4017 if (isCallValid)
4018 {
4019 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4020 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4021 CaptureReadnPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format,
4022 type, bufSize, length, columns, rows, data,
4023 &lengthParam);
4024 paramBuffer.addParam(std::move(lengthParam));
4025 }
4026 else
4027 {
4028 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4029 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4030 &lengthParam.value);
4031 paramBuffer.addParam(std::move(lengthParam));
4032 }
4033
4034 if (isCallValid)
4035 {
4036 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
4037 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
4038 CaptureReadnPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format,
4039 type, bufSize, length, columns, rows, data,
4040 &columnsParam);
4041 paramBuffer.addParam(std::move(columnsParam));
4042 }
4043 else
4044 {
4045 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
4046 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4047 &columnsParam.value);
4048 paramBuffer.addParam(std::move(columnsParam));
4049 }
4050
4051 if (isCallValid)
4052 {
4053 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
4054 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
4055 CaptureReadnPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
4056 bufSize, length, columns, rows, data, &rowsParam);
4057 paramBuffer.addParam(std::move(rowsParam));
4058 }
4059 else
4060 {
4061 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
4062 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4063 &rowsParam.value);
4064 paramBuffer.addParam(std::move(rowsParam));
4065 }
4066
4067 if (isCallValid)
4068 {
4069 ParamCapture dataParam("data", ParamType::TvoidPointer);
4070 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
4071 CaptureReadnPixelsRobustANGLE_data(glState, isCallValid, x, y, width, height, format, type,
4072 bufSize, length, columns, rows, data, &dataParam);
4073 paramBuffer.addParam(std::move(dataParam));
4074 }
4075 else
4076 {
4077 ParamCapture dataParam("data", ParamType::TvoidPointer);
4078 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
4079 paramBuffer.addParam(std::move(dataParam));
4080 }
4081
4082 return CallCapture(angle::EntryPoint::GLReadnPixelsRobustANGLE, std::move(paramBuffer));
4083 }
4084
CaptureGetnUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)4085 CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
4086 bool isCallValid,
4087 ShaderProgramID programPacked,
4088 UniformLocation locationPacked,
4089 GLsizei bufSize,
4090 GLsizei *length,
4091 GLfloat *params)
4092 {
4093 ParamBuffer paramBuffer;
4094
4095 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4096 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4097 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4098
4099 if (isCallValid)
4100 {
4101 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4102 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4103 CaptureGetnUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
4104 bufSize, length, params, &lengthParam);
4105 paramBuffer.addParam(std::move(lengthParam));
4106 }
4107 else
4108 {
4109 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4110 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4111 &lengthParam.value);
4112 paramBuffer.addParam(std::move(lengthParam));
4113 }
4114
4115 if (isCallValid)
4116 {
4117 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4118 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
4119 CaptureGetnUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
4120 bufSize, length, params, ¶msParam);
4121 paramBuffer.addParam(std::move(paramsParam));
4122 }
4123 else
4124 {
4125 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4126 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
4127 ¶msParam.value);
4128 paramBuffer.addParam(std::move(paramsParam));
4129 }
4130
4131 return CallCapture(angle::EntryPoint::GLGetnUniformfvRobustANGLE, std::move(paramBuffer));
4132 }
4133
CaptureGetnUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)4134 CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
4135 bool isCallValid,
4136 ShaderProgramID programPacked,
4137 UniformLocation locationPacked,
4138 GLsizei bufSize,
4139 GLsizei *length,
4140 GLint *params)
4141 {
4142 ParamBuffer paramBuffer;
4143
4144 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4145 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4146 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4147
4148 if (isCallValid)
4149 {
4150 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4151 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4152 CaptureGetnUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
4153 bufSize, length, params, &lengthParam);
4154 paramBuffer.addParam(std::move(lengthParam));
4155 }
4156 else
4157 {
4158 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4159 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4160 &lengthParam.value);
4161 paramBuffer.addParam(std::move(lengthParam));
4162 }
4163
4164 if (isCallValid)
4165 {
4166 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4167 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4168 CaptureGetnUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
4169 bufSize, length, params, ¶msParam);
4170 paramBuffer.addParam(std::move(paramsParam));
4171 }
4172 else
4173 {
4174 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4175 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4176 paramBuffer.addParam(std::move(paramsParam));
4177 }
4178
4179 return CallCapture(angle::EntryPoint::GLGetnUniformivRobustANGLE, std::move(paramBuffer));
4180 }
4181
CaptureGetnUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)4182 CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
4183 bool isCallValid,
4184 ShaderProgramID programPacked,
4185 UniformLocation locationPacked,
4186 GLsizei bufSize,
4187 GLsizei *length,
4188 GLuint *params)
4189 {
4190 ParamBuffer paramBuffer;
4191
4192 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4193 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4194 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4195
4196 if (isCallValid)
4197 {
4198 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4199 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4200 CaptureGetnUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
4201 bufSize, length, params, &lengthParam);
4202 paramBuffer.addParam(std::move(lengthParam));
4203 }
4204 else
4205 {
4206 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4207 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4208 &lengthParam.value);
4209 paramBuffer.addParam(std::move(lengthParam));
4210 }
4211
4212 if (isCallValid)
4213 {
4214 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4215 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4216 CaptureGetnUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
4217 bufSize, length, params, ¶msParam);
4218 paramBuffer.addParam(std::move(paramsParam));
4219 }
4220 else
4221 {
4222 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4223 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4224 ¶msParam.value);
4225 paramBuffer.addParam(std::move(paramsParam));
4226 }
4227
4228 return CallCapture(angle::EntryPoint::GLGetnUniformuivRobustANGLE, std::move(paramBuffer));
4229 }
4230
CaptureTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)4231 CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
4232 bool isCallValid,
4233 TextureType targetPacked,
4234 GLenum pname,
4235 GLsizei bufSize,
4236 const GLint *params)
4237 {
4238 ParamBuffer paramBuffer;
4239
4240 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4241 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4242 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4243
4244 if (isCallValid)
4245 {
4246 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
4247 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
4248 CaptureTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
4249 params, ¶msParam);
4250 paramBuffer.addParam(std::move(paramsParam));
4251 }
4252 else
4253 {
4254 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
4255 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
4256 ¶msParam.value);
4257 paramBuffer.addParam(std::move(paramsParam));
4258 }
4259
4260 return CallCapture(angle::EntryPoint::GLTexParameterIivRobustANGLE, std::move(paramBuffer));
4261 }
4262
CaptureTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLuint * params)4263 CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
4264 bool isCallValid,
4265 TextureType targetPacked,
4266 GLenum pname,
4267 GLsizei bufSize,
4268 const GLuint *params)
4269 {
4270 ParamBuffer paramBuffer;
4271
4272 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4273 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4274 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4275
4276 if (isCallValid)
4277 {
4278 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
4279 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
4280 CaptureTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
4281 bufSize, params, ¶msParam);
4282 paramBuffer.addParam(std::move(paramsParam));
4283 }
4284 else
4285 {
4286 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
4287 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
4288 ¶msParam.value);
4289 paramBuffer.addParam(std::move(paramsParam));
4290 }
4291
4292 return CallCapture(angle::EntryPoint::GLTexParameterIuivRobustANGLE, std::move(paramBuffer));
4293 }
4294
CaptureGetTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4295 CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
4296 bool isCallValid,
4297 TextureType targetPacked,
4298 GLenum pname,
4299 GLsizei bufSize,
4300 GLsizei *length,
4301 GLint *params)
4302 {
4303 ParamBuffer paramBuffer;
4304
4305 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4306 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4307 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4308
4309 if (isCallValid)
4310 {
4311 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4312 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4313 CaptureGetTexParameterIivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
4314 bufSize, length, params, &lengthParam);
4315 paramBuffer.addParam(std::move(lengthParam));
4316 }
4317 else
4318 {
4319 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4320 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4321 &lengthParam.value);
4322 paramBuffer.addParam(std::move(lengthParam));
4323 }
4324
4325 if (isCallValid)
4326 {
4327 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4328 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4329 CaptureGetTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
4330 bufSize, length, params, ¶msParam);
4331 paramBuffer.addParam(std::move(paramsParam));
4332 }
4333 else
4334 {
4335 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4336 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4337 paramBuffer.addParam(std::move(paramsParam));
4338 }
4339
4340 return CallCapture(angle::EntryPoint::GLGetTexParameterIivRobustANGLE, std::move(paramBuffer));
4341 }
4342
CaptureGetTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)4343 CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
4344 bool isCallValid,
4345 TextureType targetPacked,
4346 GLenum pname,
4347 GLsizei bufSize,
4348 GLsizei *length,
4349 GLuint *params)
4350 {
4351 ParamBuffer paramBuffer;
4352
4353 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4354 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4355 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4356
4357 if (isCallValid)
4358 {
4359 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4360 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4361 CaptureGetTexParameterIuivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
4362 bufSize, length, params, &lengthParam);
4363 paramBuffer.addParam(std::move(lengthParam));
4364 }
4365 else
4366 {
4367 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4368 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4369 &lengthParam.value);
4370 paramBuffer.addParam(std::move(lengthParam));
4371 }
4372
4373 if (isCallValid)
4374 {
4375 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4376 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4377 CaptureGetTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
4378 bufSize, length, params, ¶msParam);
4379 paramBuffer.addParam(std::move(paramsParam));
4380 }
4381 else
4382 {
4383 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4384 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4385 ¶msParam.value);
4386 paramBuffer.addParam(std::move(paramsParam));
4387 }
4388
4389 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivRobustANGLE, std::move(paramBuffer));
4390 }
4391
CaptureSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLint * param)4392 CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
4393 bool isCallValid,
4394 SamplerID samplerPacked,
4395 GLenum pname,
4396 GLsizei bufSize,
4397 const GLint *param)
4398 {
4399 ParamBuffer paramBuffer;
4400
4401 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4402 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4403 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4404
4405 if (isCallValid)
4406 {
4407 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
4408 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
4409 CaptureSamplerParameterIivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
4410 bufSize, param, ¶mParam);
4411 paramBuffer.addParam(std::move(paramParam));
4412 }
4413 else
4414 {
4415 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
4416 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
4417 ¶mParam.value);
4418 paramBuffer.addParam(std::move(paramParam));
4419 }
4420
4421 return CallCapture(angle::EntryPoint::GLSamplerParameterIivRobustANGLE, std::move(paramBuffer));
4422 }
4423
CaptureSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLuint * param)4424 CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
4425 bool isCallValid,
4426 SamplerID samplerPacked,
4427 GLenum pname,
4428 GLsizei bufSize,
4429 const GLuint *param)
4430 {
4431 ParamBuffer paramBuffer;
4432
4433 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4434 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4435 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4436
4437 if (isCallValid)
4438 {
4439 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
4440 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
4441 CaptureSamplerParameterIuivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
4442 bufSize, param, ¶mParam);
4443 paramBuffer.addParam(std::move(paramParam));
4444 }
4445 else
4446 {
4447 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
4448 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
4449 ¶mParam.value);
4450 paramBuffer.addParam(std::move(paramParam));
4451 }
4452
4453 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivRobustANGLE,
4454 std::move(paramBuffer));
4455 }
4456
CaptureGetSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4457 CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
4458 bool isCallValid,
4459 SamplerID samplerPacked,
4460 GLenum pname,
4461 GLsizei bufSize,
4462 GLsizei *length,
4463 GLint *params)
4464 {
4465 ParamBuffer paramBuffer;
4466
4467 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4468 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4469 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4470
4471 if (isCallValid)
4472 {
4473 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4474 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4475 CaptureGetSamplerParameterIivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
4476 bufSize, length, params, &lengthParam);
4477 paramBuffer.addParam(std::move(lengthParam));
4478 }
4479 else
4480 {
4481 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4482 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4483 &lengthParam.value);
4484 paramBuffer.addParam(std::move(lengthParam));
4485 }
4486
4487 if (isCallValid)
4488 {
4489 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4490 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4491 CaptureGetSamplerParameterIivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
4492 bufSize, length, params, ¶msParam);
4493 paramBuffer.addParam(std::move(paramsParam));
4494 }
4495 else
4496 {
4497 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4498 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4499 paramBuffer.addParam(std::move(paramsParam));
4500 }
4501
4502 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivRobustANGLE,
4503 std::move(paramBuffer));
4504 }
4505
CaptureGetSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)4506 CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
4507 bool isCallValid,
4508 SamplerID samplerPacked,
4509 GLenum pname,
4510 GLsizei bufSize,
4511 GLsizei *length,
4512 GLuint *params)
4513 {
4514 ParamBuffer paramBuffer;
4515
4516 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
4517 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4518 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4519
4520 if (isCallValid)
4521 {
4522 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4523 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4524 CaptureGetSamplerParameterIuivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
4525 bufSize, length, params, &lengthParam);
4526 paramBuffer.addParam(std::move(lengthParam));
4527 }
4528 else
4529 {
4530 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4531 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4532 &lengthParam.value);
4533 paramBuffer.addParam(std::move(lengthParam));
4534 }
4535
4536 if (isCallValid)
4537 {
4538 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4539 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4540 CaptureGetSamplerParameterIuivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
4541 bufSize, length, params, ¶msParam);
4542 paramBuffer.addParam(std::move(paramsParam));
4543 }
4544 else
4545 {
4546 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4547 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4548 ¶msParam.value);
4549 paramBuffer.addParam(std::move(paramsParam));
4550 }
4551
4552 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivRobustANGLE,
4553 std::move(paramBuffer));
4554 }
4555
CaptureGetQueryObjectivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4556 CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
4557 bool isCallValid,
4558 QueryID idPacked,
4559 GLenum pname,
4560 GLsizei bufSize,
4561 GLsizei *length,
4562 GLint *params)
4563 {
4564 ParamBuffer paramBuffer;
4565
4566 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4567 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4568 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4569
4570 if (isCallValid)
4571 {
4572 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4573 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4574 CaptureGetQueryObjectivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4575 length, params, &lengthParam);
4576 paramBuffer.addParam(std::move(lengthParam));
4577 }
4578 else
4579 {
4580 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4581 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4582 &lengthParam.value);
4583 paramBuffer.addParam(std::move(lengthParam));
4584 }
4585
4586 if (isCallValid)
4587 {
4588 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4589 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4590 CaptureGetQueryObjectivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4591 length, params, ¶msParam);
4592 paramBuffer.addParam(std::move(paramsParam));
4593 }
4594 else
4595 {
4596 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4597 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4598 paramBuffer.addParam(std::move(paramsParam));
4599 }
4600
4601 return CallCapture(angle::EntryPoint::GLGetQueryObjectivRobustANGLE, std::move(paramBuffer));
4602 }
4603
CaptureGetQueryObjecti64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)4604 CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
4605 bool isCallValid,
4606 QueryID idPacked,
4607 GLenum pname,
4608 GLsizei bufSize,
4609 GLsizei *length,
4610 GLint64 *params)
4611 {
4612 ParamBuffer paramBuffer;
4613
4614 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4615 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4616 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4617
4618 if (isCallValid)
4619 {
4620 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4621 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4622 CaptureGetQueryObjecti64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4623 length, params, &lengthParam);
4624 paramBuffer.addParam(std::move(lengthParam));
4625 }
4626 else
4627 {
4628 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4629 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4630 &lengthParam.value);
4631 paramBuffer.addParam(std::move(lengthParam));
4632 }
4633
4634 if (isCallValid)
4635 {
4636 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4637 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
4638 CaptureGetQueryObjecti64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4639 length, params, ¶msParam);
4640 paramBuffer.addParam(std::move(paramsParam));
4641 }
4642 else
4643 {
4644 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4645 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
4646 ¶msParam.value);
4647 paramBuffer.addParam(std::move(paramsParam));
4648 }
4649
4650 return CallCapture(angle::EntryPoint::GLGetQueryObjecti64vRobustANGLE, std::move(paramBuffer));
4651 }
4652
CaptureGetQueryObjectui64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)4653 CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
4654 bool isCallValid,
4655 QueryID idPacked,
4656 GLenum pname,
4657 GLsizei bufSize,
4658 GLsizei *length,
4659 GLuint64 *params)
4660 {
4661 ParamBuffer paramBuffer;
4662
4663 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4664 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
4665 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4666
4667 if (isCallValid)
4668 {
4669 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4670 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4671 CaptureGetQueryObjectui64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4672 length, params, &lengthParam);
4673 paramBuffer.addParam(std::move(lengthParam));
4674 }
4675 else
4676 {
4677 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4678 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4679 &lengthParam.value);
4680 paramBuffer.addParam(std::move(lengthParam));
4681 }
4682
4683 if (isCallValid)
4684 {
4685 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4686 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
4687 CaptureGetQueryObjectui64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4688 length, params, ¶msParam);
4689 paramBuffer.addParam(std::move(paramsParam));
4690 }
4691 else
4692 {
4693 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4694 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
4695 ¶msParam.value);
4696 paramBuffer.addParam(std::move(paramsParam));
4697 }
4698
4699 return CallCapture(angle::EntryPoint::GLGetQueryObjectui64vRobustANGLE, std::move(paramBuffer));
4700 }
4701
CaptureImportSemaphoreZirconHandleANGLE(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLuint handle)4702 CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
4703 bool isCallValid,
4704 SemaphoreID semaphorePacked,
4705 HandleType handleTypePacked,
4706 GLuint handle)
4707 {
4708 ParamBuffer paramBuffer;
4709
4710 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4711 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
4712 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
4713
4714 return CallCapture(angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE,
4715 std::move(paramBuffer));
4716 }
4717
CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State & glState,bool isCallValid,GLint plane,GLenum internalformat)4718 CallCapture CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State &glState,
4719 bool isCallValid,
4720 GLint plane,
4721 GLenum internalformat)
4722 {
4723 ParamBuffer paramBuffer;
4724
4725 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4726 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
4727 internalformat);
4728
4729 return CallCapture(angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE,
4730 std::move(paramBuffer));
4731 }
4732
CaptureFramebufferTexturePixelLocalStorageANGLE(const State & glState,bool isCallValid,GLint plane,TextureID backingtexturePacked,GLint level,GLint layer)4733 CallCapture CaptureFramebufferTexturePixelLocalStorageANGLE(const State &glState,
4734 bool isCallValid,
4735 GLint plane,
4736 TextureID backingtexturePacked,
4737 GLint level,
4738 GLint layer)
4739 {
4740 ParamBuffer paramBuffer;
4741
4742 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4743 paramBuffer.addValueParam("backingtexturePacked", ParamType::TTextureID, backingtexturePacked);
4744 paramBuffer.addValueParam("level", ParamType::TGLint, level);
4745 paramBuffer.addValueParam("layer", ParamType::TGLint, layer);
4746
4747 return CallCapture(angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE,
4748 std::move(paramBuffer));
4749 }
4750
CaptureFramebufferPixelLocalClearValuefvANGLE(const State & glState,bool isCallValid,GLint plane,const GLfloat * value)4751 CallCapture CaptureFramebufferPixelLocalClearValuefvANGLE(const State &glState,
4752 bool isCallValid,
4753 GLint plane,
4754 const GLfloat *value)
4755 {
4756 ParamBuffer paramBuffer;
4757
4758 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4759
4760 if (isCallValid)
4761 {
4762 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
4763 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
4764 CaptureFramebufferPixelLocalClearValuefvANGLE_value(glState, isCallValid, plane, value,
4765 &valueParam);
4766 paramBuffer.addParam(std::move(valueParam));
4767 }
4768 else
4769 {
4770 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
4771 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
4772 &valueParam.value);
4773 paramBuffer.addParam(std::move(valueParam));
4774 }
4775
4776 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE,
4777 std::move(paramBuffer));
4778 }
4779
CaptureFramebufferPixelLocalClearValueivANGLE(const State & glState,bool isCallValid,GLint plane,const GLint * value)4780 CallCapture CaptureFramebufferPixelLocalClearValueivANGLE(const State &glState,
4781 bool isCallValid,
4782 GLint plane,
4783 const GLint *value)
4784 {
4785 ParamBuffer paramBuffer;
4786
4787 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4788
4789 if (isCallValid)
4790 {
4791 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
4792 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
4793 CaptureFramebufferPixelLocalClearValueivANGLE_value(glState, isCallValid, plane, value,
4794 &valueParam);
4795 paramBuffer.addParam(std::move(valueParam));
4796 }
4797 else
4798 {
4799 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
4800 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
4801 &valueParam.value);
4802 paramBuffer.addParam(std::move(valueParam));
4803 }
4804
4805 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE,
4806 std::move(paramBuffer));
4807 }
4808
CaptureFramebufferPixelLocalClearValueuivANGLE(const State & glState,bool isCallValid,GLint plane,const GLuint * value)4809 CallCapture CaptureFramebufferPixelLocalClearValueuivANGLE(const State &glState,
4810 bool isCallValid,
4811 GLint plane,
4812 const GLuint *value)
4813 {
4814 ParamBuffer paramBuffer;
4815
4816 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4817
4818 if (isCallValid)
4819 {
4820 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
4821 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
4822 CaptureFramebufferPixelLocalClearValueuivANGLE_value(glState, isCallValid, plane, value,
4823 &valueParam);
4824 paramBuffer.addParam(std::move(valueParam));
4825 }
4826 else
4827 {
4828 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
4829 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
4830 &valueParam.value);
4831 paramBuffer.addParam(std::move(valueParam));
4832 }
4833
4834 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE,
4835 std::move(paramBuffer));
4836 }
4837
CaptureBeginPixelLocalStorageANGLE(const State & glState,bool isCallValid,GLsizei n,const GLenum * loadops)4838 CallCapture CaptureBeginPixelLocalStorageANGLE(const State &glState,
4839 bool isCallValid,
4840 GLsizei n,
4841 const GLenum *loadops)
4842 {
4843 ParamBuffer paramBuffer;
4844
4845 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4846
4847 if (isCallValid)
4848 {
4849 ParamCapture loadopsParam("loadops", ParamType::TGLenumConstPointer);
4850 InitParamValue(ParamType::TGLenumConstPointer, loadops, &loadopsParam.value);
4851 CaptureBeginPixelLocalStorageANGLE_loadops(glState, isCallValid, n, loadops, &loadopsParam);
4852 paramBuffer.addParam(std::move(loadopsParam));
4853 }
4854 else
4855 {
4856 ParamCapture loadopsParam("loadops", ParamType::TGLenumConstPointer);
4857 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
4858 &loadopsParam.value);
4859 paramBuffer.addParam(std::move(loadopsParam));
4860 }
4861
4862 return CallCapture(angle::EntryPoint::GLBeginPixelLocalStorageANGLE, std::move(paramBuffer));
4863 }
4864
CaptureEndPixelLocalStorageANGLE(const State & glState,bool isCallValid,GLsizei n,const GLenum * storeops)4865 CallCapture CaptureEndPixelLocalStorageANGLE(const State &glState,
4866 bool isCallValid,
4867 GLsizei n,
4868 const GLenum *storeops)
4869 {
4870 ParamBuffer paramBuffer;
4871
4872 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4873
4874 if (isCallValid)
4875 {
4876 ParamCapture storeopsParam("storeops", ParamType::TGLenumConstPointer);
4877 InitParamValue(ParamType::TGLenumConstPointer, storeops, &storeopsParam.value);
4878 CaptureEndPixelLocalStorageANGLE_storeops(glState, isCallValid, n, storeops,
4879 &storeopsParam);
4880 paramBuffer.addParam(std::move(storeopsParam));
4881 }
4882 else
4883 {
4884 ParamCapture storeopsParam("storeops", ParamType::TGLenumConstPointer);
4885 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
4886 &storeopsParam.value);
4887 paramBuffer.addParam(std::move(storeopsParam));
4888 }
4889
4890 return CallCapture(angle::EntryPoint::GLEndPixelLocalStorageANGLE, std::move(paramBuffer));
4891 }
4892
CapturePixelLocalStorageBarrierANGLE(const State & glState,bool isCallValid)4893 CallCapture CapturePixelLocalStorageBarrierANGLE(const State &glState, bool isCallValid)
4894 {
4895 ParamBuffer paramBuffer;
4896
4897 return CallCapture(angle::EntryPoint::GLPixelLocalStorageBarrierANGLE, std::move(paramBuffer));
4898 }
4899
CaptureFramebufferPixelLocalStorageInterruptANGLE(const State & glState,bool isCallValid)4900 CallCapture CaptureFramebufferPixelLocalStorageInterruptANGLE(const State &glState,
4901 bool isCallValid)
4902 {
4903 ParamBuffer paramBuffer;
4904
4905 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalStorageInterruptANGLE,
4906 std::move(paramBuffer));
4907 }
4908
CaptureFramebufferPixelLocalStorageRestoreANGLE(const State & glState,bool isCallValid)4909 CallCapture CaptureFramebufferPixelLocalStorageRestoreANGLE(const State &glState, bool isCallValid)
4910 {
4911 ParamBuffer paramBuffer;
4912
4913 return CallCapture(angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE,
4914 std::move(paramBuffer));
4915 }
4916
CaptureGetFramebufferPixelLocalStorageParameterfvANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLfloat * params)4917 CallCapture CaptureGetFramebufferPixelLocalStorageParameterfvANGLE(const State &glState,
4918 bool isCallValid,
4919 GLint plane,
4920 GLenum pname,
4921 GLfloat *params)
4922 {
4923 ParamBuffer paramBuffer;
4924
4925 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4926 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryFloat, ParamType::TGLenum, pname);
4927
4928 if (isCallValid)
4929 {
4930 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4931 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
4932 CaptureGetFramebufferPixelLocalStorageParameterfvANGLE_params(glState, isCallValid, plane,
4933 pname, params, ¶msParam);
4934 paramBuffer.addParam(std::move(paramsParam));
4935 }
4936 else
4937 {
4938 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
4939 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
4940 ¶msParam.value);
4941 paramBuffer.addParam(std::move(paramsParam));
4942 }
4943
4944 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvANGLE,
4945 std::move(paramBuffer));
4946 }
4947
CaptureGetFramebufferPixelLocalStorageParameterivANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLint * params)4948 CallCapture CaptureGetFramebufferPixelLocalStorageParameterivANGLE(const State &glState,
4949 bool isCallValid,
4950 GLint plane,
4951 GLenum pname,
4952 GLint *params)
4953 {
4954 ParamBuffer paramBuffer;
4955
4956 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4957 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryInt, ParamType::TGLenum, pname);
4958
4959 if (isCallValid)
4960 {
4961 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4962 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4963 CaptureGetFramebufferPixelLocalStorageParameterivANGLE_params(glState, isCallValid, plane,
4964 pname, params, ¶msParam);
4965 paramBuffer.addParam(std::move(paramsParam));
4966 }
4967 else
4968 {
4969 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4970 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4971 paramBuffer.addParam(std::move(paramsParam));
4972 }
4973
4974 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterivANGLE,
4975 std::move(paramBuffer));
4976 }
4977
CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)4978 CallCapture CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE(const State &glState,
4979 bool isCallValid,
4980 GLint plane,
4981 GLenum pname,
4982 GLsizei bufSize,
4983 GLsizei *length,
4984 GLfloat *params)
4985 {
4986 ParamBuffer paramBuffer;
4987
4988 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
4989 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryFloat, ParamType::TGLenum, pname);
4990 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4991
4992 if (isCallValid)
4993 {
4994 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4995 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4996 CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE_length(
4997 glState, isCallValid, plane, pname, bufSize, length, params, &lengthParam);
4998 paramBuffer.addParam(std::move(lengthParam));
4999 }
5000 else
5001 {
5002 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5003 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
5004 &lengthParam.value);
5005 paramBuffer.addParam(std::move(lengthParam));
5006 }
5007
5008 if (isCallValid)
5009 {
5010 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
5011 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
5012 CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE_params(
5013 glState, isCallValid, plane, pname, bufSize, length, params, ¶msParam);
5014 paramBuffer.addParam(std::move(paramsParam));
5015 }
5016 else
5017 {
5018 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
5019 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
5020 ¶msParam.value);
5021 paramBuffer.addParam(std::move(paramsParam));
5022 }
5023
5024 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE,
5025 std::move(paramBuffer));
5026 }
5027
CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE(const State & glState,bool isCallValid,GLint plane,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)5028 CallCapture CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE(const State &glState,
5029 bool isCallValid,
5030 GLint plane,
5031 GLenum pname,
5032 GLsizei bufSize,
5033 GLsizei *length,
5034 GLint *params)
5035 {
5036 ParamBuffer paramBuffer;
5037
5038 paramBuffer.addValueParam("plane", ParamType::TGLint, plane);
5039 paramBuffer.addEnumParam("pname", GLESEnum::PLSQueryInt, ParamType::TGLenum, pname);
5040 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5041
5042 if (isCallValid)
5043 {
5044 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5045 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
5046 CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE_length(
5047 glState, isCallValid, plane, pname, bufSize, length, params, &lengthParam);
5048 paramBuffer.addParam(std::move(lengthParam));
5049 }
5050 else
5051 {
5052 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5053 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
5054 &lengthParam.value);
5055 paramBuffer.addParam(std::move(lengthParam));
5056 }
5057
5058 if (isCallValid)
5059 {
5060 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5061 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5062 CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE_params(
5063 glState, isCallValid, plane, pname, bufSize, length, params, ¶msParam);
5064 paramBuffer.addParam(std::move(paramsParam));
5065 }
5066 else
5067 {
5068 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5069 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
5070 paramBuffer.addParam(std::move(paramsParam));
5071 }
5072
5073 return CallCapture(angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterivRobustANGLE,
5074 std::move(paramBuffer));
5075 }
5076
CaptureTexImage2DExternalANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)5077 CallCapture CaptureTexImage2DExternalANGLE(const State &glState,
5078 bool isCallValid,
5079 TextureTarget targetPacked,
5080 GLint level,
5081 GLint internalformat,
5082 GLsizei width,
5083 GLsizei height,
5084 GLint border,
5085 GLenum format,
5086 GLenum type)
5087 {
5088 ParamBuffer paramBuffer;
5089
5090 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5091 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5092 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
5093 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5094 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5095 paramBuffer.addValueParam("border", ParamType::TGLint, border);
5096 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
5097 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
5098
5099 return CallCapture(angle::EntryPoint::GLTexImage2DExternalANGLE, std::move(paramBuffer));
5100 }
5101
CaptureInvalidateTextureANGLE(const State & glState,bool isCallValid,TextureType targetPacked)5102 CallCapture CaptureInvalidateTextureANGLE(const State &glState,
5103 bool isCallValid,
5104 TextureType targetPacked)
5105 {
5106 ParamBuffer paramBuffer;
5107
5108 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5109
5110 return CallCapture(angle::EntryPoint::GLInvalidateTextureANGLE, std::move(paramBuffer));
5111 }
5112
CaptureTexStorage2DMultisampleANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)5113 CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
5114 bool isCallValid,
5115 TextureType targetPacked,
5116 GLsizei samples,
5117 GLenum internalformat,
5118 GLsizei width,
5119 GLsizei height,
5120 GLboolean fixedsamplelocations)
5121 {
5122 ParamBuffer paramBuffer;
5123
5124 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5125 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5126 paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum,
5127 internalformat);
5128 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5129 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5130 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
5131
5132 return CallCapture(angle::EntryPoint::GLTexStorage2DMultisampleANGLE, std::move(paramBuffer));
5133 }
5134
CaptureGetMultisamplefvANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLfloat * val)5135 CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
5136 bool isCallValid,
5137 GLenum pname,
5138 GLuint index,
5139 GLfloat *val)
5140 {
5141 ParamBuffer paramBuffer;
5142
5143 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
5144 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5145
5146 if (isCallValid)
5147 {
5148 ParamCapture valParam("val", ParamType::TGLfloatPointer);
5149 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
5150 CaptureGetMultisamplefvANGLE_val(glState, isCallValid, pname, index, val, &valParam);
5151 paramBuffer.addParam(std::move(valParam));
5152 }
5153 else
5154 {
5155 ParamCapture valParam("val", ParamType::TGLfloatPointer);
5156 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
5157 &valParam.value);
5158 paramBuffer.addParam(std::move(valParam));
5159 }
5160
5161 return CallCapture(angle::EntryPoint::GLGetMultisamplefvANGLE, std::move(paramBuffer));
5162 }
5163
CaptureSampleMaskiANGLE(const State & glState,bool isCallValid,GLuint maskNumber,GLbitfield mask)5164 CallCapture CaptureSampleMaskiANGLE(const State &glState,
5165 bool isCallValid,
5166 GLuint maskNumber,
5167 GLbitfield mask)
5168 {
5169 ParamBuffer paramBuffer;
5170
5171 paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber);
5172 paramBuffer.addEnumParam("mask", GLESEnum::AllEnums, ParamType::TGLbitfield, mask);
5173
5174 return CallCapture(angle::EntryPoint::GLSampleMaskiANGLE, std::move(paramBuffer));
5175 }
5176
CaptureGetTranslatedShaderSourceANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLsizei bufSize,GLsizei * length,GLchar * source)5177 CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
5178 bool isCallValid,
5179 ShaderProgramID shaderPacked,
5180 GLsizei bufSize,
5181 GLsizei *length,
5182 GLchar *source)
5183 {
5184 ParamBuffer paramBuffer;
5185
5186 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
5187 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5188
5189 if (isCallValid)
5190 {
5191 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5192 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
5193 CaptureGetTranslatedShaderSourceANGLE_length(glState, isCallValid, shaderPacked, bufSize,
5194 length, source, &lengthParam);
5195 paramBuffer.addParam(std::move(lengthParam));
5196 }
5197 else
5198 {
5199 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5200 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
5201 &lengthParam.value);
5202 paramBuffer.addParam(std::move(lengthParam));
5203 }
5204
5205 if (isCallValid)
5206 {
5207 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
5208 InitParamValue(ParamType::TGLcharPointer, source, &sourceParam.value);
5209 CaptureGetTranslatedShaderSourceANGLE_source(glState, isCallValid, shaderPacked, bufSize,
5210 length, source, &sourceParam);
5211 paramBuffer.addParam(std::move(sourceParam));
5212 }
5213 else
5214 {
5215 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
5216 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
5217 &sourceParam.value);
5218 paramBuffer.addParam(std::move(sourceParam));
5219 }
5220
5221 return CallCapture(angle::EntryPoint::GLGetTranslatedShaderSourceANGLE, std::move(paramBuffer));
5222 }
5223
CaptureAcquireTexturesANGLE(const State & glState,bool isCallValid,GLuint numTextures,const TextureID * texturesPacked,const GLenum * layouts)5224 CallCapture CaptureAcquireTexturesANGLE(const State &glState,
5225 bool isCallValid,
5226 GLuint numTextures,
5227 const TextureID *texturesPacked,
5228 const GLenum *layouts)
5229 {
5230 ParamBuffer paramBuffer;
5231
5232 paramBuffer.addValueParam("numTextures", ParamType::TGLuint, numTextures);
5233
5234 if (isCallValid)
5235 {
5236 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5237 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
5238 &texturesPackedParam.value);
5239 CaptureAcquireTexturesANGLE_texturesPacked(glState, isCallValid, numTextures,
5240 texturesPacked, layouts, &texturesPackedParam);
5241 paramBuffer.addParam(std::move(texturesPackedParam));
5242 }
5243 else
5244 {
5245 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5246 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
5247 &texturesPackedParam.value);
5248 paramBuffer.addParam(std::move(texturesPackedParam));
5249 }
5250
5251 if (isCallValid)
5252 {
5253 ParamCapture layoutsParam("layouts", ParamType::TGLenumConstPointer);
5254 InitParamValue(ParamType::TGLenumConstPointer, layouts, &layoutsParam.value);
5255 CaptureAcquireTexturesANGLE_layouts(glState, isCallValid, numTextures, texturesPacked,
5256 layouts, &layoutsParam);
5257 paramBuffer.addParam(std::move(layoutsParam));
5258 }
5259 else
5260 {
5261 ParamCapture layoutsParam("layouts", ParamType::TGLenumConstPointer);
5262 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
5263 &layoutsParam.value);
5264 paramBuffer.addParam(std::move(layoutsParam));
5265 }
5266
5267 return CallCapture(angle::EntryPoint::GLAcquireTexturesANGLE, std::move(paramBuffer));
5268 }
5269
CaptureReleaseTexturesANGLE(const State & glState,bool isCallValid,GLuint numTextures,const TextureID * texturesPacked,GLenum * layouts)5270 CallCapture CaptureReleaseTexturesANGLE(const State &glState,
5271 bool isCallValid,
5272 GLuint numTextures,
5273 const TextureID *texturesPacked,
5274 GLenum *layouts)
5275 {
5276 ParamBuffer paramBuffer;
5277
5278 paramBuffer.addValueParam("numTextures", ParamType::TGLuint, numTextures);
5279
5280 if (isCallValid)
5281 {
5282 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5283 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
5284 &texturesPackedParam.value);
5285 CaptureReleaseTexturesANGLE_texturesPacked(glState, isCallValid, numTextures,
5286 texturesPacked, layouts, &texturesPackedParam);
5287 paramBuffer.addParam(std::move(texturesPackedParam));
5288 }
5289 else
5290 {
5291 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
5292 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
5293 &texturesPackedParam.value);
5294 paramBuffer.addParam(std::move(texturesPackedParam));
5295 }
5296
5297 if (isCallValid)
5298 {
5299 ParamCapture layoutsParam("layouts", ParamType::TGLenumPointer);
5300 InitParamValue(ParamType::TGLenumPointer, layouts, &layoutsParam.value);
5301 CaptureReleaseTexturesANGLE_layouts(glState, isCallValid, numTextures, texturesPacked,
5302 layouts, &layoutsParam);
5303 paramBuffer.addParam(std::move(layoutsParam));
5304 }
5305 else
5306 {
5307 ParamCapture layoutsParam("layouts", ParamType::TGLenumPointer);
5308 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
5309 &layoutsParam.value);
5310 paramBuffer.addParam(std::move(layoutsParam));
5311 }
5312
5313 return CallCapture(angle::EntryPoint::GLReleaseTexturesANGLE, std::move(paramBuffer));
5314 }
5315
CaptureBindUniformLocationCHROMIUM(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,const GLchar * name)5316 CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
5317 bool isCallValid,
5318 ShaderProgramID programPacked,
5319 UniformLocation locationPacked,
5320 const GLchar *name)
5321 {
5322 ParamBuffer paramBuffer;
5323
5324 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5325 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
5326
5327 if (isCallValid)
5328 {
5329 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5330 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5331 CaptureBindUniformLocationCHROMIUM_name(glState, isCallValid, programPacked, locationPacked,
5332 name, &nameParam);
5333 paramBuffer.addParam(std::move(nameParam));
5334 }
5335 else
5336 {
5337 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5338 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5339 &nameParam.value);
5340 paramBuffer.addParam(std::move(nameParam));
5341 }
5342
5343 return CallCapture(angle::EntryPoint::GLBindUniformLocationCHROMIUM, std::move(paramBuffer));
5344 }
5345
CaptureCompressedCopyTextureCHROMIUM(const State & glState,bool isCallValid,TextureID sourceIdPacked,TextureID destIdPacked)5346 CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
5347 bool isCallValid,
5348 TextureID sourceIdPacked,
5349 TextureID destIdPacked)
5350 {
5351 ParamBuffer paramBuffer;
5352
5353 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
5354 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
5355
5356 return CallCapture(angle::EntryPoint::GLCompressedCopyTextureCHROMIUM, std::move(paramBuffer));
5357 }
5358
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)5359 CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
5360 bool isCallValid,
5361 TextureID sourceIdPacked,
5362 GLint sourceLevel,
5363 TextureTarget destTargetPacked,
5364 TextureID destIdPacked,
5365 GLint destLevel,
5366 GLint internalFormat,
5367 GLenum destType,
5368 GLboolean unpackFlipY,
5369 GLboolean unpackPremultiplyAlpha,
5370 GLboolean unpackUnmultiplyAlpha)
5371 {
5372 ParamBuffer paramBuffer;
5373
5374 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
5375 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
5376 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
5377 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
5378 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
5379 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
5380 paramBuffer.addEnumParam("destType", GLESEnum::AllEnums, ParamType::TGLenum, destType);
5381 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
5382 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
5383 unpackPremultiplyAlpha);
5384 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
5385 unpackUnmultiplyAlpha);
5386
5387 return CallCapture(angle::EntryPoint::GLCopyTextureCHROMIUM, std::move(paramBuffer));
5388 }
5389
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)5390 CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
5391 bool isCallValid,
5392 TextureID sourceIdPacked,
5393 GLint sourceLevel,
5394 TextureTarget destTargetPacked,
5395 TextureID destIdPacked,
5396 GLint destLevel,
5397 GLint xoffset,
5398 GLint yoffset,
5399 GLint x,
5400 GLint y,
5401 GLint width,
5402 GLint height,
5403 GLboolean unpackFlipY,
5404 GLboolean unpackPremultiplyAlpha,
5405 GLboolean unpackUnmultiplyAlpha)
5406 {
5407 ParamBuffer paramBuffer;
5408
5409 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
5410 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
5411 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
5412 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
5413 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
5414 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
5415 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
5416 paramBuffer.addValueParam("x", ParamType::TGLint, x);
5417 paramBuffer.addValueParam("y", ParamType::TGLint, y);
5418 paramBuffer.addValueParam("width", ParamType::TGLint, width);
5419 paramBuffer.addValueParam("height", ParamType::TGLint, height);
5420 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
5421 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
5422 unpackPremultiplyAlpha);
5423 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
5424 unpackUnmultiplyAlpha);
5425
5426 return CallCapture(angle::EntryPoint::GLCopySubTextureCHROMIUM, std::move(paramBuffer));
5427 }
5428
CaptureCoverageModulationCHROMIUM(const State & glState,bool isCallValid,GLenum components)5429 CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
5430 bool isCallValid,
5431 GLenum components)
5432 {
5433 ParamBuffer paramBuffer;
5434
5435 paramBuffer.addEnumParam("components", GLESEnum::AllEnums, ParamType::TGLenum, components);
5436
5437 return CallCapture(angle::EntryPoint::GLCoverageModulationCHROMIUM, std::move(paramBuffer));
5438 }
5439
CaptureLoseContextCHROMIUM(const State & glState,bool isCallValid,GraphicsResetStatus currentPacked,GraphicsResetStatus otherPacked)5440 CallCapture CaptureLoseContextCHROMIUM(const State &glState,
5441 bool isCallValid,
5442 GraphicsResetStatus currentPacked,
5443 GraphicsResetStatus otherPacked)
5444 {
5445 ParamBuffer paramBuffer;
5446
5447 paramBuffer.addValueParam("currentPacked", ParamType::TGraphicsResetStatus, currentPacked);
5448 paramBuffer.addValueParam("otherPacked", ParamType::TGraphicsResetStatus, otherPacked);
5449
5450 return CallCapture(angle::EntryPoint::GLLoseContextCHROMIUM, std::move(paramBuffer));
5451 }
5452
CaptureEGLImageTargetTexStorageEXT(const State & glState,bool isCallValid,GLenum target,egl::ImageID imagePacked,const GLint * attrib_list)5453 CallCapture CaptureEGLImageTargetTexStorageEXT(const State &glState,
5454 bool isCallValid,
5455 GLenum target,
5456 egl::ImageID imagePacked,
5457 const GLint *attrib_list)
5458 {
5459 ParamBuffer paramBuffer;
5460
5461 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
5462 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
5463
5464 if (isCallValid)
5465 {
5466 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5467 InitParamValue(ParamType::TGLintConstPointer, attrib_list, &attrib_listParam.value);
5468 CaptureEGLImageTargetTexStorageEXT_attrib_list(glState, isCallValid, target, imagePacked,
5469 attrib_list, &attrib_listParam);
5470 paramBuffer.addParam(std::move(attrib_listParam));
5471 }
5472 else
5473 {
5474 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5475 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
5476 &attrib_listParam.value);
5477 paramBuffer.addParam(std::move(attrib_listParam));
5478 }
5479
5480 return CallCapture(angle::EntryPoint::GLEGLImageTargetTexStorageEXT, std::move(paramBuffer));
5481 }
5482
CaptureEGLImageTargetTextureStorageEXT(const State & glState,bool isCallValid,GLuint texture,egl::ImageID imagePacked,const GLint * attrib_list)5483 CallCapture CaptureEGLImageTargetTextureStorageEXT(const State &glState,
5484 bool isCallValid,
5485 GLuint texture,
5486 egl::ImageID imagePacked,
5487 const GLint *attrib_list)
5488 {
5489 ParamBuffer paramBuffer;
5490
5491 paramBuffer.addValueParam("texture", ParamType::TGLuint, texture);
5492 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
5493
5494 if (isCallValid)
5495 {
5496 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5497 InitParamValue(ParamType::TGLintConstPointer, attrib_list, &attrib_listParam.value);
5498 CaptureEGLImageTargetTextureStorageEXT_attrib_list(
5499 glState, isCallValid, texture, imagePacked, attrib_list, &attrib_listParam);
5500 paramBuffer.addParam(std::move(attrib_listParam));
5501 }
5502 else
5503 {
5504 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
5505 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
5506 &attrib_listParam.value);
5507 paramBuffer.addParam(std::move(attrib_listParam));
5508 }
5509
5510 return CallCapture(angle::EntryPoint::GLEGLImageTargetTextureStorageEXT,
5511 std::move(paramBuffer));
5512 }
5513
CaptureDrawArraysInstancedBaseInstanceEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei instancecount,GLuint baseinstance)5514 CallCapture CaptureDrawArraysInstancedBaseInstanceEXT(const State &glState,
5515 bool isCallValid,
5516 PrimitiveMode modePacked,
5517 GLint first,
5518 GLsizei count,
5519 GLsizei instancecount,
5520 GLuint baseinstance)
5521 {
5522 ParamBuffer paramBuffer;
5523
5524 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5525 paramBuffer.addValueParam("first", ParamType::TGLint, first);
5526 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5527 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5528 paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
5529
5530 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedBaseInstanceEXT,
5531 std::move(paramBuffer));
5532 }
5533
CaptureDrawElementsInstancedBaseInstanceEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLuint baseinstance)5534 CallCapture CaptureDrawElementsInstancedBaseInstanceEXT(const State &glState,
5535 bool isCallValid,
5536 PrimitiveMode modePacked,
5537 GLsizei count,
5538 DrawElementsType typePacked,
5539 const void *indices,
5540 GLsizei instancecount,
5541 GLuint baseinstance)
5542 {
5543 ParamBuffer paramBuffer;
5544
5545 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5546 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5547 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5548
5549 if (isCallValid)
5550 {
5551 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5552 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5553 CaptureDrawElementsInstancedBaseInstanceEXT_indices(glState, isCallValid, modePacked, count,
5554 typePacked, indices, instancecount,
5555 baseinstance, &indicesParam);
5556 paramBuffer.addParam(std::move(indicesParam));
5557 }
5558 else
5559 {
5560 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5561 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5562 &indicesParam.value);
5563 paramBuffer.addParam(std::move(indicesParam));
5564 }
5565
5566 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5567 paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
5568
5569 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseInstanceEXT,
5570 std::move(paramBuffer));
5571 }
5572
CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex,GLuint baseinstance)5573 CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT(const State &glState,
5574 bool isCallValid,
5575 PrimitiveMode modePacked,
5576 GLsizei count,
5577 DrawElementsType typePacked,
5578 const void *indices,
5579 GLsizei instancecount,
5580 GLint basevertex,
5581 GLuint baseinstance)
5582 {
5583 ParamBuffer paramBuffer;
5584
5585 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5586 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5587 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5588
5589 if (isCallValid)
5590 {
5591 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5592 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5593 CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT_indices(
5594 glState, isCallValid, modePacked, count, typePacked, indices, instancecount, basevertex,
5595 baseinstance, &indicesParam);
5596 paramBuffer.addParam(std::move(indicesParam));
5597 }
5598 else
5599 {
5600 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5601 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5602 &indicesParam.value);
5603 paramBuffer.addParam(std::move(indicesParam));
5604 }
5605
5606 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5607 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
5608 paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
5609
5610 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceEXT,
5611 std::move(paramBuffer));
5612 }
5613
CaptureBindFragDataLocationEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint color,const GLchar * name)5614 CallCapture CaptureBindFragDataLocationEXT(const State &glState,
5615 bool isCallValid,
5616 ShaderProgramID programPacked,
5617 GLuint color,
5618 const GLchar *name)
5619 {
5620 ParamBuffer paramBuffer;
5621
5622 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5623 paramBuffer.addValueParam("color", ParamType::TGLuint, color);
5624
5625 if (isCallValid)
5626 {
5627 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5628 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5629 CaptureBindFragDataLocationEXT_name(glState, isCallValid, programPacked, color, name,
5630 &nameParam);
5631 paramBuffer.addParam(std::move(nameParam));
5632 }
5633 else
5634 {
5635 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5636 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5637 &nameParam.value);
5638 paramBuffer.addParam(std::move(nameParam));
5639 }
5640
5641 return CallCapture(angle::EntryPoint::GLBindFragDataLocationEXT, std::move(paramBuffer));
5642 }
5643
CaptureBindFragDataLocationIndexedEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint colorNumber,GLuint index,const GLchar * name)5644 CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
5645 bool isCallValid,
5646 ShaderProgramID programPacked,
5647 GLuint colorNumber,
5648 GLuint index,
5649 const GLchar *name)
5650 {
5651 ParamBuffer paramBuffer;
5652
5653 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5654 paramBuffer.addValueParam("colorNumber", ParamType::TGLuint, colorNumber);
5655 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5656
5657 if (isCallValid)
5658 {
5659 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5660 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5661 CaptureBindFragDataLocationIndexedEXT_name(glState, isCallValid, programPacked, colorNumber,
5662 index, name, &nameParam);
5663 paramBuffer.addParam(std::move(nameParam));
5664 }
5665 else
5666 {
5667 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5668 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5669 &nameParam.value);
5670 paramBuffer.addParam(std::move(nameParam));
5671 }
5672
5673 return CallCapture(angle::EntryPoint::GLBindFragDataLocationIndexedEXT, std::move(paramBuffer));
5674 }
5675
CaptureGetFragDataIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,const GLchar * name,GLint returnValue)5676 CallCapture CaptureGetFragDataIndexEXT(const State &glState,
5677 bool isCallValid,
5678 ShaderProgramID programPacked,
5679 const GLchar *name,
5680 GLint returnValue)
5681 {
5682 ParamBuffer paramBuffer;
5683
5684 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5685
5686 if (isCallValid)
5687 {
5688 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5689 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5690 CaptureGetFragDataIndexEXT_name(glState, isCallValid, programPacked, name, &nameParam);
5691 paramBuffer.addParam(std::move(nameParam));
5692 }
5693 else
5694 {
5695 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5696 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5697 &nameParam.value);
5698 paramBuffer.addParam(std::move(nameParam));
5699 }
5700
5701 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
5702 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
5703 paramBuffer.addReturnValue(std::move(returnValueCapture));
5704
5705 return CallCapture(angle::EntryPoint::GLGetFragDataIndexEXT, std::move(paramBuffer));
5706 }
5707
CaptureGetProgramResourceLocationIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,const GLchar * name,GLint returnValue)5708 CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
5709 bool isCallValid,
5710 ShaderProgramID programPacked,
5711 GLenum programInterface,
5712 const GLchar *name,
5713 GLint returnValue)
5714 {
5715 ParamBuffer paramBuffer;
5716
5717 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5718 paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum,
5719 programInterface);
5720
5721 if (isCallValid)
5722 {
5723 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5724 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
5725 CaptureGetProgramResourceLocationIndexEXT_name(glState, isCallValid, programPacked,
5726 programInterface, name, &nameParam);
5727 paramBuffer.addParam(std::move(nameParam));
5728 }
5729 else
5730 {
5731 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
5732 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5733 &nameParam.value);
5734 paramBuffer.addParam(std::move(nameParam));
5735 }
5736
5737 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
5738 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
5739 paramBuffer.addReturnValue(std::move(returnValueCapture));
5740
5741 return CallCapture(angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
5742 std::move(paramBuffer));
5743 }
5744
CaptureBufferStorageEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLsizeiptr size,const void * data,GLbitfield flags)5745 CallCapture CaptureBufferStorageEXT(const State &glState,
5746 bool isCallValid,
5747 BufferBinding targetPacked,
5748 GLsizeiptr size,
5749 const void *data,
5750 GLbitfield flags)
5751 {
5752 ParamBuffer paramBuffer;
5753
5754 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5755 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
5756
5757 if (isCallValid)
5758 {
5759 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5760 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
5761 CaptureBufferStorageEXT_data(glState, isCallValid, targetPacked, size, data, flags,
5762 &dataParam);
5763 paramBuffer.addParam(std::move(dataParam));
5764 }
5765 else
5766 {
5767 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5768 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5769 &dataParam.value);
5770 paramBuffer.addParam(std::move(dataParam));
5771 }
5772
5773 paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
5774
5775 return CallCapture(angle::EntryPoint::GLBufferStorageEXT, std::move(paramBuffer));
5776 }
5777
CaptureClearTexImageEXT(const State & glState,bool isCallValid,TextureID texturePacked,GLint level,GLenum format,GLenum type,const void * data)5778 CallCapture CaptureClearTexImageEXT(const State &glState,
5779 bool isCallValid,
5780 TextureID texturePacked,
5781 GLint level,
5782 GLenum format,
5783 GLenum type,
5784 const void *data)
5785 {
5786 ParamBuffer paramBuffer;
5787
5788 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
5789 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5790 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
5791 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
5792
5793 if (isCallValid)
5794 {
5795 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5796 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
5797 CaptureClearTexImageEXT_data(glState, isCallValid, texturePacked, level, format, type, data,
5798 &dataParam);
5799 paramBuffer.addParam(std::move(dataParam));
5800 }
5801 else
5802 {
5803 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5804 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5805 &dataParam.value);
5806 paramBuffer.addParam(std::move(dataParam));
5807 }
5808
5809 return CallCapture(angle::EntryPoint::GLClearTexImageEXT, std::move(paramBuffer));
5810 }
5811
CaptureClearTexSubImageEXT(const State & glState,bool isCallValid,TextureID texturePacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * data)5812 CallCapture CaptureClearTexSubImageEXT(const State &glState,
5813 bool isCallValid,
5814 TextureID texturePacked,
5815 GLint level,
5816 GLint xoffset,
5817 GLint yoffset,
5818 GLint zoffset,
5819 GLsizei width,
5820 GLsizei height,
5821 GLsizei depth,
5822 GLenum format,
5823 GLenum type,
5824 const void *data)
5825 {
5826 ParamBuffer paramBuffer;
5827
5828 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
5829 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5830 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
5831 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
5832 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
5833 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5834 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5835 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5836 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
5837 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
5838
5839 if (isCallValid)
5840 {
5841 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5842 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
5843 CaptureClearTexSubImageEXT_data(glState, isCallValid, texturePacked, level, xoffset,
5844 yoffset, zoffset, width, height, depth, format, type, data,
5845 &dataParam);
5846 paramBuffer.addParam(std::move(dataParam));
5847 }
5848 else
5849 {
5850 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5851 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5852 &dataParam.value);
5853 paramBuffer.addParam(std::move(dataParam));
5854 }
5855
5856 return CallCapture(angle::EntryPoint::GLClearTexSubImageEXT, std::move(paramBuffer));
5857 }
5858
CaptureClipControlEXT(const State & glState,bool isCallValid,ClipOrigin originPacked,ClipDepthMode depthPacked)5859 CallCapture CaptureClipControlEXT(const State &glState,
5860 bool isCallValid,
5861 ClipOrigin originPacked,
5862 ClipDepthMode depthPacked)
5863 {
5864 ParamBuffer paramBuffer;
5865
5866 paramBuffer.addValueParam("originPacked", ParamType::TClipOrigin, originPacked);
5867 paramBuffer.addValueParam("depthPacked", ParamType::TClipDepthMode, depthPacked);
5868
5869 return CallCapture(angle::EntryPoint::GLClipControlEXT, std::move(paramBuffer));
5870 }
5871
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)5872 CallCapture CaptureCopyImageSubDataEXT(const State &glState,
5873 bool isCallValid,
5874 GLuint srcName,
5875 GLenum srcTarget,
5876 GLint srcLevel,
5877 GLint srcX,
5878 GLint srcY,
5879 GLint srcZ,
5880 GLuint dstName,
5881 GLenum dstTarget,
5882 GLint dstLevel,
5883 GLint dstX,
5884 GLint dstY,
5885 GLint dstZ,
5886 GLsizei srcWidth,
5887 GLsizei srcHeight,
5888 GLsizei srcDepth)
5889 {
5890 ParamBuffer paramBuffer;
5891
5892 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
5893 paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
5894 srcTarget);
5895 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
5896 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
5897 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
5898 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
5899 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
5900 paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
5901 dstTarget);
5902 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
5903 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
5904 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
5905 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
5906 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
5907 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
5908 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
5909
5910 return CallCapture(angle::EntryPoint::GLCopyImageSubDataEXT, std::move(paramBuffer));
5911 }
5912
CaptureGetObjectLabelEXT(const State & glState,bool isCallValid,GLenum type,GLuint object,GLsizei bufSize,GLsizei * length,GLchar * label)5913 CallCapture CaptureGetObjectLabelEXT(const State &glState,
5914 bool isCallValid,
5915 GLenum type,
5916 GLuint object,
5917 GLsizei bufSize,
5918 GLsizei *length,
5919 GLchar *label)
5920 {
5921 ParamBuffer paramBuffer;
5922
5923 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
5924 paramBuffer.addValueParam("object", ParamType::TGLuint, object);
5925 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5926
5927 if (isCallValid)
5928 {
5929 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5930 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
5931 CaptureGetObjectLabelEXT_length(glState, isCallValid, type, object, bufSize, length, label,
5932 &lengthParam);
5933 paramBuffer.addParam(std::move(lengthParam));
5934 }
5935 else
5936 {
5937 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5938 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
5939 &lengthParam.value);
5940 paramBuffer.addParam(std::move(lengthParam));
5941 }
5942
5943 if (isCallValid)
5944 {
5945 ParamCapture labelParam("label", ParamType::TGLcharPointer);
5946 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
5947 CaptureGetObjectLabelEXT_label(glState, isCallValid, type, object, bufSize, length, label,
5948 &labelParam);
5949 paramBuffer.addParam(std::move(labelParam));
5950 }
5951 else
5952 {
5953 ParamCapture labelParam("label", ParamType::TGLcharPointer);
5954 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
5955 &labelParam.value);
5956 paramBuffer.addParam(std::move(labelParam));
5957 }
5958
5959 return CallCapture(angle::EntryPoint::GLGetObjectLabelEXT, std::move(paramBuffer));
5960 }
5961
CaptureLabelObjectEXT(const State & glState,bool isCallValid,GLenum type,GLuint object,GLsizei length,const GLchar * label)5962 CallCapture CaptureLabelObjectEXT(const State &glState,
5963 bool isCallValid,
5964 GLenum type,
5965 GLuint object,
5966 GLsizei length,
5967 const GLchar *label)
5968 {
5969 ParamBuffer paramBuffer;
5970
5971 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
5972 paramBuffer.addValueParam("object", ParamType::TGLuint, object);
5973 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
5974
5975 if (isCallValid)
5976 {
5977 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
5978 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
5979 CaptureLabelObjectEXT_label(glState, isCallValid, type, object, length, label, &labelParam);
5980 paramBuffer.addParam(std::move(labelParam));
5981 }
5982 else
5983 {
5984 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
5985 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
5986 &labelParam.value);
5987 paramBuffer.addParam(std::move(labelParam));
5988 }
5989
5990 return CallCapture(angle::EntryPoint::GLLabelObjectEXT, std::move(paramBuffer));
5991 }
5992
CaptureInsertEventMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)5993 CallCapture CaptureInsertEventMarkerEXT(const State &glState,
5994 bool isCallValid,
5995 GLsizei length,
5996 const GLchar *marker)
5997 {
5998 ParamBuffer paramBuffer;
5999
6000 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
6001
6002 if (isCallValid)
6003 {
6004 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
6005 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
6006 CaptureInsertEventMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
6007 paramBuffer.addParam(std::move(markerParam));
6008 }
6009 else
6010 {
6011 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
6012 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
6013 &markerParam.value);
6014 paramBuffer.addParam(std::move(markerParam));
6015 }
6016
6017 return CallCapture(angle::EntryPoint::GLInsertEventMarkerEXT, std::move(paramBuffer));
6018 }
6019
CapturePopGroupMarkerEXT(const State & glState,bool isCallValid)6020 CallCapture CapturePopGroupMarkerEXT(const State &glState, bool isCallValid)
6021 {
6022 ParamBuffer paramBuffer;
6023
6024 return CallCapture(angle::EntryPoint::GLPopGroupMarkerEXT, std::move(paramBuffer));
6025 }
6026
CapturePushGroupMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)6027 CallCapture CapturePushGroupMarkerEXT(const State &glState,
6028 bool isCallValid,
6029 GLsizei length,
6030 const GLchar *marker)
6031 {
6032 ParamBuffer paramBuffer;
6033
6034 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
6035
6036 if (isCallValid)
6037 {
6038 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
6039 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
6040 CapturePushGroupMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
6041 paramBuffer.addParam(std::move(markerParam));
6042 }
6043 else
6044 {
6045 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
6046 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
6047 &markerParam.value);
6048 paramBuffer.addParam(std::move(markerParam));
6049 }
6050
6051 return CallCapture(angle::EntryPoint::GLPushGroupMarkerEXT, std::move(paramBuffer));
6052 }
6053
CaptureDiscardFramebufferEXT(const State & glState,bool isCallValid,GLenum target,GLsizei numAttachments,const GLenum * attachments)6054 CallCapture CaptureDiscardFramebufferEXT(const State &glState,
6055 bool isCallValid,
6056 GLenum target,
6057 GLsizei numAttachments,
6058 const GLenum *attachments)
6059 {
6060 ParamBuffer paramBuffer;
6061
6062 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
6063 paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
6064
6065 if (isCallValid)
6066 {
6067 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
6068 InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
6069 CaptureDiscardFramebufferEXT_attachments(glState, isCallValid, target, numAttachments,
6070 attachments, &attachmentsParam);
6071 paramBuffer.addParam(std::move(attachmentsParam));
6072 }
6073 else
6074 {
6075 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
6076 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
6077 &attachmentsParam.value);
6078 paramBuffer.addParam(std::move(attachmentsParam));
6079 }
6080
6081 return CallCapture(angle::EntryPoint::GLDiscardFramebufferEXT, std::move(paramBuffer));
6082 }
6083
CaptureBeginQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked,QueryID idPacked)6084 CallCapture CaptureBeginQueryEXT(const State &glState,
6085 bool isCallValid,
6086 QueryType targetPacked,
6087 QueryID idPacked)
6088 {
6089 ParamBuffer paramBuffer;
6090
6091 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
6092 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6093
6094 return CallCapture(angle::EntryPoint::GLBeginQueryEXT, std::move(paramBuffer));
6095 }
6096
CaptureDeleteQueriesEXT(const State & glState,bool isCallValid,GLsizei n,const QueryID * idsPacked)6097 CallCapture CaptureDeleteQueriesEXT(const State &glState,
6098 bool isCallValid,
6099 GLsizei n,
6100 const QueryID *idsPacked)
6101 {
6102 ParamBuffer paramBuffer;
6103
6104 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6105
6106 if (isCallValid)
6107 {
6108 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
6109 InitParamValue(ParamType::TQueryIDConstPointer, idsPacked, &idsPackedParam.value);
6110 CaptureDeleteQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
6111 paramBuffer.addParam(std::move(idsPackedParam));
6112 }
6113 else
6114 {
6115 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
6116 InitParamValue(ParamType::TQueryIDConstPointer, static_cast<const QueryID *>(nullptr),
6117 &idsPackedParam.value);
6118 paramBuffer.addParam(std::move(idsPackedParam));
6119 }
6120
6121 return CallCapture(angle::EntryPoint::GLDeleteQueriesEXT, std::move(paramBuffer));
6122 }
6123
CaptureEndQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked)6124 CallCapture CaptureEndQueryEXT(const State &glState, bool isCallValid, QueryType targetPacked)
6125 {
6126 ParamBuffer paramBuffer;
6127
6128 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
6129
6130 return CallCapture(angle::EntryPoint::GLEndQueryEXT, std::move(paramBuffer));
6131 }
6132
CaptureGenQueriesEXT(const State & glState,bool isCallValid,GLsizei n,QueryID * idsPacked)6133 CallCapture CaptureGenQueriesEXT(const State &glState,
6134 bool isCallValid,
6135 GLsizei n,
6136 QueryID *idsPacked)
6137 {
6138 ParamBuffer paramBuffer;
6139
6140 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6141
6142 if (isCallValid)
6143 {
6144 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
6145 InitParamValue(ParamType::TQueryIDPointer, idsPacked, &idsPackedParam.value);
6146 CaptureGenQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
6147 paramBuffer.addParam(std::move(idsPackedParam));
6148 }
6149 else
6150 {
6151 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
6152 InitParamValue(ParamType::TQueryIDPointer, static_cast<QueryID *>(nullptr),
6153 &idsPackedParam.value);
6154 paramBuffer.addParam(std::move(idsPackedParam));
6155 }
6156
6157 return CallCapture(angle::EntryPoint::GLGenQueriesEXT, std::move(paramBuffer));
6158 }
6159
CaptureGetInteger64vEXT(const State & glState,bool isCallValid,GLenum pname,GLint64 * data)6160 CallCapture CaptureGetInteger64vEXT(const State &glState,
6161 bool isCallValid,
6162 GLenum pname,
6163 GLint64 *data)
6164 {
6165 ParamBuffer paramBuffer;
6166
6167 paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname);
6168
6169 if (isCallValid)
6170 {
6171 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
6172 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
6173 CaptureGetInteger64vEXT_data(glState, isCallValid, pname, data, &dataParam);
6174 paramBuffer.addParam(std::move(dataParam));
6175 }
6176 else
6177 {
6178 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
6179 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
6180 &dataParam.value);
6181 paramBuffer.addParam(std::move(dataParam));
6182 }
6183
6184 return CallCapture(angle::EntryPoint::GLGetInteger64vEXT, std::move(paramBuffer));
6185 }
6186
CaptureGetQueryObjecti64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint64 * params)6187 CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
6188 bool isCallValid,
6189 QueryID idPacked,
6190 GLenum pname,
6191 GLint64 *params)
6192 {
6193 ParamBuffer paramBuffer;
6194
6195 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6196 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6197 pname);
6198
6199 if (isCallValid)
6200 {
6201 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
6202 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
6203 CaptureGetQueryObjecti64vEXT_params(glState, isCallValid, idPacked, pname, params,
6204 ¶msParam);
6205 paramBuffer.addParam(std::move(paramsParam));
6206 }
6207 else
6208 {
6209 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
6210 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
6211 ¶msParam.value);
6212 paramBuffer.addParam(std::move(paramsParam));
6213 }
6214
6215 return CallCapture(angle::EntryPoint::GLGetQueryObjecti64vEXT, std::move(paramBuffer));
6216 }
6217
CaptureGetQueryObjectivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint * params)6218 CallCapture CaptureGetQueryObjectivEXT(const State &glState,
6219 bool isCallValid,
6220 QueryID idPacked,
6221 GLenum pname,
6222 GLint *params)
6223 {
6224 ParamBuffer paramBuffer;
6225
6226 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6227 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6228 pname);
6229
6230 if (isCallValid)
6231 {
6232 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6233 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6234 CaptureGetQueryObjectivEXT_params(glState, isCallValid, idPacked, pname, params,
6235 ¶msParam);
6236 paramBuffer.addParam(std::move(paramsParam));
6237 }
6238 else
6239 {
6240 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6241 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6242 paramBuffer.addParam(std::move(paramsParam));
6243 }
6244
6245 return CallCapture(angle::EntryPoint::GLGetQueryObjectivEXT, std::move(paramBuffer));
6246 }
6247
CaptureGetQueryObjectui64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint64 * params)6248 CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
6249 bool isCallValid,
6250 QueryID idPacked,
6251 GLenum pname,
6252 GLuint64 *params)
6253 {
6254 ParamBuffer paramBuffer;
6255
6256 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6257 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6258 pname);
6259
6260 if (isCallValid)
6261 {
6262 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
6263 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
6264 CaptureGetQueryObjectui64vEXT_params(glState, isCallValid, idPacked, pname, params,
6265 ¶msParam);
6266 paramBuffer.addParam(std::move(paramsParam));
6267 }
6268 else
6269 {
6270 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
6271 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
6272 ¶msParam.value);
6273 paramBuffer.addParam(std::move(paramsParam));
6274 }
6275
6276 return CallCapture(angle::EntryPoint::GLGetQueryObjectui64vEXT, std::move(paramBuffer));
6277 }
6278
CaptureGetQueryObjectuivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint * params)6279 CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
6280 bool isCallValid,
6281 QueryID idPacked,
6282 GLenum pname,
6283 GLuint *params)
6284 {
6285 ParamBuffer paramBuffer;
6286
6287 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6288 paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum,
6289 pname);
6290
6291 if (isCallValid)
6292 {
6293 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
6294 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
6295 CaptureGetQueryObjectuivEXT_params(glState, isCallValid, idPacked, pname, params,
6296 ¶msParam);
6297 paramBuffer.addParam(std::move(paramsParam));
6298 }
6299 else
6300 {
6301 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
6302 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
6303 ¶msParam.value);
6304 paramBuffer.addParam(std::move(paramsParam));
6305 }
6306
6307 return CallCapture(angle::EntryPoint::GLGetQueryObjectuivEXT, std::move(paramBuffer));
6308 }
6309
CaptureGetQueryivEXT(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLint * params)6310 CallCapture CaptureGetQueryivEXT(const State &glState,
6311 bool isCallValid,
6312 QueryType targetPacked,
6313 GLenum pname,
6314 GLint *params)
6315 {
6316 ParamBuffer paramBuffer;
6317
6318 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
6319 paramBuffer.addEnumParam("pname", GLESEnum::QueryParameterName, ParamType::TGLenum, pname);
6320
6321 if (isCallValid)
6322 {
6323 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6324 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6325 CaptureGetQueryivEXT_params(glState, isCallValid, targetPacked, pname, params,
6326 ¶msParam);
6327 paramBuffer.addParam(std::move(paramsParam));
6328 }
6329 else
6330 {
6331 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6332 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6333 paramBuffer.addParam(std::move(paramsParam));
6334 }
6335
6336 return CallCapture(angle::EntryPoint::GLGetQueryivEXT, std::move(paramBuffer));
6337 }
6338
CaptureIsQueryEXT(const State & glState,bool isCallValid,QueryID idPacked,GLboolean returnValue)6339 CallCapture CaptureIsQueryEXT(const State &glState,
6340 bool isCallValid,
6341 QueryID idPacked,
6342 GLboolean returnValue)
6343 {
6344 ParamBuffer paramBuffer;
6345
6346 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6347
6348 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6349 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6350 paramBuffer.addReturnValue(std::move(returnValueCapture));
6351
6352 return CallCapture(angle::EntryPoint::GLIsQueryEXT, std::move(paramBuffer));
6353 }
6354
CaptureQueryCounterEXT(const State & glState,bool isCallValid,QueryID idPacked,QueryType targetPacked)6355 CallCapture CaptureQueryCounterEXT(const State &glState,
6356 bool isCallValid,
6357 QueryID idPacked,
6358 QueryType targetPacked)
6359 {
6360 ParamBuffer paramBuffer;
6361
6362 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
6363 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
6364
6365 return CallCapture(angle::EntryPoint::GLQueryCounterEXT, std::move(paramBuffer));
6366 }
6367
CaptureDrawBuffersEXT(const State & glState,bool isCallValid,GLsizei n,const GLenum * bufs)6368 CallCapture CaptureDrawBuffersEXT(const State &glState,
6369 bool isCallValid,
6370 GLsizei n,
6371 const GLenum *bufs)
6372 {
6373 ParamBuffer paramBuffer;
6374
6375 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6376
6377 if (isCallValid)
6378 {
6379 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
6380 InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
6381 CaptureDrawBuffersEXT_bufs(glState, isCallValid, n, bufs, &bufsParam);
6382 paramBuffer.addParam(std::move(bufsParam));
6383 }
6384 else
6385 {
6386 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
6387 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
6388 &bufsParam.value);
6389 paramBuffer.addParam(std::move(bufsParam));
6390 }
6391
6392 return CallCapture(angle::EntryPoint::GLDrawBuffersEXT, std::move(paramBuffer));
6393 }
6394
CaptureBlendEquationSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)6395 CallCapture CaptureBlendEquationSeparateiEXT(const State &glState,
6396 bool isCallValid,
6397 GLuint buf,
6398 GLenum modeRGB,
6399 GLenum modeAlpha)
6400 {
6401 ParamBuffer paramBuffer;
6402
6403 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6404 paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
6405 modeRGB);
6406 paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
6407 modeAlpha);
6408
6409 return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiEXT, std::move(paramBuffer));
6410 }
6411
CaptureBlendEquationiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum mode)6412 CallCapture CaptureBlendEquationiEXT(const State &glState,
6413 bool isCallValid,
6414 GLuint buf,
6415 GLenum mode)
6416 {
6417 ParamBuffer paramBuffer;
6418
6419 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6420 paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode);
6421
6422 return CallCapture(angle::EntryPoint::GLBlendEquationiEXT, std::move(paramBuffer));
6423 }
6424
CaptureBlendFuncSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)6425 CallCapture CaptureBlendFuncSeparateiEXT(const State &glState,
6426 bool isCallValid,
6427 GLuint buf,
6428 GLenum srcRGB,
6429 GLenum dstRGB,
6430 GLenum srcAlpha,
6431 GLenum dstAlpha)
6432 {
6433 ParamBuffer paramBuffer;
6434
6435 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6436 paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB);
6437 paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB);
6438 paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha);
6439 paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha);
6440
6441 return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiEXT, std::move(paramBuffer));
6442 }
6443
CaptureBlendFunciEXT(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)6444 CallCapture CaptureBlendFunciEXT(const State &glState,
6445 bool isCallValid,
6446 GLuint buf,
6447 GLenum src,
6448 GLenum dst)
6449 {
6450 ParamBuffer paramBuffer;
6451
6452 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
6453 paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src);
6454 paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst);
6455
6456 return CallCapture(angle::EntryPoint::GLBlendFunciEXT, std::move(paramBuffer));
6457 }
6458
CaptureColorMaskiEXT(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)6459 CallCapture CaptureColorMaskiEXT(const State &glState,
6460 bool isCallValid,
6461 GLuint index,
6462 GLboolean r,
6463 GLboolean g,
6464 GLboolean b,
6465 GLboolean a)
6466 {
6467 ParamBuffer paramBuffer;
6468
6469 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6470 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
6471 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
6472 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
6473 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
6474
6475 return CallCapture(angle::EntryPoint::GLColorMaskiEXT, std::move(paramBuffer));
6476 }
6477
CaptureDisableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)6478 CallCapture CaptureDisableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
6479 {
6480 ParamBuffer paramBuffer;
6481
6482 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
6483 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6484
6485 return CallCapture(angle::EntryPoint::GLDisableiEXT, std::move(paramBuffer));
6486 }
6487
CaptureEnableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)6488 CallCapture CaptureEnableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
6489 {
6490 ParamBuffer paramBuffer;
6491
6492 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
6493 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6494
6495 return CallCapture(angle::EntryPoint::GLEnableiEXT, std::move(paramBuffer));
6496 }
6497
CaptureIsEnablediEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)6498 CallCapture CaptureIsEnablediEXT(const State &glState,
6499 bool isCallValid,
6500 GLenum target,
6501 GLuint index,
6502 GLboolean returnValue)
6503 {
6504 ParamBuffer paramBuffer;
6505
6506 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
6507 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6508
6509 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6510 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6511 paramBuffer.addReturnValue(std::move(returnValueCapture));
6512
6513 return CallCapture(angle::EntryPoint::GLIsEnablediEXT, std::move(paramBuffer));
6514 }
6515
CaptureDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)6516 CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
6517 bool isCallValid,
6518 PrimitiveMode modePacked,
6519 GLsizei count,
6520 DrawElementsType typePacked,
6521 const void *indices,
6522 GLint basevertex)
6523 {
6524 ParamBuffer paramBuffer;
6525
6526 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6527 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6528 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6529
6530 if (isCallValid)
6531 {
6532 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6533 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6534 CaptureDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
6535 typePacked, indices, basevertex, &indicesParam);
6536 paramBuffer.addParam(std::move(indicesParam));
6537 }
6538 else
6539 {
6540 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6541 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6542 &indicesParam.value);
6543 paramBuffer.addParam(std::move(indicesParam));
6544 }
6545
6546 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
6547
6548 return CallCapture(angle::EntryPoint::GLDrawElementsBaseVertexEXT, std::move(paramBuffer));
6549 }
6550
CaptureDrawElementsInstancedBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)6551 CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
6552 bool isCallValid,
6553 PrimitiveMode modePacked,
6554 GLsizei count,
6555 DrawElementsType typePacked,
6556 const void *indices,
6557 GLsizei instancecount,
6558 GLint basevertex)
6559 {
6560 ParamBuffer paramBuffer;
6561
6562 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6563 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6564 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6565
6566 if (isCallValid)
6567 {
6568 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6569 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6570 CaptureDrawElementsInstancedBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
6571 typePacked, indices, instancecount,
6572 basevertex, &indicesParam);
6573 paramBuffer.addParam(std::move(indicesParam));
6574 }
6575 else
6576 {
6577 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6578 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6579 &indicesParam.value);
6580 paramBuffer.addParam(std::move(indicesParam));
6581 }
6582
6583 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
6584 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
6585
6586 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexEXT,
6587 std::move(paramBuffer));
6588 }
6589
CaptureDrawRangeElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)6590 CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
6591 bool isCallValid,
6592 PrimitiveMode modePacked,
6593 GLuint start,
6594 GLuint end,
6595 GLsizei count,
6596 DrawElementsType typePacked,
6597 const void *indices,
6598 GLint basevertex)
6599 {
6600 ParamBuffer paramBuffer;
6601
6602 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6603 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
6604 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
6605 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6606 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6607
6608 if (isCallValid)
6609 {
6610 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6611 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6612 CaptureDrawRangeElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, start, end,
6613 count, typePacked, indices, basevertex,
6614 &indicesParam);
6615 paramBuffer.addParam(std::move(indicesParam));
6616 }
6617 else
6618 {
6619 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6620 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6621 &indicesParam.value);
6622 paramBuffer.addParam(std::move(indicesParam));
6623 }
6624
6625 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
6626
6627 return CallCapture(angle::EntryPoint::GLDrawRangeElementsBaseVertexEXT, std::move(paramBuffer));
6628 }
6629
CaptureMultiDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount,const GLint * basevertex)6630 CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
6631 bool isCallValid,
6632 PrimitiveMode modePacked,
6633 const GLsizei *count,
6634 DrawElementsType typePacked,
6635 const void *const *indices,
6636 GLsizei drawcount,
6637 const GLint *basevertex)
6638 {
6639 ParamBuffer paramBuffer;
6640
6641 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6642
6643 if (isCallValid)
6644 {
6645 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
6646 InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value);
6647 CaptureMultiDrawElementsBaseVertexEXT_count(glState, isCallValid, modePacked, count,
6648 typePacked, indices, drawcount, basevertex,
6649 &countParam);
6650 paramBuffer.addParam(std::move(countParam));
6651 }
6652 else
6653 {
6654 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
6655 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
6656 &countParam.value);
6657 paramBuffer.addParam(std::move(countParam));
6658 }
6659
6660 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6661
6662 if (isCallValid)
6663 {
6664 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
6665 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
6666 CaptureMultiDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
6667 typePacked, indices, drawcount, basevertex,
6668 &indicesParam);
6669 paramBuffer.addParam(std::move(indicesParam));
6670 }
6671 else
6672 {
6673 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
6674 InitParamValue(ParamType::TvoidConstPointerPointer,
6675 static_cast<const void *const *>(nullptr), &indicesParam.value);
6676 paramBuffer.addParam(std::move(indicesParam));
6677 }
6678
6679 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
6680
6681 if (isCallValid)
6682 {
6683 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
6684 InitParamValue(ParamType::TGLintConstPointer, basevertex, &basevertexParam.value);
6685 CaptureMultiDrawElementsBaseVertexEXT_basevertex(glState, isCallValid, modePacked, count,
6686 typePacked, indices, drawcount, basevertex,
6687 &basevertexParam);
6688 paramBuffer.addParam(std::move(basevertexParam));
6689 }
6690 else
6691 {
6692 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
6693 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
6694 &basevertexParam.value);
6695 paramBuffer.addParam(std::move(basevertexParam));
6696 }
6697
6698 return CallCapture(angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT, std::move(paramBuffer));
6699 }
6700
CaptureBufferStorageExternalEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)6701 CallCapture CaptureBufferStorageExternalEXT(const State &glState,
6702 bool isCallValid,
6703 BufferBinding targetPacked,
6704 GLintptr offset,
6705 GLsizeiptr size,
6706 GLeglClientBufferEXT clientBuffer,
6707 GLbitfield flags)
6708 {
6709 ParamBuffer paramBuffer;
6710
6711 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
6712 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6713 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6714 paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer);
6715 paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
6716
6717 return CallCapture(angle::EntryPoint::GLBufferStorageExternalEXT, std::move(paramBuffer));
6718 }
6719
CaptureNamedBufferStorageExternalEXT(const State & glState,bool isCallValid,GLuint buffer,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)6720 CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState,
6721 bool isCallValid,
6722 GLuint buffer,
6723 GLintptr offset,
6724 GLsizeiptr size,
6725 GLeglClientBufferEXT clientBuffer,
6726 GLbitfield flags)
6727 {
6728 ParamBuffer paramBuffer;
6729
6730 paramBuffer.addValueParam("buffer", ParamType::TGLuint, buffer);
6731 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6732 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6733 paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer);
6734 paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
6735
6736 return CallCapture(angle::EntryPoint::GLNamedBufferStorageExternalEXT, std::move(paramBuffer));
6737 }
6738
CaptureFramebufferTextureEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)6739 CallCapture CaptureFramebufferTextureEXT(const State &glState,
6740 bool isCallValid,
6741 GLenum target,
6742 GLenum attachment,
6743 TextureID texturePacked,
6744 GLint level)
6745 {
6746 ParamBuffer paramBuffer;
6747
6748 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
6749 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
6750 attachment);
6751 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
6752 paramBuffer.addValueParam("level", ParamType::TGLint, level);
6753
6754 return CallCapture(angle::EntryPoint::GLFramebufferTextureEXT, std::move(paramBuffer));
6755 }
6756
CaptureDrawArraysInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint start,GLsizei count,GLsizei primcount)6757 CallCapture CaptureDrawArraysInstancedEXT(const State &glState,
6758 bool isCallValid,
6759 PrimitiveMode modePacked,
6760 GLint start,
6761 GLsizei count,
6762 GLsizei primcount)
6763 {
6764 ParamBuffer paramBuffer;
6765
6766 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6767 paramBuffer.addValueParam("start", ParamType::TGLint, start);
6768 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6769 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
6770
6771 return CallCapture(angle::EntryPoint::GLDrawArraysInstancedEXT, std::move(paramBuffer));
6772 }
6773
CaptureDrawElementsInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)6774 CallCapture CaptureDrawElementsInstancedEXT(const State &glState,
6775 bool isCallValid,
6776 PrimitiveMode modePacked,
6777 GLsizei count,
6778 DrawElementsType typePacked,
6779 const void *indices,
6780 GLsizei primcount)
6781 {
6782 ParamBuffer paramBuffer;
6783
6784 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
6785 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6786 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
6787
6788 if (isCallValid)
6789 {
6790 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6791 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
6792 CaptureDrawElementsInstancedEXT_indices(glState, isCallValid, modePacked, count, typePacked,
6793 indices, primcount, &indicesParam);
6794 paramBuffer.addParam(std::move(indicesParam));
6795 }
6796 else
6797 {
6798 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
6799 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6800 &indicesParam.value);
6801 paramBuffer.addParam(std::move(indicesParam));
6802 }
6803
6804 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
6805
6806 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedEXT, std::move(paramBuffer));
6807 }
6808
CaptureVertexAttribDivisorEXT(const State & glState,bool isCallValid,GLuint index,GLuint divisor)6809 CallCapture CaptureVertexAttribDivisorEXT(const State &glState,
6810 bool isCallValid,
6811 GLuint index,
6812 GLuint divisor)
6813 {
6814 ParamBuffer paramBuffer;
6815
6816 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
6817 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
6818
6819 return CallCapture(angle::EntryPoint::GLVertexAttribDivisorEXT, std::move(paramBuffer));
6820 }
6821
CaptureFlushMappedBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length)6822 CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState,
6823 bool isCallValid,
6824 BufferBinding targetPacked,
6825 GLintptr offset,
6826 GLsizeiptr length)
6827 {
6828 ParamBuffer paramBuffer;
6829
6830 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
6831 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6832 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
6833
6834 return CallCapture(angle::EntryPoint::GLFlushMappedBufferRangeEXT, std::move(paramBuffer));
6835 }
6836
CaptureMapBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length,GLbitfield access,void * returnValue)6837 CallCapture CaptureMapBufferRangeEXT(const State &glState,
6838 bool isCallValid,
6839 BufferBinding targetPacked,
6840 GLintptr offset,
6841 GLsizeiptr length,
6842 GLbitfield access,
6843 void *returnValue)
6844 {
6845 ParamBuffer paramBuffer;
6846
6847 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
6848 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6849 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
6850 paramBuffer.addEnumParam("access", GLESEnum::MapBufferAccessMask, ParamType::TGLbitfield,
6851 access);
6852
6853 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
6854 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
6855 paramBuffer.addReturnValue(std::move(returnValueCapture));
6856
6857 return CallCapture(angle::EntryPoint::GLMapBufferRangeEXT, std::move(paramBuffer));
6858 }
6859
CaptureBufferStorageMemEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizeiptr size,MemoryObjectID memoryPacked,GLuint64 offset)6860 CallCapture CaptureBufferStorageMemEXT(const State &glState,
6861 bool isCallValid,
6862 TextureType targetPacked,
6863 GLsizeiptr size,
6864 MemoryObjectID memoryPacked,
6865 GLuint64 offset)
6866 {
6867 ParamBuffer paramBuffer;
6868
6869 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6870 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6871 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
6872 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
6873
6874 return CallCapture(angle::EntryPoint::GLBufferStorageMemEXT, std::move(paramBuffer));
6875 }
6876
CaptureCreateMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,MemoryObjectID * memoryObjectsPacked)6877 CallCapture CaptureCreateMemoryObjectsEXT(const State &glState,
6878 bool isCallValid,
6879 GLsizei n,
6880 MemoryObjectID *memoryObjectsPacked)
6881 {
6882 ParamBuffer paramBuffer;
6883
6884 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6885
6886 if (isCallValid)
6887 {
6888 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6889 ParamType::TMemoryObjectIDPointer);
6890 InitParamValue(ParamType::TMemoryObjectIDPointer, memoryObjectsPacked,
6891 &memoryObjectsPackedParam.value);
6892 CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(
6893 glState, isCallValid, n, memoryObjectsPacked, &memoryObjectsPackedParam);
6894 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6895 }
6896 else
6897 {
6898 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6899 ParamType::TMemoryObjectIDPointer);
6900 InitParamValue(ParamType::TMemoryObjectIDPointer, static_cast<MemoryObjectID *>(nullptr),
6901 &memoryObjectsPackedParam.value);
6902 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6903 }
6904
6905 return CallCapture(angle::EntryPoint::GLCreateMemoryObjectsEXT, std::move(paramBuffer));
6906 }
6907
CaptureDeleteMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,const MemoryObjectID * memoryObjectsPacked)6908 CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState,
6909 bool isCallValid,
6910 GLsizei n,
6911 const MemoryObjectID *memoryObjectsPacked)
6912 {
6913 ParamBuffer paramBuffer;
6914
6915 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6916
6917 if (isCallValid)
6918 {
6919 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6920 ParamType::TMemoryObjectIDConstPointer);
6921 InitParamValue(ParamType::TMemoryObjectIDConstPointer, memoryObjectsPacked,
6922 &memoryObjectsPackedParam.value);
6923 CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(
6924 glState, isCallValid, n, memoryObjectsPacked, &memoryObjectsPackedParam);
6925 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6926 }
6927 else
6928 {
6929 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
6930 ParamType::TMemoryObjectIDConstPointer);
6931 InitParamValue(ParamType::TMemoryObjectIDConstPointer,
6932 static_cast<const MemoryObjectID *>(nullptr),
6933 &memoryObjectsPackedParam.value);
6934 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
6935 }
6936
6937 return CallCapture(angle::EntryPoint::GLDeleteMemoryObjectsEXT, std::move(paramBuffer));
6938 }
6939
CaptureGetMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,GLint * params)6940 CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState,
6941 bool isCallValid,
6942 MemoryObjectID memoryObjectPacked,
6943 GLenum pname,
6944 GLint *params)
6945 {
6946 ParamBuffer paramBuffer;
6947
6948 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
6949 paramBuffer.addEnumParam("pname", GLESEnum::MemoryObjectParameterName, ParamType::TGLenum,
6950 pname);
6951
6952 if (isCallValid)
6953 {
6954 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6955 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6956 CaptureGetMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
6957 params, ¶msParam);
6958 paramBuffer.addParam(std::move(paramsParam));
6959 }
6960 else
6961 {
6962 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6963 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6964 paramBuffer.addParam(std::move(paramsParam));
6965 }
6966
6967 return CallCapture(angle::EntryPoint::GLGetMemoryObjectParameterivEXT, std::move(paramBuffer));
6968 }
6969
CaptureGetUnsignedBytevEXT(const State & glState,bool isCallValid,GLenum pname,GLubyte * data)6970 CallCapture CaptureGetUnsignedBytevEXT(const State &glState,
6971 bool isCallValid,
6972 GLenum pname,
6973 GLubyte *data)
6974 {
6975 ParamBuffer paramBuffer;
6976
6977 paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname);
6978
6979 if (isCallValid)
6980 {
6981 ParamCapture dataParam("data", ParamType::TGLubytePointer);
6982 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
6983 CaptureGetUnsignedBytevEXT_data(glState, isCallValid, pname, data, &dataParam);
6984 paramBuffer.addParam(std::move(dataParam));
6985 }
6986 else
6987 {
6988 ParamCapture dataParam("data", ParamType::TGLubytePointer);
6989 InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
6990 &dataParam.value);
6991 paramBuffer.addParam(std::move(dataParam));
6992 }
6993
6994 return CallCapture(angle::EntryPoint::GLGetUnsignedBytevEXT, std::move(paramBuffer));
6995 }
6996
CaptureGetUnsignedBytei_vEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLubyte * data)6997 CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState,
6998 bool isCallValid,
6999 GLenum target,
7000 GLuint index,
7001 GLubyte *data)
7002 {
7003 ParamBuffer paramBuffer;
7004
7005 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
7006 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
7007
7008 if (isCallValid)
7009 {
7010 ParamCapture dataParam("data", ParamType::TGLubytePointer);
7011 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
7012 CaptureGetUnsignedBytei_vEXT_data(glState, isCallValid, target, index, data, &dataParam);
7013 paramBuffer.addParam(std::move(dataParam));
7014 }
7015 else
7016 {
7017 ParamCapture dataParam("data", ParamType::TGLubytePointer);
7018 InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
7019 &dataParam.value);
7020 paramBuffer.addParam(std::move(dataParam));
7021 }
7022
7023 return CallCapture(angle::EntryPoint::GLGetUnsignedBytei_vEXT, std::move(paramBuffer));
7024 }
7025
CaptureIsMemoryObjectEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLboolean returnValue)7026 CallCapture CaptureIsMemoryObjectEXT(const State &glState,
7027 bool isCallValid,
7028 MemoryObjectID memoryObjectPacked,
7029 GLboolean returnValue)
7030 {
7031 ParamBuffer paramBuffer;
7032
7033 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
7034
7035 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7036 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7037 paramBuffer.addReturnValue(std::move(returnValueCapture));
7038
7039 return CallCapture(angle::EntryPoint::GLIsMemoryObjectEXT, std::move(paramBuffer));
7040 }
7041
CaptureMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,const GLint * params)7042 CallCapture CaptureMemoryObjectParameterivEXT(const State &glState,
7043 bool isCallValid,
7044 MemoryObjectID memoryObjectPacked,
7045 GLenum pname,
7046 const GLint *params)
7047 {
7048 ParamBuffer paramBuffer;
7049
7050 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
7051 paramBuffer.addEnumParam("pname", GLESEnum::MemoryObjectParameterName, ParamType::TGLenum,
7052 pname);
7053
7054 if (isCallValid)
7055 {
7056 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
7057 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
7058 CaptureMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
7059 params, ¶msParam);
7060 paramBuffer.addParam(std::move(paramsParam));
7061 }
7062 else
7063 {
7064 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
7065 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
7066 ¶msParam.value);
7067 paramBuffer.addParam(std::move(paramsParam));
7068 }
7069
7070 return CallCapture(angle::EntryPoint::GLMemoryObjectParameterivEXT, std::move(paramBuffer));
7071 }
7072
CaptureTexStorageMem2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,MemoryObjectID memoryPacked,GLuint64 offset)7073 CallCapture CaptureTexStorageMem2DEXT(const State &glState,
7074 bool isCallValid,
7075 TextureType targetPacked,
7076 GLsizei levels,
7077 GLenum internalFormat,
7078 GLsizei width,
7079 GLsizei height,
7080 MemoryObjectID memoryPacked,
7081 GLuint64 offset)
7082 {
7083 ParamBuffer paramBuffer;
7084
7085 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
7086 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
7087 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
7088 internalFormat);
7089 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7090 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7091 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7092 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
7093
7094 return CallCapture(angle::EntryPoint::GLTexStorageMem2DEXT, std::move(paramBuffer));
7095 }
7096
CaptureTexStorageMem2DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)7097 CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState,
7098 bool isCallValid,
7099 TextureType targetPacked,
7100 GLsizei samples,
7101 GLenum internalFormat,
7102 GLsizei width,
7103 GLsizei height,
7104 GLboolean fixedSampleLocations,
7105 MemoryObjectID memoryPacked,
7106 GLuint64 offset)
7107 {
7108 ParamBuffer paramBuffer;
7109
7110 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
7111 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7112 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
7113 internalFormat);
7114 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7115 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7116 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
7117 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7118 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
7119
7120 return CallCapture(angle::EntryPoint::GLTexStorageMem2DMultisampleEXT, std::move(paramBuffer));
7121 }
7122
CaptureTexStorageMem3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,MemoryObjectID memoryPacked,GLuint64 offset)7123 CallCapture CaptureTexStorageMem3DEXT(const State &glState,
7124 bool isCallValid,
7125 TextureType targetPacked,
7126 GLsizei levels,
7127 GLenum internalFormat,
7128 GLsizei width,
7129 GLsizei height,
7130 GLsizei depth,
7131 MemoryObjectID memoryPacked,
7132 GLuint64 offset)
7133 {
7134 ParamBuffer paramBuffer;
7135
7136 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
7137 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
7138 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
7139 internalFormat);
7140 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7141 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7142 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
7143 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7144 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
7145
7146 return CallCapture(angle::EntryPoint::GLTexStorageMem3DEXT, std::move(paramBuffer));
7147 }
7148
CaptureTexStorageMem3DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)7149 CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState,
7150 bool isCallValid,
7151 TextureType targetPacked,
7152 GLsizei samples,
7153 GLenum internalFormat,
7154 GLsizei width,
7155 GLsizei height,
7156 GLsizei depth,
7157 GLboolean fixedSampleLocations,
7158 MemoryObjectID memoryPacked,
7159 GLuint64 offset)
7160 {
7161 ParamBuffer paramBuffer;
7162
7163 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
7164 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7165 paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
7166 internalFormat);
7167 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7168 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7169 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
7170 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
7171 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7172 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
7173
7174 return CallCapture(angle::EntryPoint::GLTexStorageMem3DMultisampleEXT, std::move(paramBuffer));
7175 }
7176
CaptureImportMemoryFdEXT(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLint fd)7177 CallCapture CaptureImportMemoryFdEXT(const State &glState,
7178 bool isCallValid,
7179 MemoryObjectID memoryPacked,
7180 GLuint64 size,
7181 HandleType handleTypePacked,
7182 GLint fd)
7183 {
7184 ParamBuffer paramBuffer;
7185
7186 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
7187 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
7188 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
7189 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
7190
7191 return CallCapture(angle::EntryPoint::GLImportMemoryFdEXT, std::move(paramBuffer));
7192 }
7193
CaptureMultiDrawArraysIndirectEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,const void * indirect,GLsizei drawcount,GLsizei stride)7194 CallCapture CaptureMultiDrawArraysIndirectEXT(const State &glState,
7195 bool isCallValid,
7196 PrimitiveMode modePacked,
7197 const void *indirect,
7198 GLsizei drawcount,
7199 GLsizei stride)
7200 {
7201 ParamBuffer paramBuffer;
7202
7203 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7204
7205 if (isCallValid)
7206 {
7207 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7208 InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
7209 CaptureMultiDrawArraysIndirectEXT_indirect(glState, isCallValid, modePacked, indirect,
7210 drawcount, stride, &indirectParam);
7211 paramBuffer.addParam(std::move(indirectParam));
7212 }
7213 else
7214 {
7215 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7216 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7217 &indirectParam.value);
7218 paramBuffer.addParam(std::move(indirectParam));
7219 }
7220
7221 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
7222 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
7223
7224 return CallCapture(angle::EntryPoint::GLMultiDrawArraysIndirectEXT, std::move(paramBuffer));
7225 }
7226
CaptureMultiDrawElementsIndirectEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,DrawElementsType typePacked,const void * indirect,GLsizei drawcount,GLsizei stride)7227 CallCapture CaptureMultiDrawElementsIndirectEXT(const State &glState,
7228 bool isCallValid,
7229 PrimitiveMode modePacked,
7230 DrawElementsType typePacked,
7231 const void *indirect,
7232 GLsizei drawcount,
7233 GLsizei stride)
7234 {
7235 ParamBuffer paramBuffer;
7236
7237 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7238 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
7239
7240 if (isCallValid)
7241 {
7242 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7243 InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
7244 CaptureMultiDrawElementsIndirectEXT_indirect(glState, isCallValid, modePacked, typePacked,
7245 indirect, drawcount, stride, &indirectParam);
7246 paramBuffer.addParam(std::move(indirectParam));
7247 }
7248 else
7249 {
7250 ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
7251 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7252 &indirectParam.value);
7253 paramBuffer.addParam(std::move(indirectParam));
7254 }
7255
7256 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
7257 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
7258
7259 return CallCapture(angle::EntryPoint::GLMultiDrawElementsIndirectEXT, std::move(paramBuffer));
7260 }
7261
CaptureFramebufferTexture2DMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLsizei samples)7262 CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
7263 bool isCallValid,
7264 GLenum target,
7265 GLenum attachment,
7266 TextureTarget textargetPacked,
7267 TextureID texturePacked,
7268 GLint level,
7269 GLsizei samples)
7270 {
7271 ParamBuffer paramBuffer;
7272
7273 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
7274 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
7275 attachment);
7276 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
7277 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
7278 paramBuffer.addValueParam("level", ParamType::TGLint, level);
7279 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7280
7281 return CallCapture(angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT,
7282 std::move(paramBuffer));
7283 }
7284
CaptureRenderbufferStorageMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)7285 CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
7286 bool isCallValid,
7287 GLenum target,
7288 GLsizei samples,
7289 GLenum internalformat,
7290 GLsizei width,
7291 GLsizei height)
7292 {
7293 ParamBuffer paramBuffer;
7294
7295 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
7296 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
7297 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
7298 internalformat);
7299 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7300 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7301
7302 return CallCapture(angle::EntryPoint::GLRenderbufferStorageMultisampleEXT,
7303 std::move(paramBuffer));
7304 }
7305
CapturePolygonOffsetClampEXT(const State & glState,bool isCallValid,GLfloat factor,GLfloat units,GLfloat clamp)7306 CallCapture CapturePolygonOffsetClampEXT(const State &glState,
7307 bool isCallValid,
7308 GLfloat factor,
7309 GLfloat units,
7310 GLfloat clamp)
7311 {
7312 ParamBuffer paramBuffer;
7313
7314 paramBuffer.addValueParam("factor", ParamType::TGLfloat, factor);
7315 paramBuffer.addValueParam("units", ParamType::TGLfloat, units);
7316 paramBuffer.addValueParam("clamp", ParamType::TGLfloat, clamp);
7317
7318 return CallCapture(angle::EntryPoint::GLPolygonOffsetClampEXT, std::move(paramBuffer));
7319 }
7320
CapturePrimitiveBoundingBoxEXT(const State & glState,bool isCallValid,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)7321 CallCapture CapturePrimitiveBoundingBoxEXT(const State &glState,
7322 bool isCallValid,
7323 GLfloat minX,
7324 GLfloat minY,
7325 GLfloat minZ,
7326 GLfloat minW,
7327 GLfloat maxX,
7328 GLfloat maxY,
7329 GLfloat maxZ,
7330 GLfloat maxW)
7331 {
7332 ParamBuffer paramBuffer;
7333
7334 paramBuffer.addValueParam("minX", ParamType::TGLfloat, minX);
7335 paramBuffer.addValueParam("minY", ParamType::TGLfloat, minY);
7336 paramBuffer.addValueParam("minZ", ParamType::TGLfloat, minZ);
7337 paramBuffer.addValueParam("minW", ParamType::TGLfloat, minW);
7338 paramBuffer.addValueParam("maxX", ParamType::TGLfloat, maxX);
7339 paramBuffer.addValueParam("maxY", ParamType::TGLfloat, maxY);
7340 paramBuffer.addValueParam("maxZ", ParamType::TGLfloat, maxZ);
7341 paramBuffer.addValueParam("maxW", ParamType::TGLfloat, maxW);
7342
7343 return CallCapture(angle::EntryPoint::GLPrimitiveBoundingBoxEXT, std::move(paramBuffer));
7344 }
7345
CaptureGetGraphicsResetStatusEXT(const State & glState,bool isCallValid,GLenum returnValue)7346 CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
7347 bool isCallValid,
7348 GLenum returnValue)
7349 {
7350 ParamBuffer paramBuffer;
7351
7352 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
7353 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
7354 paramBuffer.addReturnValue(std::move(returnValueCapture));
7355
7356 return CallCapture(angle::EntryPoint::GLGetGraphicsResetStatusEXT, std::move(paramBuffer));
7357 }
7358
CaptureGetnUniformfvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)7359 CallCapture CaptureGetnUniformfvEXT(const State &glState,
7360 bool isCallValid,
7361 ShaderProgramID programPacked,
7362 UniformLocation locationPacked,
7363 GLsizei bufSize,
7364 GLfloat *params)
7365 {
7366 ParamBuffer paramBuffer;
7367
7368 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7369 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7370 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7371
7372 if (isCallValid)
7373 {
7374 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
7375 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
7376 CaptureGetnUniformfvEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
7377 params, ¶msParam);
7378 paramBuffer.addParam(std::move(paramsParam));
7379 }
7380 else
7381 {
7382 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
7383 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
7384 ¶msParam.value);
7385 paramBuffer.addParam(std::move(paramsParam));
7386 }
7387
7388 return CallCapture(angle::EntryPoint::GLGetnUniformfvEXT, std::move(paramBuffer));
7389 }
7390
CaptureGetnUniformivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)7391 CallCapture CaptureGetnUniformivEXT(const State &glState,
7392 bool isCallValid,
7393 ShaderProgramID programPacked,
7394 UniformLocation locationPacked,
7395 GLsizei bufSize,
7396 GLint *params)
7397 {
7398 ParamBuffer paramBuffer;
7399
7400 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7401 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7402 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7403
7404 if (isCallValid)
7405 {
7406 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7407 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
7408 CaptureGetnUniformivEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
7409 params, ¶msParam);
7410 paramBuffer.addParam(std::move(paramsParam));
7411 }
7412 else
7413 {
7414 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7415 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
7416 paramBuffer.addParam(std::move(paramsParam));
7417 }
7418
7419 return CallCapture(angle::EntryPoint::GLGetnUniformivEXT, std::move(paramBuffer));
7420 }
7421
CaptureReadnPixelsEXT(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)7422 CallCapture CaptureReadnPixelsEXT(const State &glState,
7423 bool isCallValid,
7424 GLint x,
7425 GLint y,
7426 GLsizei width,
7427 GLsizei height,
7428 GLenum format,
7429 GLenum type,
7430 GLsizei bufSize,
7431 void *data)
7432 {
7433 ParamBuffer paramBuffer;
7434
7435 paramBuffer.addValueParam("x", ParamType::TGLint, x);
7436 paramBuffer.addValueParam("y", ParamType::TGLint, y);
7437 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7438 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7439 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
7440 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
7441 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7442
7443 if (isCallValid)
7444 {
7445 ParamCapture dataParam("data", ParamType::TvoidPointer);
7446 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
7447 CaptureReadnPixelsEXT_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
7448 data, &dataParam);
7449 paramBuffer.addParam(std::move(dataParam));
7450 }
7451 else
7452 {
7453 ParamCapture dataParam("data", ParamType::TvoidPointer);
7454 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
7455 paramBuffer.addParam(std::move(dataParam));
7456 }
7457
7458 return CallCapture(angle::EntryPoint::GLReadnPixelsEXT, std::move(paramBuffer));
7459 }
7460
CaptureDeleteSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,const SemaphoreID * semaphoresPacked)7461 CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
7462 bool isCallValid,
7463 GLsizei n,
7464 const SemaphoreID *semaphoresPacked)
7465 {
7466 ParamBuffer paramBuffer;
7467
7468 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7469
7470 if (isCallValid)
7471 {
7472 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
7473 InitParamValue(ParamType::TSemaphoreIDConstPointer, semaphoresPacked,
7474 &semaphoresPackedParam.value);
7475 CaptureDeleteSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
7476 &semaphoresPackedParam);
7477 paramBuffer.addParam(std::move(semaphoresPackedParam));
7478 }
7479 else
7480 {
7481 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
7482 InitParamValue(ParamType::TSemaphoreIDConstPointer,
7483 static_cast<const SemaphoreID *>(nullptr), &semaphoresPackedParam.value);
7484 paramBuffer.addParam(std::move(semaphoresPackedParam));
7485 }
7486
7487 return CallCapture(angle::EntryPoint::GLDeleteSemaphoresEXT, std::move(paramBuffer));
7488 }
7489
CaptureGenSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,SemaphoreID * semaphoresPacked)7490 CallCapture CaptureGenSemaphoresEXT(const State &glState,
7491 bool isCallValid,
7492 GLsizei n,
7493 SemaphoreID *semaphoresPacked)
7494 {
7495 ParamBuffer paramBuffer;
7496
7497 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7498
7499 if (isCallValid)
7500 {
7501 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
7502 InitParamValue(ParamType::TSemaphoreIDPointer, semaphoresPacked,
7503 &semaphoresPackedParam.value);
7504 CaptureGenSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
7505 &semaphoresPackedParam);
7506 paramBuffer.addParam(std::move(semaphoresPackedParam));
7507 }
7508 else
7509 {
7510 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
7511 InitParamValue(ParamType::TSemaphoreIDPointer, static_cast<SemaphoreID *>(nullptr),
7512 &semaphoresPackedParam.value);
7513 paramBuffer.addParam(std::move(semaphoresPackedParam));
7514 }
7515
7516 return CallCapture(angle::EntryPoint::GLGenSemaphoresEXT, std::move(paramBuffer));
7517 }
7518
CaptureGetSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,GLuint64 * params)7519 CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
7520 bool isCallValid,
7521 SemaphoreID semaphorePacked,
7522 GLenum pname,
7523 GLuint64 *params)
7524 {
7525 ParamBuffer paramBuffer;
7526
7527 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7528 paramBuffer.addEnumParam("pname", GLESEnum::SemaphoreParameterName, ParamType::TGLenum, pname);
7529
7530 if (isCallValid)
7531 {
7532 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
7533 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
7534 CaptureGetSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
7535 params, ¶msParam);
7536 paramBuffer.addParam(std::move(paramsParam));
7537 }
7538 else
7539 {
7540 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
7541 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
7542 ¶msParam.value);
7543 paramBuffer.addParam(std::move(paramsParam));
7544 }
7545
7546 return CallCapture(angle::EntryPoint::GLGetSemaphoreParameterui64vEXT, std::move(paramBuffer));
7547 }
7548
CaptureIsSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLboolean returnValue)7549 CallCapture CaptureIsSemaphoreEXT(const State &glState,
7550 bool isCallValid,
7551 SemaphoreID semaphorePacked,
7552 GLboolean returnValue)
7553 {
7554 ParamBuffer paramBuffer;
7555
7556 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7557
7558 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7559 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7560 paramBuffer.addReturnValue(std::move(returnValueCapture));
7561
7562 return CallCapture(angle::EntryPoint::GLIsSemaphoreEXT, std::move(paramBuffer));
7563 }
7564
CaptureSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,const GLuint64 * params)7565 CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
7566 bool isCallValid,
7567 SemaphoreID semaphorePacked,
7568 GLenum pname,
7569 const GLuint64 *params)
7570 {
7571 ParamBuffer paramBuffer;
7572
7573 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7574 paramBuffer.addEnumParam("pname", GLESEnum::SemaphoreParameterName, ParamType::TGLenum, pname);
7575
7576 if (isCallValid)
7577 {
7578 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
7579 InitParamValue(ParamType::TGLuint64ConstPointer, params, ¶msParam.value);
7580 CaptureSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
7581 params, ¶msParam);
7582 paramBuffer.addParam(std::move(paramsParam));
7583 }
7584 else
7585 {
7586 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
7587 InitParamValue(ParamType::TGLuint64ConstPointer, static_cast<const GLuint64 *>(nullptr),
7588 ¶msParam.value);
7589 paramBuffer.addParam(std::move(paramsParam));
7590 }
7591
7592 return CallCapture(angle::EntryPoint::GLSemaphoreParameterui64vEXT, std::move(paramBuffer));
7593 }
7594
CaptureSignalSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * dstLayouts)7595 CallCapture CaptureSignalSemaphoreEXT(const State &glState,
7596 bool isCallValid,
7597 SemaphoreID semaphorePacked,
7598 GLuint numBufferBarriers,
7599 const BufferID *buffersPacked,
7600 GLuint numTextureBarriers,
7601 const TextureID *texturesPacked,
7602 const GLenum *dstLayouts)
7603 {
7604 ParamBuffer paramBuffer;
7605
7606 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7607 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
7608
7609 if (isCallValid)
7610 {
7611 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7612 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
7613 CaptureSignalSemaphoreEXT_buffersPacked(
7614 glState, isCallValid, semaphorePacked, numBufferBarriers, buffersPacked,
7615 numTextureBarriers, texturesPacked, dstLayouts, &buffersPackedParam);
7616 paramBuffer.addParam(std::move(buffersPackedParam));
7617 }
7618 else
7619 {
7620 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7621 InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
7622 &buffersPackedParam.value);
7623 paramBuffer.addParam(std::move(buffersPackedParam));
7624 }
7625
7626 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
7627
7628 if (isCallValid)
7629 {
7630 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7631 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
7632 &texturesPackedParam.value);
7633 CaptureSignalSemaphoreEXT_texturesPacked(
7634 glState, isCallValid, semaphorePacked, numBufferBarriers, buffersPacked,
7635 numTextureBarriers, texturesPacked, dstLayouts, &texturesPackedParam);
7636 paramBuffer.addParam(std::move(texturesPackedParam));
7637 }
7638 else
7639 {
7640 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7641 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
7642 &texturesPackedParam.value);
7643 paramBuffer.addParam(std::move(texturesPackedParam));
7644 }
7645
7646 if (isCallValid)
7647 {
7648 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
7649 InitParamValue(ParamType::TGLenumConstPointer, dstLayouts, &dstLayoutsParam.value);
7650 CaptureSignalSemaphoreEXT_dstLayouts(glState, isCallValid, semaphorePacked,
7651 numBufferBarriers, buffersPacked, numTextureBarriers,
7652 texturesPacked, dstLayouts, &dstLayoutsParam);
7653 paramBuffer.addParam(std::move(dstLayoutsParam));
7654 }
7655 else
7656 {
7657 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
7658 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
7659 &dstLayoutsParam.value);
7660 paramBuffer.addParam(std::move(dstLayoutsParam));
7661 }
7662
7663 return CallCapture(angle::EntryPoint::GLSignalSemaphoreEXT, std::move(paramBuffer));
7664 }
7665
CaptureWaitSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * srcLayouts)7666 CallCapture CaptureWaitSemaphoreEXT(const State &glState,
7667 bool isCallValid,
7668 SemaphoreID semaphorePacked,
7669 GLuint numBufferBarriers,
7670 const BufferID *buffersPacked,
7671 GLuint numTextureBarriers,
7672 const TextureID *texturesPacked,
7673 const GLenum *srcLayouts)
7674 {
7675 ParamBuffer paramBuffer;
7676
7677 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7678 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
7679
7680 if (isCallValid)
7681 {
7682 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7683 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
7684 CaptureWaitSemaphoreEXT_buffersPacked(glState, isCallValid, semaphorePacked,
7685 numBufferBarriers, buffersPacked, numTextureBarriers,
7686 texturesPacked, srcLayouts, &buffersPackedParam);
7687 paramBuffer.addParam(std::move(buffersPackedParam));
7688 }
7689 else
7690 {
7691 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
7692 InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
7693 &buffersPackedParam.value);
7694 paramBuffer.addParam(std::move(buffersPackedParam));
7695 }
7696
7697 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
7698
7699 if (isCallValid)
7700 {
7701 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7702 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
7703 &texturesPackedParam.value);
7704 CaptureWaitSemaphoreEXT_texturesPacked(glState, isCallValid, semaphorePacked,
7705 numBufferBarriers, buffersPacked, numTextureBarriers,
7706 texturesPacked, srcLayouts, &texturesPackedParam);
7707 paramBuffer.addParam(std::move(texturesPackedParam));
7708 }
7709 else
7710 {
7711 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
7712 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
7713 &texturesPackedParam.value);
7714 paramBuffer.addParam(std::move(texturesPackedParam));
7715 }
7716
7717 if (isCallValid)
7718 {
7719 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
7720 InitParamValue(ParamType::TGLenumConstPointer, srcLayouts, &srcLayoutsParam.value);
7721 CaptureWaitSemaphoreEXT_srcLayouts(glState, isCallValid, semaphorePacked, numBufferBarriers,
7722 buffersPacked, numTextureBarriers, texturesPacked,
7723 srcLayouts, &srcLayoutsParam);
7724 paramBuffer.addParam(std::move(srcLayoutsParam));
7725 }
7726 else
7727 {
7728 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
7729 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
7730 &srcLayoutsParam.value);
7731 paramBuffer.addParam(std::move(srcLayoutsParam));
7732 }
7733
7734 return CallCapture(angle::EntryPoint::GLWaitSemaphoreEXT, std::move(paramBuffer));
7735 }
7736
CaptureImportSemaphoreFdEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLint fd)7737 CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
7738 bool isCallValid,
7739 SemaphoreID semaphorePacked,
7740 HandleType handleTypePacked,
7741 GLint fd)
7742 {
7743 ParamBuffer paramBuffer;
7744
7745 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
7746 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
7747 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
7748
7749 return CallCapture(angle::EntryPoint::GLImportSemaphoreFdEXT, std::move(paramBuffer));
7750 }
7751
CaptureActiveShaderProgramEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,ShaderProgramID programPacked)7752 CallCapture CaptureActiveShaderProgramEXT(const State &glState,
7753 bool isCallValid,
7754 ProgramPipelineID pipelinePacked,
7755 ShaderProgramID programPacked)
7756 {
7757 ParamBuffer paramBuffer;
7758
7759 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7760 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7761
7762 return CallCapture(angle::EntryPoint::GLActiveShaderProgramEXT, std::move(paramBuffer));
7763 }
7764
CaptureBindProgramPipelineEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked)7765 CallCapture CaptureBindProgramPipelineEXT(const State &glState,
7766 bool isCallValid,
7767 ProgramPipelineID pipelinePacked)
7768 {
7769 ParamBuffer paramBuffer;
7770
7771 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7772
7773 return CallCapture(angle::EntryPoint::GLBindProgramPipelineEXT, std::move(paramBuffer));
7774 }
7775
CaptureCreateShaderProgramvEXT(const State & glState,bool isCallValid,ShaderType typePacked,GLsizei count,const GLchar ** strings,GLuint returnValue)7776 CallCapture CaptureCreateShaderProgramvEXT(const State &glState,
7777 bool isCallValid,
7778 ShaderType typePacked,
7779 GLsizei count,
7780 const GLchar **strings,
7781 GLuint returnValue)
7782 {
7783 ParamBuffer paramBuffer;
7784
7785 paramBuffer.addValueParam("typePacked", ParamType::TShaderType, typePacked);
7786 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7787
7788 if (isCallValid)
7789 {
7790 ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
7791 InitParamValue(ParamType::TGLcharConstPointerPointer, strings, &stringsParam.value);
7792 CaptureCreateShaderProgramvEXT_strings(glState, isCallValid, typePacked, count, strings,
7793 &stringsParam);
7794 paramBuffer.addParam(std::move(stringsParam));
7795 }
7796 else
7797 {
7798 ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
7799 InitParamValue(ParamType::TGLcharConstPointerPointer, static_cast<const GLchar **>(nullptr),
7800 &stringsParam.value);
7801 paramBuffer.addParam(std::move(stringsParam));
7802 }
7803
7804 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
7805 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
7806 paramBuffer.addReturnValue(std::move(returnValueCapture));
7807
7808 return CallCapture(angle::EntryPoint::GLCreateShaderProgramvEXT, std::move(paramBuffer));
7809 }
7810
CaptureDeleteProgramPipelinesEXT(const State & glState,bool isCallValid,GLsizei n,const ProgramPipelineID * pipelinesPacked)7811 CallCapture CaptureDeleteProgramPipelinesEXT(const State &glState,
7812 bool isCallValid,
7813 GLsizei n,
7814 const ProgramPipelineID *pipelinesPacked)
7815 {
7816 ParamBuffer paramBuffer;
7817
7818 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7819
7820 if (isCallValid)
7821 {
7822 ParamCapture pipelinesPackedParam("pipelinesPacked",
7823 ParamType::TProgramPipelineIDConstPointer);
7824 InitParamValue(ParamType::TProgramPipelineIDConstPointer, pipelinesPacked,
7825 &pipelinesPackedParam.value);
7826 CaptureDeleteProgramPipelinesEXT_pipelinesPacked(glState, isCallValid, n, pipelinesPacked,
7827 &pipelinesPackedParam);
7828 paramBuffer.addParam(std::move(pipelinesPackedParam));
7829 }
7830 else
7831 {
7832 ParamCapture pipelinesPackedParam("pipelinesPacked",
7833 ParamType::TProgramPipelineIDConstPointer);
7834 InitParamValue(ParamType::TProgramPipelineIDConstPointer,
7835 static_cast<const ProgramPipelineID *>(nullptr),
7836 &pipelinesPackedParam.value);
7837 paramBuffer.addParam(std::move(pipelinesPackedParam));
7838 }
7839
7840 return CallCapture(angle::EntryPoint::GLDeleteProgramPipelinesEXT, std::move(paramBuffer));
7841 }
7842
CaptureGenProgramPipelinesEXT(const State & glState,bool isCallValid,GLsizei n,ProgramPipelineID * pipelinesPacked)7843 CallCapture CaptureGenProgramPipelinesEXT(const State &glState,
7844 bool isCallValid,
7845 GLsizei n,
7846 ProgramPipelineID *pipelinesPacked)
7847 {
7848 ParamBuffer paramBuffer;
7849
7850 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7851
7852 if (isCallValid)
7853 {
7854 ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDPointer);
7855 InitParamValue(ParamType::TProgramPipelineIDPointer, pipelinesPacked,
7856 &pipelinesPackedParam.value);
7857 CaptureGenProgramPipelinesEXT_pipelinesPacked(glState, isCallValid, n, pipelinesPacked,
7858 &pipelinesPackedParam);
7859 paramBuffer.addParam(std::move(pipelinesPackedParam));
7860 }
7861 else
7862 {
7863 ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDPointer);
7864 InitParamValue(ParamType::TProgramPipelineIDPointer,
7865 static_cast<ProgramPipelineID *>(nullptr), &pipelinesPackedParam.value);
7866 paramBuffer.addParam(std::move(pipelinesPackedParam));
7867 }
7868
7869 return CallCapture(angle::EntryPoint::GLGenProgramPipelinesEXT, std::move(paramBuffer));
7870 }
7871
CaptureGetProgramPipelineInfoLogEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLsizei bufSize,GLsizei * length,GLchar * infoLog)7872 CallCapture CaptureGetProgramPipelineInfoLogEXT(const State &glState,
7873 bool isCallValid,
7874 ProgramPipelineID pipelinePacked,
7875 GLsizei bufSize,
7876 GLsizei *length,
7877 GLchar *infoLog)
7878 {
7879 ParamBuffer paramBuffer;
7880
7881 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7882 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7883
7884 if (isCallValid)
7885 {
7886 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
7887 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
7888 CaptureGetProgramPipelineInfoLogEXT_length(glState, isCallValid, pipelinePacked, bufSize,
7889 length, infoLog, &lengthParam);
7890 paramBuffer.addParam(std::move(lengthParam));
7891 }
7892 else
7893 {
7894 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
7895 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
7896 &lengthParam.value);
7897 paramBuffer.addParam(std::move(lengthParam));
7898 }
7899
7900 if (isCallValid)
7901 {
7902 ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
7903 InitParamValue(ParamType::TGLcharPointer, infoLog, &infoLogParam.value);
7904 CaptureGetProgramPipelineInfoLogEXT_infoLog(glState, isCallValid, pipelinePacked, bufSize,
7905 length, infoLog, &infoLogParam);
7906 paramBuffer.addParam(std::move(infoLogParam));
7907 }
7908 else
7909 {
7910 ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
7911 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
7912 &infoLogParam.value);
7913 paramBuffer.addParam(std::move(infoLogParam));
7914 }
7915
7916 return CallCapture(angle::EntryPoint::GLGetProgramPipelineInfoLogEXT, std::move(paramBuffer));
7917 }
7918
CaptureGetProgramPipelineivEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLenum pname,GLint * params)7919 CallCapture CaptureGetProgramPipelineivEXT(const State &glState,
7920 bool isCallValid,
7921 ProgramPipelineID pipelinePacked,
7922 GLenum pname,
7923 GLint *params)
7924 {
7925 ParamBuffer paramBuffer;
7926
7927 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7928 paramBuffer.addEnumParam("pname", GLESEnum::PipelineParameterName, ParamType::TGLenum, pname);
7929
7930 if (isCallValid)
7931 {
7932 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7933 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
7934 CaptureGetProgramPipelineivEXT_params(glState, isCallValid, pipelinePacked, pname, params,
7935 ¶msParam);
7936 paramBuffer.addParam(std::move(paramsParam));
7937 }
7938 else
7939 {
7940 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7941 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
7942 paramBuffer.addParam(std::move(paramsParam));
7943 }
7944
7945 return CallCapture(angle::EntryPoint::GLGetProgramPipelineivEXT, std::move(paramBuffer));
7946 }
7947
CaptureIsProgramPipelineEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLboolean returnValue)7948 CallCapture CaptureIsProgramPipelineEXT(const State &glState,
7949 bool isCallValid,
7950 ProgramPipelineID pipelinePacked,
7951 GLboolean returnValue)
7952 {
7953 ParamBuffer paramBuffer;
7954
7955 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
7956
7957 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7958 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7959 paramBuffer.addReturnValue(std::move(returnValueCapture));
7960
7961 return CallCapture(angle::EntryPoint::GLIsProgramPipelineEXT, std::move(paramBuffer));
7962 }
7963
CaptureProgramParameteriEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum pname,GLint value)7964 CallCapture CaptureProgramParameteriEXT(const State &glState,
7965 bool isCallValid,
7966 ShaderProgramID programPacked,
7967 GLenum pname,
7968 GLint value)
7969 {
7970 ParamBuffer paramBuffer;
7971
7972 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7973 paramBuffer.addEnumParam("pname", GLESEnum::ProgramParameterPName, ParamType::TGLenum, pname);
7974 paramBuffer.addValueParam("value", ParamType::TGLint, value);
7975
7976 return CallCapture(angle::EntryPoint::GLProgramParameteriEXT, std::move(paramBuffer));
7977 }
7978
CaptureProgramUniform1fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0)7979 CallCapture CaptureProgramUniform1fEXT(const State &glState,
7980 bool isCallValid,
7981 ShaderProgramID programPacked,
7982 UniformLocation locationPacked,
7983 GLfloat v0)
7984 {
7985 ParamBuffer paramBuffer;
7986
7987 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7988 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
7989 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
7990
7991 return CallCapture(angle::EntryPoint::GLProgramUniform1fEXT, std::move(paramBuffer));
7992 }
7993
CaptureProgramUniform1fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)7994 CallCapture CaptureProgramUniform1fvEXT(const State &glState,
7995 bool isCallValid,
7996 ShaderProgramID programPacked,
7997 UniformLocation locationPacked,
7998 GLsizei count,
7999 const GLfloat *value)
8000 {
8001 ParamBuffer paramBuffer;
8002
8003 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8004 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8005 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8006
8007 if (isCallValid)
8008 {
8009 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8010 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8011 CaptureProgramUniform1fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8012 count, value, &valueParam);
8013 paramBuffer.addParam(std::move(valueParam));
8014 }
8015 else
8016 {
8017 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8018 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8019 &valueParam.value);
8020 paramBuffer.addParam(std::move(valueParam));
8021 }
8022
8023 return CallCapture(angle::EntryPoint::GLProgramUniform1fvEXT, std::move(paramBuffer));
8024 }
8025
CaptureProgramUniform1iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0)8026 CallCapture CaptureProgramUniform1iEXT(const State &glState,
8027 bool isCallValid,
8028 ShaderProgramID programPacked,
8029 UniformLocation locationPacked,
8030 GLint v0)
8031 {
8032 ParamBuffer paramBuffer;
8033
8034 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8035 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8036 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8037
8038 return CallCapture(angle::EntryPoint::GLProgramUniform1iEXT, std::move(paramBuffer));
8039 }
8040
CaptureProgramUniform1ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8041 CallCapture CaptureProgramUniform1ivEXT(const State &glState,
8042 bool isCallValid,
8043 ShaderProgramID programPacked,
8044 UniformLocation locationPacked,
8045 GLsizei count,
8046 const GLint *value)
8047 {
8048 ParamBuffer paramBuffer;
8049
8050 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8051 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8052 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8053
8054 if (isCallValid)
8055 {
8056 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8057 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8058 CaptureProgramUniform1ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8059 count, value, &valueParam);
8060 paramBuffer.addParam(std::move(valueParam));
8061 }
8062 else
8063 {
8064 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8065 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8066 &valueParam.value);
8067 paramBuffer.addParam(std::move(valueParam));
8068 }
8069
8070 return CallCapture(angle::EntryPoint::GLProgramUniform1ivEXT, std::move(paramBuffer));
8071 }
8072
CaptureProgramUniform1uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0)8073 CallCapture CaptureProgramUniform1uiEXT(const State &glState,
8074 bool isCallValid,
8075 ShaderProgramID programPacked,
8076 UniformLocation locationPacked,
8077 GLuint v0)
8078 {
8079 ParamBuffer paramBuffer;
8080
8081 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8082 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8083 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8084
8085 return CallCapture(angle::EntryPoint::GLProgramUniform1uiEXT, std::move(paramBuffer));
8086 }
8087
CaptureProgramUniform1uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8088 CallCapture CaptureProgramUniform1uivEXT(const State &glState,
8089 bool isCallValid,
8090 ShaderProgramID programPacked,
8091 UniformLocation locationPacked,
8092 GLsizei count,
8093 const GLuint *value)
8094 {
8095 ParamBuffer paramBuffer;
8096
8097 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8098 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8099 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8100
8101 if (isCallValid)
8102 {
8103 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8104 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8105 CaptureProgramUniform1uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8106 count, value, &valueParam);
8107 paramBuffer.addParam(std::move(valueParam));
8108 }
8109 else
8110 {
8111 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8112 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8113 &valueParam.value);
8114 paramBuffer.addParam(std::move(valueParam));
8115 }
8116
8117 return CallCapture(angle::EntryPoint::GLProgramUniform1uivEXT, std::move(paramBuffer));
8118 }
8119
CaptureProgramUniform2fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0,GLfloat v1)8120 CallCapture CaptureProgramUniform2fEXT(const State &glState,
8121 bool isCallValid,
8122 ShaderProgramID programPacked,
8123 UniformLocation locationPacked,
8124 GLfloat v0,
8125 GLfloat v1)
8126 {
8127 ParamBuffer paramBuffer;
8128
8129 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8130 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8131 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
8132 paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
8133
8134 return CallCapture(angle::EntryPoint::GLProgramUniform2fEXT, std::move(paramBuffer));
8135 }
8136
CaptureProgramUniform2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)8137 CallCapture CaptureProgramUniform2fvEXT(const State &glState,
8138 bool isCallValid,
8139 ShaderProgramID programPacked,
8140 UniformLocation locationPacked,
8141 GLsizei count,
8142 const GLfloat *value)
8143 {
8144 ParamBuffer paramBuffer;
8145
8146 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8147 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8148 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8149
8150 if (isCallValid)
8151 {
8152 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8153 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8154 CaptureProgramUniform2fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8155 count, value, &valueParam);
8156 paramBuffer.addParam(std::move(valueParam));
8157 }
8158 else
8159 {
8160 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8161 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8162 &valueParam.value);
8163 paramBuffer.addParam(std::move(valueParam));
8164 }
8165
8166 return CallCapture(angle::EntryPoint::GLProgramUniform2fvEXT, std::move(paramBuffer));
8167 }
8168
CaptureProgramUniform2iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0,GLint v1)8169 CallCapture CaptureProgramUniform2iEXT(const State &glState,
8170 bool isCallValid,
8171 ShaderProgramID programPacked,
8172 UniformLocation locationPacked,
8173 GLint v0,
8174 GLint v1)
8175 {
8176 ParamBuffer paramBuffer;
8177
8178 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8179 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8180 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8181 paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
8182
8183 return CallCapture(angle::EntryPoint::GLProgramUniform2iEXT, std::move(paramBuffer));
8184 }
8185
CaptureProgramUniform2ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8186 CallCapture CaptureProgramUniform2ivEXT(const State &glState,
8187 bool isCallValid,
8188 ShaderProgramID programPacked,
8189 UniformLocation locationPacked,
8190 GLsizei count,
8191 const GLint *value)
8192 {
8193 ParamBuffer paramBuffer;
8194
8195 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8196 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8197 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8198
8199 if (isCallValid)
8200 {
8201 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8202 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8203 CaptureProgramUniform2ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8204 count, value, &valueParam);
8205 paramBuffer.addParam(std::move(valueParam));
8206 }
8207 else
8208 {
8209 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8210 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8211 &valueParam.value);
8212 paramBuffer.addParam(std::move(valueParam));
8213 }
8214
8215 return CallCapture(angle::EntryPoint::GLProgramUniform2ivEXT, std::move(paramBuffer));
8216 }
8217
CaptureProgramUniform2uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0,GLuint v1)8218 CallCapture CaptureProgramUniform2uiEXT(const State &glState,
8219 bool isCallValid,
8220 ShaderProgramID programPacked,
8221 UniformLocation locationPacked,
8222 GLuint v0,
8223 GLuint v1)
8224 {
8225 ParamBuffer paramBuffer;
8226
8227 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8228 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8229 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8230 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
8231
8232 return CallCapture(angle::EntryPoint::GLProgramUniform2uiEXT, std::move(paramBuffer));
8233 }
8234
CaptureProgramUniform2uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8235 CallCapture CaptureProgramUniform2uivEXT(const State &glState,
8236 bool isCallValid,
8237 ShaderProgramID programPacked,
8238 UniformLocation locationPacked,
8239 GLsizei count,
8240 const GLuint *value)
8241 {
8242 ParamBuffer paramBuffer;
8243
8244 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8245 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8246 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8247
8248 if (isCallValid)
8249 {
8250 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8251 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8252 CaptureProgramUniform2uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8253 count, value, &valueParam);
8254 paramBuffer.addParam(std::move(valueParam));
8255 }
8256 else
8257 {
8258 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8259 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8260 &valueParam.value);
8261 paramBuffer.addParam(std::move(valueParam));
8262 }
8263
8264 return CallCapture(angle::EntryPoint::GLProgramUniform2uivEXT, std::move(paramBuffer));
8265 }
8266
CaptureProgramUniform3fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0,GLfloat v1,GLfloat v2)8267 CallCapture CaptureProgramUniform3fEXT(const State &glState,
8268 bool isCallValid,
8269 ShaderProgramID programPacked,
8270 UniformLocation locationPacked,
8271 GLfloat v0,
8272 GLfloat v1,
8273 GLfloat v2)
8274 {
8275 ParamBuffer paramBuffer;
8276
8277 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8278 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8279 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
8280 paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
8281 paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
8282
8283 return CallCapture(angle::EntryPoint::GLProgramUniform3fEXT, std::move(paramBuffer));
8284 }
8285
CaptureProgramUniform3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)8286 CallCapture CaptureProgramUniform3fvEXT(const State &glState,
8287 bool isCallValid,
8288 ShaderProgramID programPacked,
8289 UniformLocation locationPacked,
8290 GLsizei count,
8291 const GLfloat *value)
8292 {
8293 ParamBuffer paramBuffer;
8294
8295 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8296 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8297 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8298
8299 if (isCallValid)
8300 {
8301 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8302 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8303 CaptureProgramUniform3fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8304 count, value, &valueParam);
8305 paramBuffer.addParam(std::move(valueParam));
8306 }
8307 else
8308 {
8309 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8310 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8311 &valueParam.value);
8312 paramBuffer.addParam(std::move(valueParam));
8313 }
8314
8315 return CallCapture(angle::EntryPoint::GLProgramUniform3fvEXT, std::move(paramBuffer));
8316 }
8317
CaptureProgramUniform3iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0,GLint v1,GLint v2)8318 CallCapture CaptureProgramUniform3iEXT(const State &glState,
8319 bool isCallValid,
8320 ShaderProgramID programPacked,
8321 UniformLocation locationPacked,
8322 GLint v0,
8323 GLint v1,
8324 GLint v2)
8325 {
8326 ParamBuffer paramBuffer;
8327
8328 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8329 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8330 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8331 paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
8332 paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
8333
8334 return CallCapture(angle::EntryPoint::GLProgramUniform3iEXT, std::move(paramBuffer));
8335 }
8336
CaptureProgramUniform3ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8337 CallCapture CaptureProgramUniform3ivEXT(const State &glState,
8338 bool isCallValid,
8339 ShaderProgramID programPacked,
8340 UniformLocation locationPacked,
8341 GLsizei count,
8342 const GLint *value)
8343 {
8344 ParamBuffer paramBuffer;
8345
8346 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8347 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8348 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8349
8350 if (isCallValid)
8351 {
8352 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8353 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8354 CaptureProgramUniform3ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8355 count, value, &valueParam);
8356 paramBuffer.addParam(std::move(valueParam));
8357 }
8358 else
8359 {
8360 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8361 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8362 &valueParam.value);
8363 paramBuffer.addParam(std::move(valueParam));
8364 }
8365
8366 return CallCapture(angle::EntryPoint::GLProgramUniform3ivEXT, std::move(paramBuffer));
8367 }
8368
CaptureProgramUniform3uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0,GLuint v1,GLuint v2)8369 CallCapture CaptureProgramUniform3uiEXT(const State &glState,
8370 bool isCallValid,
8371 ShaderProgramID programPacked,
8372 UniformLocation locationPacked,
8373 GLuint v0,
8374 GLuint v1,
8375 GLuint v2)
8376 {
8377 ParamBuffer paramBuffer;
8378
8379 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8380 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8381 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8382 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
8383 paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
8384
8385 return CallCapture(angle::EntryPoint::GLProgramUniform3uiEXT, std::move(paramBuffer));
8386 }
8387
CaptureProgramUniform3uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8388 CallCapture CaptureProgramUniform3uivEXT(const State &glState,
8389 bool isCallValid,
8390 ShaderProgramID programPacked,
8391 UniformLocation locationPacked,
8392 GLsizei count,
8393 const GLuint *value)
8394 {
8395 ParamBuffer paramBuffer;
8396
8397 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8398 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8399 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8400
8401 if (isCallValid)
8402 {
8403 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8404 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8405 CaptureProgramUniform3uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8406 count, value, &valueParam);
8407 paramBuffer.addParam(std::move(valueParam));
8408 }
8409 else
8410 {
8411 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8412 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8413 &valueParam.value);
8414 paramBuffer.addParam(std::move(valueParam));
8415 }
8416
8417 return CallCapture(angle::EntryPoint::GLProgramUniform3uivEXT, std::move(paramBuffer));
8418 }
8419
CaptureProgramUniform4fEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)8420 CallCapture CaptureProgramUniform4fEXT(const State &glState,
8421 bool isCallValid,
8422 ShaderProgramID programPacked,
8423 UniformLocation locationPacked,
8424 GLfloat v0,
8425 GLfloat v1,
8426 GLfloat v2,
8427 GLfloat v3)
8428 {
8429 ParamBuffer paramBuffer;
8430
8431 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8432 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8433 paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
8434 paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
8435 paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
8436 paramBuffer.addValueParam("v3", ParamType::TGLfloat, v3);
8437
8438 return CallCapture(angle::EntryPoint::GLProgramUniform4fEXT, std::move(paramBuffer));
8439 }
8440
CaptureProgramUniform4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLfloat * value)8441 CallCapture CaptureProgramUniform4fvEXT(const State &glState,
8442 bool isCallValid,
8443 ShaderProgramID programPacked,
8444 UniformLocation locationPacked,
8445 GLsizei count,
8446 const GLfloat *value)
8447 {
8448 ParamBuffer paramBuffer;
8449
8450 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8451 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8452 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8453
8454 if (isCallValid)
8455 {
8456 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8457 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8458 CaptureProgramUniform4fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8459 count, value, &valueParam);
8460 paramBuffer.addParam(std::move(valueParam));
8461 }
8462 else
8463 {
8464 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8465 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8466 &valueParam.value);
8467 paramBuffer.addParam(std::move(valueParam));
8468 }
8469
8470 return CallCapture(angle::EntryPoint::GLProgramUniform4fvEXT, std::move(paramBuffer));
8471 }
8472
CaptureProgramUniform4iEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLint v0,GLint v1,GLint v2,GLint v3)8473 CallCapture CaptureProgramUniform4iEXT(const State &glState,
8474 bool isCallValid,
8475 ShaderProgramID programPacked,
8476 UniformLocation locationPacked,
8477 GLint v0,
8478 GLint v1,
8479 GLint v2,
8480 GLint v3)
8481 {
8482 ParamBuffer paramBuffer;
8483
8484 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8485 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8486 paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
8487 paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
8488 paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
8489 paramBuffer.addValueParam("v3", ParamType::TGLint, v3);
8490
8491 return CallCapture(angle::EntryPoint::GLProgramUniform4iEXT, std::move(paramBuffer));
8492 }
8493
CaptureProgramUniform4ivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLint * value)8494 CallCapture CaptureProgramUniform4ivEXT(const State &glState,
8495 bool isCallValid,
8496 ShaderProgramID programPacked,
8497 UniformLocation locationPacked,
8498 GLsizei count,
8499 const GLint *value)
8500 {
8501 ParamBuffer paramBuffer;
8502
8503 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8504 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8505 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8506
8507 if (isCallValid)
8508 {
8509 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8510 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
8511 CaptureProgramUniform4ivEXT_value(glState, isCallValid, programPacked, locationPacked,
8512 count, value, &valueParam);
8513 paramBuffer.addParam(std::move(valueParam));
8514 }
8515 else
8516 {
8517 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
8518 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8519 &valueParam.value);
8520 paramBuffer.addParam(std::move(valueParam));
8521 }
8522
8523 return CallCapture(angle::EntryPoint::GLProgramUniform4ivEXT, std::move(paramBuffer));
8524 }
8525
CaptureProgramUniform4uiEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLuint v0,GLuint v1,GLuint v2,GLuint v3)8526 CallCapture CaptureProgramUniform4uiEXT(const State &glState,
8527 bool isCallValid,
8528 ShaderProgramID programPacked,
8529 UniformLocation locationPacked,
8530 GLuint v0,
8531 GLuint v1,
8532 GLuint v2,
8533 GLuint v3)
8534 {
8535 ParamBuffer paramBuffer;
8536
8537 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8538 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8539 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
8540 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
8541 paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
8542 paramBuffer.addValueParam("v3", ParamType::TGLuint, v3);
8543
8544 return CallCapture(angle::EntryPoint::GLProgramUniform4uiEXT, std::move(paramBuffer));
8545 }
8546
CaptureProgramUniform4uivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,const GLuint * value)8547 CallCapture CaptureProgramUniform4uivEXT(const State &glState,
8548 bool isCallValid,
8549 ShaderProgramID programPacked,
8550 UniformLocation locationPacked,
8551 GLsizei count,
8552 const GLuint *value)
8553 {
8554 ParamBuffer paramBuffer;
8555
8556 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8557 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8558 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8559
8560 if (isCallValid)
8561 {
8562 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8563 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
8564 CaptureProgramUniform4uivEXT_value(glState, isCallValid, programPacked, locationPacked,
8565 count, value, &valueParam);
8566 paramBuffer.addParam(std::move(valueParam));
8567 }
8568 else
8569 {
8570 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
8571 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8572 &valueParam.value);
8573 paramBuffer.addParam(std::move(valueParam));
8574 }
8575
8576 return CallCapture(angle::EntryPoint::GLProgramUniform4uivEXT, std::move(paramBuffer));
8577 }
8578
CaptureProgramUniformMatrix2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8579 CallCapture CaptureProgramUniformMatrix2fvEXT(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 CaptureProgramUniformMatrix2fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8599 count, transpose, value, &valueParam);
8600 paramBuffer.addParam(std::move(valueParam));
8601 }
8602 else
8603 {
8604 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8605 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8606 &valueParam.value);
8607 paramBuffer.addParam(std::move(valueParam));
8608 }
8609
8610 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2fvEXT, std::move(paramBuffer));
8611 }
8612
CaptureProgramUniformMatrix2x3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8613 CallCapture CaptureProgramUniformMatrix2x3fvEXT(const State &glState,
8614 bool isCallValid,
8615 ShaderProgramID programPacked,
8616 UniformLocation locationPacked,
8617 GLsizei count,
8618 GLboolean transpose,
8619 const GLfloat *value)
8620 {
8621 ParamBuffer paramBuffer;
8622
8623 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8624 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8625 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8626 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8627
8628 if (isCallValid)
8629 {
8630 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8631 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8632 CaptureProgramUniformMatrix2x3fvEXT_value(glState, isCallValid, programPacked,
8633 locationPacked, count, transpose, value,
8634 &valueParam);
8635 paramBuffer.addParam(std::move(valueParam));
8636 }
8637 else
8638 {
8639 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8640 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8641 &valueParam.value);
8642 paramBuffer.addParam(std::move(valueParam));
8643 }
8644
8645 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT, std::move(paramBuffer));
8646 }
8647
CaptureProgramUniformMatrix2x4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8648 CallCapture CaptureProgramUniformMatrix2x4fvEXT(const State &glState,
8649 bool isCallValid,
8650 ShaderProgramID programPacked,
8651 UniformLocation locationPacked,
8652 GLsizei count,
8653 GLboolean transpose,
8654 const GLfloat *value)
8655 {
8656 ParamBuffer paramBuffer;
8657
8658 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8659 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8660 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8661 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8662
8663 if (isCallValid)
8664 {
8665 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8666 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8667 CaptureProgramUniformMatrix2x4fvEXT_value(glState, isCallValid, programPacked,
8668 locationPacked, count, transpose, value,
8669 &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::GLProgramUniformMatrix2x4fvEXT, std::move(paramBuffer));
8681 }
8682
CaptureProgramUniformMatrix3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8683 CallCapture CaptureProgramUniformMatrix3fvEXT(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 CaptureProgramUniformMatrix3fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8703 count, transpose, value, &valueParam);
8704 paramBuffer.addParam(std::move(valueParam));
8705 }
8706 else
8707 {
8708 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8709 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8710 &valueParam.value);
8711 paramBuffer.addParam(std::move(valueParam));
8712 }
8713
8714 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3fvEXT, std::move(paramBuffer));
8715 }
8716
CaptureProgramUniformMatrix3x2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8717 CallCapture CaptureProgramUniformMatrix3x2fvEXT(const State &glState,
8718 bool isCallValid,
8719 ShaderProgramID programPacked,
8720 UniformLocation locationPacked,
8721 GLsizei count,
8722 GLboolean transpose,
8723 const GLfloat *value)
8724 {
8725 ParamBuffer paramBuffer;
8726
8727 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8728 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8729 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8730 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8731
8732 if (isCallValid)
8733 {
8734 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8735 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8736 CaptureProgramUniformMatrix3x2fvEXT_value(glState, isCallValid, programPacked,
8737 locationPacked, count, transpose, value,
8738 &valueParam);
8739 paramBuffer.addParam(std::move(valueParam));
8740 }
8741 else
8742 {
8743 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8744 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8745 &valueParam.value);
8746 paramBuffer.addParam(std::move(valueParam));
8747 }
8748
8749 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT, std::move(paramBuffer));
8750 }
8751
CaptureProgramUniformMatrix3x4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8752 CallCapture CaptureProgramUniformMatrix3x4fvEXT(const State &glState,
8753 bool isCallValid,
8754 ShaderProgramID programPacked,
8755 UniformLocation locationPacked,
8756 GLsizei count,
8757 GLboolean transpose,
8758 const GLfloat *value)
8759 {
8760 ParamBuffer paramBuffer;
8761
8762 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8763 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8764 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8765 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8766
8767 if (isCallValid)
8768 {
8769 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8770 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8771 CaptureProgramUniformMatrix3x4fvEXT_value(glState, isCallValid, programPacked,
8772 locationPacked, count, transpose, value,
8773 &valueParam);
8774 paramBuffer.addParam(std::move(valueParam));
8775 }
8776 else
8777 {
8778 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8779 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8780 &valueParam.value);
8781 paramBuffer.addParam(std::move(valueParam));
8782 }
8783
8784 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT, std::move(paramBuffer));
8785 }
8786
CaptureProgramUniformMatrix4fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8787 CallCapture CaptureProgramUniformMatrix4fvEXT(const State &glState,
8788 bool isCallValid,
8789 ShaderProgramID programPacked,
8790 UniformLocation locationPacked,
8791 GLsizei count,
8792 GLboolean transpose,
8793 const GLfloat *value)
8794 {
8795 ParamBuffer paramBuffer;
8796
8797 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8798 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8799 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8800 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8801
8802 if (isCallValid)
8803 {
8804 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8805 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8806 CaptureProgramUniformMatrix4fvEXT_value(glState, isCallValid, programPacked, locationPacked,
8807 count, transpose, value, &valueParam);
8808 paramBuffer.addParam(std::move(valueParam));
8809 }
8810 else
8811 {
8812 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8813 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8814 &valueParam.value);
8815 paramBuffer.addParam(std::move(valueParam));
8816 }
8817
8818 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4fvEXT, std::move(paramBuffer));
8819 }
8820
CaptureProgramUniformMatrix4x2fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8821 CallCapture CaptureProgramUniformMatrix4x2fvEXT(const State &glState,
8822 bool isCallValid,
8823 ShaderProgramID programPacked,
8824 UniformLocation locationPacked,
8825 GLsizei count,
8826 GLboolean transpose,
8827 const GLfloat *value)
8828 {
8829 ParamBuffer paramBuffer;
8830
8831 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8832 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8833 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8834 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8835
8836 if (isCallValid)
8837 {
8838 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8839 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8840 CaptureProgramUniformMatrix4x2fvEXT_value(glState, isCallValid, programPacked,
8841 locationPacked, count, transpose, value,
8842 &valueParam);
8843 paramBuffer.addParam(std::move(valueParam));
8844 }
8845 else
8846 {
8847 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8848 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8849 &valueParam.value);
8850 paramBuffer.addParam(std::move(valueParam));
8851 }
8852
8853 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT, std::move(paramBuffer));
8854 }
8855
CaptureProgramUniformMatrix4x3fvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei count,GLboolean transpose,const GLfloat * value)8856 CallCapture CaptureProgramUniformMatrix4x3fvEXT(const State &glState,
8857 bool isCallValid,
8858 ShaderProgramID programPacked,
8859 UniformLocation locationPacked,
8860 GLsizei count,
8861 GLboolean transpose,
8862 const GLfloat *value)
8863 {
8864 ParamBuffer paramBuffer;
8865
8866 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8867 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
8868 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
8869 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
8870
8871 if (isCallValid)
8872 {
8873 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8874 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
8875 CaptureProgramUniformMatrix4x3fvEXT_value(glState, isCallValid, programPacked,
8876 locationPacked, count, transpose, value,
8877 &valueParam);
8878 paramBuffer.addParam(std::move(valueParam));
8879 }
8880 else
8881 {
8882 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
8883 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8884 &valueParam.value);
8885 paramBuffer.addParam(std::move(valueParam));
8886 }
8887
8888 return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT, std::move(paramBuffer));
8889 }
8890
CaptureUseProgramStagesEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked,GLbitfield stages,ShaderProgramID programPacked)8891 CallCapture CaptureUseProgramStagesEXT(const State &glState,
8892 bool isCallValid,
8893 ProgramPipelineID pipelinePacked,
8894 GLbitfield stages,
8895 ShaderProgramID programPacked)
8896 {
8897 ParamBuffer paramBuffer;
8898
8899 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
8900 paramBuffer.addEnumParam("stages", GLESEnum::UseProgramStageMask, ParamType::TGLbitfield,
8901 stages);
8902 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
8903
8904 return CallCapture(angle::EntryPoint::GLUseProgramStagesEXT, std::move(paramBuffer));
8905 }
8906
CaptureValidateProgramPipelineEXT(const State & glState,bool isCallValid,ProgramPipelineID pipelinePacked)8907 CallCapture CaptureValidateProgramPipelineEXT(const State &glState,
8908 bool isCallValid,
8909 ProgramPipelineID pipelinePacked)
8910 {
8911 ParamBuffer paramBuffer;
8912
8913 paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
8914
8915 return CallCapture(angle::EntryPoint::GLValidateProgramPipelineEXT, std::move(paramBuffer));
8916 }
8917
CaptureFramebufferFetchBarrierEXT(const State & glState,bool isCallValid)8918 CallCapture CaptureFramebufferFetchBarrierEXT(const State &glState, bool isCallValid)
8919 {
8920 ParamBuffer paramBuffer;
8921
8922 return CallCapture(angle::EntryPoint::GLFramebufferFetchBarrierEXT, std::move(paramBuffer));
8923 }
8924
CapturePatchParameteriEXT(const State & glState,bool isCallValid,GLenum pname,GLint value)8925 CallCapture CapturePatchParameteriEXT(const State &glState,
8926 bool isCallValid,
8927 GLenum pname,
8928 GLint value)
8929 {
8930 ParamBuffer paramBuffer;
8931
8932 paramBuffer.addEnumParam("pname", GLESEnum::PatchParameterName, ParamType::TGLenum, pname);
8933 paramBuffer.addValueParam("value", ParamType::TGLint, value);
8934
8935 return CallCapture(angle::EntryPoint::GLPatchParameteriEXT, std::move(paramBuffer));
8936 }
8937
CaptureGetSamplerParameterIivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)8938 CallCapture CaptureGetSamplerParameterIivEXT(const State &glState,
8939 bool isCallValid,
8940 SamplerID samplerPacked,
8941 GLenum pname,
8942 GLint *params)
8943 {
8944 ParamBuffer paramBuffer;
8945
8946 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8947 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
8948
8949 if (isCallValid)
8950 {
8951 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8952 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
8953 CaptureGetSamplerParameterIivEXT_params(glState, isCallValid, samplerPacked, pname, params,
8954 ¶msParam);
8955 paramBuffer.addParam(std::move(paramsParam));
8956 }
8957 else
8958 {
8959 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8960 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
8961 paramBuffer.addParam(std::move(paramsParam));
8962 }
8963
8964 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivEXT, std::move(paramBuffer));
8965 }
8966
CaptureGetSamplerParameterIuivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)8967 CallCapture CaptureGetSamplerParameterIuivEXT(const State &glState,
8968 bool isCallValid,
8969 SamplerID samplerPacked,
8970 GLenum pname,
8971 GLuint *params)
8972 {
8973 ParamBuffer paramBuffer;
8974
8975 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8976 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
8977
8978 if (isCallValid)
8979 {
8980 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8981 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
8982 CaptureGetSamplerParameterIuivEXT_params(glState, isCallValid, samplerPacked, pname, params,
8983 ¶msParam);
8984 paramBuffer.addParam(std::move(paramsParam));
8985 }
8986 else
8987 {
8988 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8989 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
8990 ¶msParam.value);
8991 paramBuffer.addParam(std::move(paramsParam));
8992 }
8993
8994 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivEXT, std::move(paramBuffer));
8995 }
8996
CaptureGetTexParameterIivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)8997 CallCapture CaptureGetTexParameterIivEXT(const State &glState,
8998 bool isCallValid,
8999 TextureType targetPacked,
9000 GLenum pname,
9001 GLint *params)
9002 {
9003 ParamBuffer paramBuffer;
9004
9005 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9006 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
9007
9008 if (isCallValid)
9009 {
9010 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9011 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9012 CaptureGetTexParameterIivEXT_params(glState, isCallValid, targetPacked, pname, params,
9013 ¶msParam);
9014 paramBuffer.addParam(std::move(paramsParam));
9015 }
9016 else
9017 {
9018 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9019 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9020 paramBuffer.addParam(std::move(paramsParam));
9021 }
9022
9023 return CallCapture(angle::EntryPoint::GLGetTexParameterIivEXT, std::move(paramBuffer));
9024 }
9025
CaptureGetTexParameterIuivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)9026 CallCapture CaptureGetTexParameterIuivEXT(const State &glState,
9027 bool isCallValid,
9028 TextureType targetPacked,
9029 GLenum pname,
9030 GLuint *params)
9031 {
9032 ParamBuffer paramBuffer;
9033
9034 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9035 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
9036
9037 if (isCallValid)
9038 {
9039 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
9040 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
9041 CaptureGetTexParameterIuivEXT_params(glState, isCallValid, targetPacked, pname, params,
9042 ¶msParam);
9043 paramBuffer.addParam(std::move(paramsParam));
9044 }
9045 else
9046 {
9047 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
9048 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
9049 ¶msParam.value);
9050 paramBuffer.addParam(std::move(paramsParam));
9051 }
9052
9053 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivEXT, std::move(paramBuffer));
9054 }
9055
CaptureSamplerParameterIivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)9056 CallCapture CaptureSamplerParameterIivEXT(const State &glState,
9057 bool isCallValid,
9058 SamplerID samplerPacked,
9059 GLenum pname,
9060 const GLint *param)
9061 {
9062 ParamBuffer paramBuffer;
9063
9064 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
9065 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
9066
9067 if (isCallValid)
9068 {
9069 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
9070 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
9071 CaptureSamplerParameterIivEXT_param(glState, isCallValid, samplerPacked, pname, param,
9072 ¶mParam);
9073 paramBuffer.addParam(std::move(paramParam));
9074 }
9075 else
9076 {
9077 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
9078 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
9079 ¶mParam.value);
9080 paramBuffer.addParam(std::move(paramParam));
9081 }
9082
9083 return CallCapture(angle::EntryPoint::GLSamplerParameterIivEXT, std::move(paramBuffer));
9084 }
9085
CaptureSamplerParameterIuivEXT(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)9086 CallCapture CaptureSamplerParameterIuivEXT(const State &glState,
9087 bool isCallValid,
9088 SamplerID samplerPacked,
9089 GLenum pname,
9090 const GLuint *param)
9091 {
9092 ParamBuffer paramBuffer;
9093
9094 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
9095 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
9096
9097 if (isCallValid)
9098 {
9099 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
9100 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
9101 CaptureSamplerParameterIuivEXT_param(glState, isCallValid, samplerPacked, pname, param,
9102 ¶mParam);
9103 paramBuffer.addParam(std::move(paramParam));
9104 }
9105 else
9106 {
9107 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
9108 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
9109 ¶mParam.value);
9110 paramBuffer.addParam(std::move(paramParam));
9111 }
9112
9113 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivEXT, std::move(paramBuffer));
9114 }
9115
CaptureTexParameterIivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)9116 CallCapture CaptureTexParameterIivEXT(const State &glState,
9117 bool isCallValid,
9118 TextureType targetPacked,
9119 GLenum pname,
9120 const GLint *params)
9121 {
9122 ParamBuffer paramBuffer;
9123
9124 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9125 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
9126
9127 if (isCallValid)
9128 {
9129 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
9130 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
9131 CaptureTexParameterIivEXT_params(glState, isCallValid, targetPacked, pname, params,
9132 ¶msParam);
9133 paramBuffer.addParam(std::move(paramsParam));
9134 }
9135 else
9136 {
9137 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
9138 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
9139 ¶msParam.value);
9140 paramBuffer.addParam(std::move(paramsParam));
9141 }
9142
9143 return CallCapture(angle::EntryPoint::GLTexParameterIivEXT, std::move(paramBuffer));
9144 }
9145
CaptureTexParameterIuivEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)9146 CallCapture CaptureTexParameterIuivEXT(const State &glState,
9147 bool isCallValid,
9148 TextureType targetPacked,
9149 GLenum pname,
9150 const GLuint *params)
9151 {
9152 ParamBuffer paramBuffer;
9153
9154 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9155 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
9156
9157 if (isCallValid)
9158 {
9159 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
9160 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
9161 CaptureTexParameterIuivEXT_params(glState, isCallValid, targetPacked, pname, params,
9162 ¶msParam);
9163 paramBuffer.addParam(std::move(paramsParam));
9164 }
9165 else
9166 {
9167 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
9168 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
9169 ¶msParam.value);
9170 paramBuffer.addParam(std::move(paramsParam));
9171 }
9172
9173 return CallCapture(angle::EntryPoint::GLTexParameterIuivEXT, std::move(paramBuffer));
9174 }
9175
CaptureTexBufferEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)9176 CallCapture CaptureTexBufferEXT(const State &glState,
9177 bool isCallValid,
9178 TextureType targetPacked,
9179 GLenum internalformat,
9180 BufferID bufferPacked)
9181 {
9182 ParamBuffer paramBuffer;
9183
9184 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9185 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9186 internalformat);
9187 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
9188
9189 return CallCapture(angle::EntryPoint::GLTexBufferEXT, std::move(paramBuffer));
9190 }
9191
CaptureTexBufferRangeEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)9192 CallCapture CaptureTexBufferRangeEXT(const State &glState,
9193 bool isCallValid,
9194 TextureType targetPacked,
9195 GLenum internalformat,
9196 BufferID bufferPacked,
9197 GLintptr offset,
9198 GLsizeiptr size)
9199 {
9200 ParamBuffer paramBuffer;
9201
9202 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9203 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9204 internalformat);
9205 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
9206 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
9207 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
9208
9209 return CallCapture(angle::EntryPoint::GLTexBufferRangeEXT, std::move(paramBuffer));
9210 }
9211
CaptureTexStorage1DEXT(const State & glState,bool isCallValid,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)9212 CallCapture CaptureTexStorage1DEXT(const State &glState,
9213 bool isCallValid,
9214 GLenum target,
9215 GLsizei levels,
9216 GLenum internalformat,
9217 GLsizei width)
9218 {
9219 ParamBuffer paramBuffer;
9220
9221 paramBuffer.addEnumParam("target", GLESEnum::TextureTarget, ParamType::TGLenum, target);
9222 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9223 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9224 internalformat);
9225 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9226
9227 return CallCapture(angle::EntryPoint::GLTexStorage1DEXT, std::move(paramBuffer));
9228 }
9229
CaptureTexStorage2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)9230 CallCapture CaptureTexStorage2DEXT(const State &glState,
9231 bool isCallValid,
9232 TextureType targetPacked,
9233 GLsizei levels,
9234 GLenum internalformat,
9235 GLsizei width,
9236 GLsizei height)
9237 {
9238 ParamBuffer paramBuffer;
9239
9240 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9241 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9242 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9243 internalformat);
9244 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9245 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9246
9247 return CallCapture(angle::EntryPoint::GLTexStorage2DEXT, std::move(paramBuffer));
9248 }
9249
CaptureTexStorage3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)9250 CallCapture CaptureTexStorage3DEXT(const State &glState,
9251 bool isCallValid,
9252 TextureType targetPacked,
9253 GLsizei levels,
9254 GLenum internalformat,
9255 GLsizei width,
9256 GLsizei height,
9257 GLsizei depth)
9258 {
9259 ParamBuffer paramBuffer;
9260
9261 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
9262 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9263 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9264 internalformat);
9265 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9266 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9267 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
9268
9269 return CallCapture(angle::EntryPoint::GLTexStorage3DEXT, std::move(paramBuffer));
9270 }
9271
CaptureTexStorageAttribs2DEXT(const State & glState,bool isCallValid,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,const GLint * attrib_list)9272 CallCapture CaptureTexStorageAttribs2DEXT(const State &glState,
9273 bool isCallValid,
9274 GLenum target,
9275 GLsizei levels,
9276 GLenum internalformat,
9277 GLsizei width,
9278 GLsizei height,
9279 const GLint *attrib_list)
9280 {
9281 ParamBuffer paramBuffer;
9282
9283 paramBuffer.addEnumParam("target", GLESEnum::TextureTarget, ParamType::TGLenum, target);
9284 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9285 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9286 internalformat);
9287 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9288 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9289
9290 if (isCallValid)
9291 {
9292 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
9293 InitParamValue(ParamType::TGLintConstPointer, attrib_list, &attrib_listParam.value);
9294 CaptureTexStorageAttribs2DEXT_attrib_list(glState, isCallValid, target, levels,
9295 internalformat, width, height, attrib_list,
9296 &attrib_listParam);
9297 paramBuffer.addParam(std::move(attrib_listParam));
9298 }
9299 else
9300 {
9301 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
9302 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
9303 &attrib_listParam.value);
9304 paramBuffer.addParam(std::move(attrib_listParam));
9305 }
9306
9307 return CallCapture(angle::EntryPoint::GLTexStorageAttribs2DEXT, std::move(paramBuffer));
9308 }
9309
CaptureTexStorageAttribs3DEXT(const State & glState,bool isCallValid,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,const GLint * attrib_list)9310 CallCapture CaptureTexStorageAttribs3DEXT(const State &glState,
9311 bool isCallValid,
9312 GLenum target,
9313 GLsizei levels,
9314 GLenum internalformat,
9315 GLsizei width,
9316 GLsizei height,
9317 GLsizei depth,
9318 const GLint *attrib_list)
9319 {
9320 ParamBuffer paramBuffer;
9321
9322 paramBuffer.addEnumParam("target", GLESEnum::TextureTarget, ParamType::TGLenum, target);
9323 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
9324 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
9325 internalformat);
9326 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9327 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9328 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
9329
9330 if (isCallValid)
9331 {
9332 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
9333 InitParamValue(ParamType::TGLintConstPointer, attrib_list, &attrib_listParam.value);
9334 CaptureTexStorageAttribs3DEXT_attrib_list(glState, isCallValid, target, levels,
9335 internalformat, width, height, depth, attrib_list,
9336 &attrib_listParam);
9337 paramBuffer.addParam(std::move(attrib_listParam));
9338 }
9339 else
9340 {
9341 ParamCapture attrib_listParam("attrib_list", ParamType::TGLintConstPointer);
9342 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
9343 &attrib_listParam.value);
9344 paramBuffer.addParam(std::move(attrib_listParam));
9345 }
9346
9347 return CallCapture(angle::EntryPoint::GLTexStorageAttribs3DEXT, std::move(paramBuffer));
9348 }
9349
CaptureBlendBarrierKHR(const State & glState,bool isCallValid)9350 CallCapture CaptureBlendBarrierKHR(const State &glState, bool isCallValid)
9351 {
9352 ParamBuffer paramBuffer;
9353
9354 return CallCapture(angle::EntryPoint::GLBlendBarrierKHR, std::move(paramBuffer));
9355 }
9356
CaptureDebugMessageCallbackKHR(const State & glState,bool isCallValid,GLDEBUGPROCKHR callback,const void * userParam)9357 CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
9358 bool isCallValid,
9359 GLDEBUGPROCKHR callback,
9360 const void *userParam)
9361 {
9362 ParamBuffer paramBuffer;
9363
9364 paramBuffer.addValueParam("callback", ParamType::TGLDEBUGPROCKHR, callback);
9365
9366 if (isCallValid)
9367 {
9368 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
9369 InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
9370 CaptureDebugMessageCallbackKHR_userParam(glState, isCallValid, callback, userParam,
9371 &userParamParam);
9372 paramBuffer.addParam(std::move(userParamParam));
9373 }
9374 else
9375 {
9376 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
9377 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
9378 &userParamParam.value);
9379 paramBuffer.addParam(std::move(userParamParam));
9380 }
9381
9382 return CallCapture(angle::EntryPoint::GLDebugMessageCallbackKHR, std::move(paramBuffer));
9383 }
9384
CaptureDebugMessageControlKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)9385 CallCapture CaptureDebugMessageControlKHR(const State &glState,
9386 bool isCallValid,
9387 GLenum source,
9388 GLenum type,
9389 GLenum severity,
9390 GLsizei count,
9391 const GLuint *ids,
9392 GLboolean enabled)
9393 {
9394 ParamBuffer paramBuffer;
9395
9396 paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source);
9397 paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type);
9398 paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity);
9399 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
9400
9401 if (isCallValid)
9402 {
9403 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
9404 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
9405 CaptureDebugMessageControlKHR_ids(glState, isCallValid, source, type, severity, count, ids,
9406 enabled, &idsParam);
9407 paramBuffer.addParam(std::move(idsParam));
9408 }
9409 else
9410 {
9411 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
9412 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
9413 &idsParam.value);
9414 paramBuffer.addParam(std::move(idsParam));
9415 }
9416
9417 paramBuffer.addValueParam("enabled", ParamType::TGLboolean, enabled);
9418
9419 return CallCapture(angle::EntryPoint::GLDebugMessageControlKHR, std::move(paramBuffer));
9420 }
9421
CaptureDebugMessageInsertKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)9422 CallCapture CaptureDebugMessageInsertKHR(const State &glState,
9423 bool isCallValid,
9424 GLenum source,
9425 GLenum type,
9426 GLuint id,
9427 GLenum severity,
9428 GLsizei length,
9429 const GLchar *buf)
9430 {
9431 ParamBuffer paramBuffer;
9432
9433 paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source);
9434 paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type);
9435 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
9436 paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity);
9437 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9438
9439 if (isCallValid)
9440 {
9441 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
9442 InitParamValue(ParamType::TGLcharConstPointer, buf, &bufParam.value);
9443 CaptureDebugMessageInsertKHR_buf(glState, isCallValid, source, type, id, severity, length,
9444 buf, &bufParam);
9445 paramBuffer.addParam(std::move(bufParam));
9446 }
9447 else
9448 {
9449 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
9450 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9451 &bufParam.value);
9452 paramBuffer.addParam(std::move(bufParam));
9453 }
9454
9455 return CallCapture(angle::EntryPoint::GLDebugMessageInsertKHR, std::move(paramBuffer));
9456 }
9457
CaptureGetDebugMessageLogKHR(const State & glState,bool isCallValid,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog,GLuint returnValue)9458 CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
9459 bool isCallValid,
9460 GLuint count,
9461 GLsizei bufSize,
9462 GLenum *sources,
9463 GLenum *types,
9464 GLuint *ids,
9465 GLenum *severities,
9466 GLsizei *lengths,
9467 GLchar *messageLog,
9468 GLuint returnValue)
9469 {
9470 ParamBuffer paramBuffer;
9471
9472 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
9473 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9474
9475 if (isCallValid)
9476 {
9477 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
9478 InitParamValue(ParamType::TGLenumPointer, sources, &sourcesParam.value);
9479 CaptureGetDebugMessageLogKHR_sources(glState, isCallValid, count, bufSize, sources, types,
9480 ids, severities, lengths, messageLog, &sourcesParam);
9481 paramBuffer.addParam(std::move(sourcesParam));
9482 }
9483 else
9484 {
9485 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
9486 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
9487 &sourcesParam.value);
9488 paramBuffer.addParam(std::move(sourcesParam));
9489 }
9490
9491 if (isCallValid)
9492 {
9493 ParamCapture typesParam("types", ParamType::TGLenumPointer);
9494 InitParamValue(ParamType::TGLenumPointer, types, &typesParam.value);
9495 CaptureGetDebugMessageLogKHR_types(glState, isCallValid, count, bufSize, sources, types,
9496 ids, severities, lengths, messageLog, &typesParam);
9497 paramBuffer.addParam(std::move(typesParam));
9498 }
9499 else
9500 {
9501 ParamCapture typesParam("types", ParamType::TGLenumPointer);
9502 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
9503 &typesParam.value);
9504 paramBuffer.addParam(std::move(typesParam));
9505 }
9506
9507 if (isCallValid)
9508 {
9509 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
9510 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
9511 CaptureGetDebugMessageLogKHR_ids(glState, isCallValid, count, bufSize, sources, types, ids,
9512 severities, lengths, messageLog, &idsParam);
9513 paramBuffer.addParam(std::move(idsParam));
9514 }
9515 else
9516 {
9517 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
9518 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &idsParam.value);
9519 paramBuffer.addParam(std::move(idsParam));
9520 }
9521
9522 if (isCallValid)
9523 {
9524 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
9525 InitParamValue(ParamType::TGLenumPointer, severities, &severitiesParam.value);
9526 CaptureGetDebugMessageLogKHR_severities(glState, isCallValid, count, bufSize, sources,
9527 types, ids, severities, lengths, messageLog,
9528 &severitiesParam);
9529 paramBuffer.addParam(std::move(severitiesParam));
9530 }
9531 else
9532 {
9533 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
9534 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
9535 &severitiesParam.value);
9536 paramBuffer.addParam(std::move(severitiesParam));
9537 }
9538
9539 if (isCallValid)
9540 {
9541 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
9542 InitParamValue(ParamType::TGLsizeiPointer, lengths, &lengthsParam.value);
9543 CaptureGetDebugMessageLogKHR_lengths(glState, isCallValid, count, bufSize, sources, types,
9544 ids, severities, lengths, messageLog, &lengthsParam);
9545 paramBuffer.addParam(std::move(lengthsParam));
9546 }
9547 else
9548 {
9549 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
9550 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
9551 &lengthsParam.value);
9552 paramBuffer.addParam(std::move(lengthsParam));
9553 }
9554
9555 if (isCallValid)
9556 {
9557 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
9558 InitParamValue(ParamType::TGLcharPointer, messageLog, &messageLogParam.value);
9559 CaptureGetDebugMessageLogKHR_messageLog(glState, isCallValid, count, bufSize, sources,
9560 types, ids, severities, lengths, messageLog,
9561 &messageLogParam);
9562 paramBuffer.addParam(std::move(messageLogParam));
9563 }
9564 else
9565 {
9566 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
9567 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
9568 &messageLogParam.value);
9569 paramBuffer.addParam(std::move(messageLogParam));
9570 }
9571
9572 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
9573 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
9574 paramBuffer.addReturnValue(std::move(returnValueCapture));
9575
9576 return CallCapture(angle::EntryPoint::GLGetDebugMessageLogKHR, std::move(paramBuffer));
9577 }
9578
CaptureGetObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)9579 CallCapture CaptureGetObjectLabelKHR(const State &glState,
9580 bool isCallValid,
9581 GLenum identifier,
9582 GLuint name,
9583 GLsizei bufSize,
9584 GLsizei *length,
9585 GLchar *label)
9586 {
9587 ParamBuffer paramBuffer;
9588
9589 paramBuffer.addEnumParam("identifier", GLESEnum::AllEnums, ParamType::TGLenum, identifier);
9590 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
9591 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9592
9593 if (isCallValid)
9594 {
9595 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9596 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
9597 CaptureGetObjectLabelKHR_length(glState, isCallValid, identifier, name, bufSize, length,
9598 label, &lengthParam);
9599 paramBuffer.addParam(std::move(lengthParam));
9600 }
9601 else
9602 {
9603 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9604 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
9605 &lengthParam.value);
9606 paramBuffer.addParam(std::move(lengthParam));
9607 }
9608
9609 if (isCallValid)
9610 {
9611 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9612 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
9613 CaptureGetObjectLabelKHR_label(glState, isCallValid, identifier, name, bufSize, length,
9614 label, &labelParam);
9615 paramBuffer.addParam(std::move(labelParam));
9616 }
9617 else
9618 {
9619 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9620 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
9621 &labelParam.value);
9622 paramBuffer.addParam(std::move(labelParam));
9623 }
9624
9625 return CallCapture(angle::EntryPoint::GLGetObjectLabelKHR, std::move(paramBuffer));
9626 }
9627
CaptureGetObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)9628 CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
9629 bool isCallValid,
9630 const void *ptr,
9631 GLsizei bufSize,
9632 GLsizei *length,
9633 GLchar *label)
9634 {
9635 ParamBuffer paramBuffer;
9636
9637 if (isCallValid)
9638 {
9639 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9640 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
9641 CaptureGetObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, bufSize, length, label,
9642 &ptrParam);
9643 paramBuffer.addParam(std::move(ptrParam));
9644 }
9645 else
9646 {
9647 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9648 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
9649 &ptrParam.value);
9650 paramBuffer.addParam(std::move(ptrParam));
9651 }
9652
9653 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9654
9655 if (isCallValid)
9656 {
9657 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9658 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
9659 CaptureGetObjectPtrLabelKHR_length(glState, isCallValid, ptr, bufSize, length, label,
9660 &lengthParam);
9661 paramBuffer.addParam(std::move(lengthParam));
9662 }
9663 else
9664 {
9665 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
9666 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
9667 &lengthParam.value);
9668 paramBuffer.addParam(std::move(lengthParam));
9669 }
9670
9671 if (isCallValid)
9672 {
9673 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9674 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
9675 CaptureGetObjectPtrLabelKHR_label(glState, isCallValid, ptr, bufSize, length, label,
9676 &labelParam);
9677 paramBuffer.addParam(std::move(labelParam));
9678 }
9679 else
9680 {
9681 ParamCapture labelParam("label", ParamType::TGLcharPointer);
9682 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
9683 &labelParam.value);
9684 paramBuffer.addParam(std::move(labelParam));
9685 }
9686
9687 return CallCapture(angle::EntryPoint::GLGetObjectPtrLabelKHR, std::move(paramBuffer));
9688 }
9689
CaptureGetPointervKHR(const State & glState,bool isCallValid,GLenum pname,void ** params)9690 CallCapture CaptureGetPointervKHR(const State &glState,
9691 bool isCallValid,
9692 GLenum pname,
9693 void **params)
9694 {
9695 ParamBuffer paramBuffer;
9696
9697 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
9698
9699 if (isCallValid)
9700 {
9701 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
9702 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
9703 CaptureGetPointervKHR_params(glState, isCallValid, pname, params, ¶msParam);
9704 paramBuffer.addParam(std::move(paramsParam));
9705 }
9706 else
9707 {
9708 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
9709 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
9710 ¶msParam.value);
9711 paramBuffer.addParam(std::move(paramsParam));
9712 }
9713
9714 return CallCapture(angle::EntryPoint::GLGetPointervKHR, std::move(paramBuffer));
9715 }
9716
CaptureObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)9717 CallCapture CaptureObjectLabelKHR(const State &glState,
9718 bool isCallValid,
9719 GLenum identifier,
9720 GLuint name,
9721 GLsizei length,
9722 const GLchar *label)
9723 {
9724 ParamBuffer paramBuffer;
9725
9726 paramBuffer.addEnumParam("identifier", GLESEnum::ObjectIdentifier, ParamType::TGLenum,
9727 identifier);
9728 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
9729 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9730
9731 if (isCallValid)
9732 {
9733 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9734 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
9735 CaptureObjectLabelKHR_label(glState, isCallValid, identifier, name, length, label,
9736 &labelParam);
9737 paramBuffer.addParam(std::move(labelParam));
9738 }
9739 else
9740 {
9741 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9742 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9743 &labelParam.value);
9744 paramBuffer.addParam(std::move(labelParam));
9745 }
9746
9747 return CallCapture(angle::EntryPoint::GLObjectLabelKHR, std::move(paramBuffer));
9748 }
9749
CaptureObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei length,const GLchar * label)9750 CallCapture CaptureObjectPtrLabelKHR(const State &glState,
9751 bool isCallValid,
9752 const void *ptr,
9753 GLsizei length,
9754 const GLchar *label)
9755 {
9756 ParamBuffer paramBuffer;
9757
9758 if (isCallValid)
9759 {
9760 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9761 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
9762 CaptureObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, length, label, &ptrParam);
9763 paramBuffer.addParam(std::move(ptrParam));
9764 }
9765 else
9766 {
9767 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
9768 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
9769 &ptrParam.value);
9770 paramBuffer.addParam(std::move(ptrParam));
9771 }
9772
9773 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9774
9775 if (isCallValid)
9776 {
9777 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9778 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
9779 CaptureObjectPtrLabelKHR_label(glState, isCallValid, ptr, length, label, &labelParam);
9780 paramBuffer.addParam(std::move(labelParam));
9781 }
9782 else
9783 {
9784 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
9785 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9786 &labelParam.value);
9787 paramBuffer.addParam(std::move(labelParam));
9788 }
9789
9790 return CallCapture(angle::EntryPoint::GLObjectPtrLabelKHR, std::move(paramBuffer));
9791 }
9792
CapturePopDebugGroupKHR(const State & glState,bool isCallValid)9793 CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid)
9794 {
9795 ParamBuffer paramBuffer;
9796
9797 return CallCapture(angle::EntryPoint::GLPopDebugGroupKHR, std::move(paramBuffer));
9798 }
9799
CapturePushDebugGroupKHR(const State & glState,bool isCallValid,GLenum source,GLuint id,GLsizei length,const GLchar * message)9800 CallCapture CapturePushDebugGroupKHR(const State &glState,
9801 bool isCallValid,
9802 GLenum source,
9803 GLuint id,
9804 GLsizei length,
9805 const GLchar *message)
9806 {
9807 ParamBuffer paramBuffer;
9808
9809 paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source);
9810 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
9811 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
9812
9813 if (isCallValid)
9814 {
9815 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
9816 InitParamValue(ParamType::TGLcharConstPointer, message, &messageParam.value);
9817 CapturePushDebugGroupKHR_message(glState, isCallValid, source, id, length, message,
9818 &messageParam);
9819 paramBuffer.addParam(std::move(messageParam));
9820 }
9821 else
9822 {
9823 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
9824 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
9825 &messageParam.value);
9826 paramBuffer.addParam(std::move(messageParam));
9827 }
9828
9829 return CallCapture(angle::EntryPoint::GLPushDebugGroupKHR, std::move(paramBuffer));
9830 }
9831
CaptureMaxShaderCompilerThreadsKHR(const State & glState,bool isCallValid,GLuint count)9832 CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState, bool isCallValid, GLuint count)
9833 {
9834 ParamBuffer paramBuffer;
9835
9836 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
9837
9838 return CallCapture(angle::EntryPoint::GLMaxShaderCompilerThreadsKHR, std::move(paramBuffer));
9839 }
9840
CaptureGetGraphicsResetStatusKHR(const State & glState,bool isCallValid,GLenum returnValue)9841 CallCapture CaptureGetGraphicsResetStatusKHR(const State &glState,
9842 bool isCallValid,
9843 GLenum returnValue)
9844 {
9845 ParamBuffer paramBuffer;
9846
9847 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
9848 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
9849 paramBuffer.addReturnValue(std::move(returnValueCapture));
9850
9851 return CallCapture(angle::EntryPoint::GLGetGraphicsResetStatusKHR, std::move(paramBuffer));
9852 }
9853
CaptureGetnUniformfvKHR(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)9854 CallCapture CaptureGetnUniformfvKHR(const State &glState,
9855 bool isCallValid,
9856 ShaderProgramID programPacked,
9857 UniformLocation locationPacked,
9858 GLsizei bufSize,
9859 GLfloat *params)
9860 {
9861 ParamBuffer paramBuffer;
9862
9863 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
9864 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
9865 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9866
9867 if (isCallValid)
9868 {
9869 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
9870 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
9871 CaptureGetnUniformfvKHR_params(glState, isCallValid, programPacked, locationPacked, bufSize,
9872 params, ¶msParam);
9873 paramBuffer.addParam(std::move(paramsParam));
9874 }
9875 else
9876 {
9877 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
9878 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
9879 ¶msParam.value);
9880 paramBuffer.addParam(std::move(paramsParam));
9881 }
9882
9883 return CallCapture(angle::EntryPoint::GLGetnUniformfvKHR, std::move(paramBuffer));
9884 }
9885
CaptureGetnUniformivKHR(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)9886 CallCapture CaptureGetnUniformivKHR(const State &glState,
9887 bool isCallValid,
9888 ShaderProgramID programPacked,
9889 UniformLocation locationPacked,
9890 GLsizei bufSize,
9891 GLint *params)
9892 {
9893 ParamBuffer paramBuffer;
9894
9895 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
9896 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
9897 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9898
9899 if (isCallValid)
9900 {
9901 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9902 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
9903 CaptureGetnUniformivKHR_params(glState, isCallValid, programPacked, locationPacked, bufSize,
9904 params, ¶msParam);
9905 paramBuffer.addParam(std::move(paramsParam));
9906 }
9907 else
9908 {
9909 ParamCapture paramsParam("params", ParamType::TGLintPointer);
9910 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
9911 paramBuffer.addParam(std::move(paramsParam));
9912 }
9913
9914 return CallCapture(angle::EntryPoint::GLGetnUniformivKHR, std::move(paramBuffer));
9915 }
9916
CaptureGetnUniformuivKHR(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLuint * params)9917 CallCapture CaptureGetnUniformuivKHR(const State &glState,
9918 bool isCallValid,
9919 ShaderProgramID programPacked,
9920 UniformLocation locationPacked,
9921 GLsizei bufSize,
9922 GLuint *params)
9923 {
9924 ParamBuffer paramBuffer;
9925
9926 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
9927 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
9928 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9929
9930 if (isCallValid)
9931 {
9932 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
9933 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
9934 CaptureGetnUniformuivKHR_params(glState, isCallValid, programPacked, locationPacked,
9935 bufSize, params, ¶msParam);
9936 paramBuffer.addParam(std::move(paramsParam));
9937 }
9938 else
9939 {
9940 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
9941 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
9942 ¶msParam.value);
9943 paramBuffer.addParam(std::move(paramsParam));
9944 }
9945
9946 return CallCapture(angle::EntryPoint::GLGetnUniformuivKHR, std::move(paramBuffer));
9947 }
9948
CaptureReadnPixelsKHR(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)9949 CallCapture CaptureReadnPixelsKHR(const State &glState,
9950 bool isCallValid,
9951 GLint x,
9952 GLint y,
9953 GLsizei width,
9954 GLsizei height,
9955 GLenum format,
9956 GLenum type,
9957 GLsizei bufSize,
9958 void *data)
9959 {
9960 ParamBuffer paramBuffer;
9961
9962 paramBuffer.addValueParam("x", ParamType::TGLint, x);
9963 paramBuffer.addValueParam("y", ParamType::TGLint, y);
9964 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
9965 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
9966 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
9967 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
9968 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
9969
9970 if (isCallValid)
9971 {
9972 ParamCapture dataParam("data", ParamType::TvoidPointer);
9973 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
9974 CaptureReadnPixelsKHR_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
9975 data, &dataParam);
9976 paramBuffer.addParam(std::move(dataParam));
9977 }
9978 else
9979 {
9980 ParamCapture dataParam("data", ParamType::TvoidPointer);
9981 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
9982 paramBuffer.addParam(std::move(dataParam));
9983 }
9984
9985 return CallCapture(angle::EntryPoint::GLReadnPixelsKHR, std::move(paramBuffer));
9986 }
9987
CaptureFramebufferParameteriMESA(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint param)9988 CallCapture CaptureFramebufferParameteriMESA(const State &glState,
9989 bool isCallValid,
9990 GLenum target,
9991 GLenum pname,
9992 GLint param)
9993 {
9994 ParamBuffer paramBuffer;
9995
9996 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
9997 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferParameterName, ParamType::TGLenum,
9998 pname);
9999 paramBuffer.addValueParam("param", ParamType::TGLint, param);
10000
10001 return CallCapture(angle::EntryPoint::GLFramebufferParameteriMESA, std::move(paramBuffer));
10002 }
10003
CaptureGetFramebufferParameterivMESA(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)10004 CallCapture CaptureGetFramebufferParameterivMESA(const State &glState,
10005 bool isCallValid,
10006 GLenum target,
10007 GLenum pname,
10008 GLint *params)
10009 {
10010 ParamBuffer paramBuffer;
10011
10012 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10013 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName,
10014 ParamType::TGLenum, pname);
10015
10016 if (isCallValid)
10017 {
10018 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10019 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10020 CaptureGetFramebufferParameterivMESA_params(glState, isCallValid, target, pname, params,
10021 ¶msParam);
10022 paramBuffer.addParam(std::move(paramsParam));
10023 }
10024 else
10025 {
10026 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10027 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10028 paramBuffer.addParam(std::move(paramsParam));
10029 }
10030
10031 return CallCapture(angle::EntryPoint::GLGetFramebufferParameterivMESA, std::move(paramBuffer));
10032 }
10033
CaptureDeleteFencesNV(const State & glState,bool isCallValid,GLsizei n,const FenceNVID * fencesPacked)10034 CallCapture CaptureDeleteFencesNV(const State &glState,
10035 bool isCallValid,
10036 GLsizei n,
10037 const FenceNVID *fencesPacked)
10038 {
10039 ParamBuffer paramBuffer;
10040
10041 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10042
10043 if (isCallValid)
10044 {
10045 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
10046 InitParamValue(ParamType::TFenceNVIDConstPointer, fencesPacked, &fencesPackedParam.value);
10047 CaptureDeleteFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked,
10048 &fencesPackedParam);
10049 paramBuffer.addParam(std::move(fencesPackedParam));
10050 }
10051 else
10052 {
10053 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
10054 InitParamValue(ParamType::TFenceNVIDConstPointer, static_cast<const FenceNVID *>(nullptr),
10055 &fencesPackedParam.value);
10056 paramBuffer.addParam(std::move(fencesPackedParam));
10057 }
10058
10059 return CallCapture(angle::EntryPoint::GLDeleteFencesNV, std::move(paramBuffer));
10060 }
10061
CaptureFinishFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked)10062 CallCapture CaptureFinishFenceNV(const State &glState, bool isCallValid, FenceNVID fencePacked)
10063 {
10064 ParamBuffer paramBuffer;
10065
10066 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
10067
10068 return CallCapture(angle::EntryPoint::GLFinishFenceNV, std::move(paramBuffer));
10069 }
10070
CaptureGenFencesNV(const State & glState,bool isCallValid,GLsizei n,FenceNVID * fencesPacked)10071 CallCapture CaptureGenFencesNV(const State &glState,
10072 bool isCallValid,
10073 GLsizei n,
10074 FenceNVID *fencesPacked)
10075 {
10076 ParamBuffer paramBuffer;
10077
10078 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10079
10080 if (isCallValid)
10081 {
10082 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
10083 InitParamValue(ParamType::TFenceNVIDPointer, fencesPacked, &fencesPackedParam.value);
10084 CaptureGenFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked, &fencesPackedParam);
10085 paramBuffer.addParam(std::move(fencesPackedParam));
10086 }
10087 else
10088 {
10089 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
10090 InitParamValue(ParamType::TFenceNVIDPointer, static_cast<FenceNVID *>(nullptr),
10091 &fencesPackedParam.value);
10092 paramBuffer.addParam(std::move(fencesPackedParam));
10093 }
10094
10095 return CallCapture(angle::EntryPoint::GLGenFencesNV, std::move(paramBuffer));
10096 }
10097
CaptureGetFenceivNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum pname,GLint * params)10098 CallCapture CaptureGetFenceivNV(const State &glState,
10099 bool isCallValid,
10100 FenceNVID fencePacked,
10101 GLenum pname,
10102 GLint *params)
10103 {
10104 ParamBuffer paramBuffer;
10105
10106 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
10107 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
10108
10109 if (isCallValid)
10110 {
10111 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10112 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10113 CaptureGetFenceivNV_params(glState, isCallValid, fencePacked, pname, params, ¶msParam);
10114 paramBuffer.addParam(std::move(paramsParam));
10115 }
10116 else
10117 {
10118 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10119 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10120 paramBuffer.addParam(std::move(paramsParam));
10121 }
10122
10123 return CallCapture(angle::EntryPoint::GLGetFenceivNV, std::move(paramBuffer));
10124 }
10125
CaptureIsFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)10126 CallCapture CaptureIsFenceNV(const State &glState,
10127 bool isCallValid,
10128 FenceNVID fencePacked,
10129 GLboolean returnValue)
10130 {
10131 ParamBuffer paramBuffer;
10132
10133 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
10134
10135 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10136 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10137 paramBuffer.addReturnValue(std::move(returnValueCapture));
10138
10139 return CallCapture(angle::EntryPoint::GLIsFenceNV, std::move(paramBuffer));
10140 }
10141
CaptureSetFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum condition)10142 CallCapture CaptureSetFenceNV(const State &glState,
10143 bool isCallValid,
10144 FenceNVID fencePacked,
10145 GLenum condition)
10146 {
10147 ParamBuffer paramBuffer;
10148
10149 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
10150 paramBuffer.addEnumParam("condition", GLESEnum::AllEnums, ParamType::TGLenum, condition);
10151
10152 return CallCapture(angle::EntryPoint::GLSetFenceNV, std::move(paramBuffer));
10153 }
10154
CaptureTestFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)10155 CallCapture CaptureTestFenceNV(const State &glState,
10156 bool isCallValid,
10157 FenceNVID fencePacked,
10158 GLboolean returnValue)
10159 {
10160 ParamBuffer paramBuffer;
10161
10162 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
10163
10164 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10165 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10166 paramBuffer.addReturnValue(std::move(returnValueCapture));
10167
10168 return CallCapture(angle::EntryPoint::GLTestFenceNV, std::move(paramBuffer));
10169 }
10170
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)10171 CallCapture CaptureBlitFramebufferNV(const State &glState,
10172 bool isCallValid,
10173 GLint srcX0,
10174 GLint srcY0,
10175 GLint srcX1,
10176 GLint srcY1,
10177 GLint dstX0,
10178 GLint dstY0,
10179 GLint dstX1,
10180 GLint dstY1,
10181 GLbitfield mask,
10182 GLenum filter)
10183 {
10184 ParamBuffer paramBuffer;
10185
10186 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
10187 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
10188 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
10189 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
10190 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
10191 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
10192 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
10193 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
10194 paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask);
10195 paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter);
10196
10197 return CallCapture(angle::EntryPoint::GLBlitFramebufferNV, std::move(paramBuffer));
10198 }
10199
CapturePolygonModeNV(const State & glState,bool isCallValid,GLenum face,PolygonMode modePacked)10200 CallCapture CapturePolygonModeNV(const State &glState,
10201 bool isCallValid,
10202 GLenum face,
10203 PolygonMode modePacked)
10204 {
10205 ParamBuffer paramBuffer;
10206
10207 paramBuffer.addEnumParam("face", GLESEnum::TriangleFace, ParamType::TGLenum, face);
10208 paramBuffer.addValueParam("modePacked", ParamType::TPolygonMode, modePacked);
10209
10210 return CallCapture(angle::EntryPoint::GLPolygonModeNV, std::move(paramBuffer));
10211 }
10212
CaptureEGLImageTargetRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,egl::ImageID imagePacked)10213 CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
10214 bool isCallValid,
10215 GLenum target,
10216 egl::ImageID imagePacked)
10217 {
10218 ParamBuffer paramBuffer;
10219
10220 paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target);
10221 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
10222
10223 return CallCapture(angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES,
10224 std::move(paramBuffer));
10225 }
10226
CaptureEGLImageTargetTexture2DOES(const State & glState,bool isCallValid,TextureType targetPacked,egl::ImageID imagePacked)10227 CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
10228 bool isCallValid,
10229 TextureType targetPacked,
10230 egl::ImageID imagePacked)
10231 {
10232 ParamBuffer paramBuffer;
10233
10234 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
10235 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
10236
10237 return CallCapture(angle::EntryPoint::GLEGLImageTargetTexture2DOES, std::move(paramBuffer));
10238 }
10239
CaptureBlendEquationOES(const State & glState,bool isCallValid,GLenum mode)10240 CallCapture CaptureBlendEquationOES(const State &glState, bool isCallValid, GLenum mode)
10241 {
10242 ParamBuffer paramBuffer;
10243
10244 paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode);
10245
10246 return CallCapture(angle::EntryPoint::GLBlendEquationOES, std::move(paramBuffer));
10247 }
10248
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)10249 CallCapture CaptureCopyImageSubDataOES(const State &glState,
10250 bool isCallValid,
10251 GLuint srcName,
10252 GLenum srcTarget,
10253 GLint srcLevel,
10254 GLint srcX,
10255 GLint srcY,
10256 GLint srcZ,
10257 GLuint dstName,
10258 GLenum dstTarget,
10259 GLint dstLevel,
10260 GLint dstX,
10261 GLint dstY,
10262 GLint dstZ,
10263 GLsizei srcWidth,
10264 GLsizei srcHeight,
10265 GLsizei srcDepth)
10266 {
10267 ParamBuffer paramBuffer;
10268
10269 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
10270 paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
10271 srcTarget);
10272 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
10273 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
10274 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
10275 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
10276 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
10277 paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum,
10278 dstTarget);
10279 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
10280 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
10281 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
10282 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
10283 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
10284 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
10285 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
10286
10287 return CallCapture(angle::EntryPoint::GLCopyImageSubDataOES, std::move(paramBuffer));
10288 }
10289
CaptureBlendEquationSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)10290 CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
10291 bool isCallValid,
10292 GLuint buf,
10293 GLenum modeRGB,
10294 GLenum modeAlpha)
10295 {
10296 ParamBuffer paramBuffer;
10297
10298 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10299 paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
10300 modeRGB);
10301 paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum,
10302 modeAlpha);
10303
10304 return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiOES, std::move(paramBuffer));
10305 }
10306
CaptureBlendEquationiOES(const State & glState,bool isCallValid,GLuint buf,GLenum mode)10307 CallCapture CaptureBlendEquationiOES(const State &glState,
10308 bool isCallValid,
10309 GLuint buf,
10310 GLenum mode)
10311 {
10312 ParamBuffer paramBuffer;
10313
10314 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10315 paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode);
10316
10317 return CallCapture(angle::EntryPoint::GLBlendEquationiOES, std::move(paramBuffer));
10318 }
10319
CaptureBlendFuncSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)10320 CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
10321 bool isCallValid,
10322 GLuint buf,
10323 GLenum srcRGB,
10324 GLenum dstRGB,
10325 GLenum srcAlpha,
10326 GLenum dstAlpha)
10327 {
10328 ParamBuffer paramBuffer;
10329
10330 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10331 paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB);
10332 paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB);
10333 paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha);
10334 paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha);
10335
10336 return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiOES, std::move(paramBuffer));
10337 }
10338
CaptureBlendFunciOES(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)10339 CallCapture CaptureBlendFunciOES(const State &glState,
10340 bool isCallValid,
10341 GLuint buf,
10342 GLenum src,
10343 GLenum dst)
10344 {
10345 ParamBuffer paramBuffer;
10346
10347 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
10348 paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src);
10349 paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst);
10350
10351 return CallCapture(angle::EntryPoint::GLBlendFunciOES, std::move(paramBuffer));
10352 }
10353
CaptureColorMaskiOES(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)10354 CallCapture CaptureColorMaskiOES(const State &glState,
10355 bool isCallValid,
10356 GLuint index,
10357 GLboolean r,
10358 GLboolean g,
10359 GLboolean b,
10360 GLboolean a)
10361 {
10362 ParamBuffer paramBuffer;
10363
10364 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10365 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
10366 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
10367 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
10368 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
10369
10370 return CallCapture(angle::EntryPoint::GLColorMaskiOES, std::move(paramBuffer));
10371 }
10372
CaptureDisableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)10373 CallCapture CaptureDisableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
10374 {
10375 ParamBuffer paramBuffer;
10376
10377 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10378 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10379
10380 return CallCapture(angle::EntryPoint::GLDisableiOES, std::move(paramBuffer));
10381 }
10382
CaptureEnableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)10383 CallCapture CaptureEnableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
10384 {
10385 ParamBuffer paramBuffer;
10386
10387 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10388 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10389
10390 return CallCapture(angle::EntryPoint::GLEnableiOES, std::move(paramBuffer));
10391 }
10392
CaptureIsEnablediOES(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)10393 CallCapture CaptureIsEnablediOES(const State &glState,
10394 bool isCallValid,
10395 GLenum target,
10396 GLuint index,
10397 GLboolean returnValue)
10398 {
10399 ParamBuffer paramBuffer;
10400
10401 paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target);
10402 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
10403
10404 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10405 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10406 paramBuffer.addReturnValue(std::move(returnValueCapture));
10407
10408 return CallCapture(angle::EntryPoint::GLIsEnablediOES, std::move(paramBuffer));
10409 }
10410
CaptureDrawElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)10411 CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
10412 bool isCallValid,
10413 PrimitiveMode modePacked,
10414 GLsizei count,
10415 DrawElementsType typePacked,
10416 const void *indices,
10417 GLint basevertex)
10418 {
10419 ParamBuffer paramBuffer;
10420
10421 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10422 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10423 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10424
10425 if (isCallValid)
10426 {
10427 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10428 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10429 CaptureDrawElementsBaseVertexOES_indices(glState, isCallValid, modePacked, count,
10430 typePacked, indices, basevertex, &indicesParam);
10431 paramBuffer.addParam(std::move(indicesParam));
10432 }
10433 else
10434 {
10435 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10436 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10437 &indicesParam.value);
10438 paramBuffer.addParam(std::move(indicesParam));
10439 }
10440
10441 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10442
10443 return CallCapture(angle::EntryPoint::GLDrawElementsBaseVertexOES, std::move(paramBuffer));
10444 }
10445
CaptureDrawElementsInstancedBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)10446 CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
10447 bool isCallValid,
10448 PrimitiveMode modePacked,
10449 GLsizei count,
10450 DrawElementsType typePacked,
10451 const void *indices,
10452 GLsizei instancecount,
10453 GLint basevertex)
10454 {
10455 ParamBuffer paramBuffer;
10456
10457 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10458 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10459 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10460
10461 if (isCallValid)
10462 {
10463 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10464 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10465 CaptureDrawElementsInstancedBaseVertexOES_indices(glState, isCallValid, modePacked, count,
10466 typePacked, indices, instancecount,
10467 basevertex, &indicesParam);
10468 paramBuffer.addParam(std::move(indicesParam));
10469 }
10470 else
10471 {
10472 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10473 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10474 &indicesParam.value);
10475 paramBuffer.addParam(std::move(indicesParam));
10476 }
10477
10478 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
10479 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10480
10481 return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexOES,
10482 std::move(paramBuffer));
10483 }
10484
CaptureDrawRangeElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)10485 CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
10486 bool isCallValid,
10487 PrimitiveMode modePacked,
10488 GLuint start,
10489 GLuint end,
10490 GLsizei count,
10491 DrawElementsType typePacked,
10492 const void *indices,
10493 GLint basevertex)
10494 {
10495 ParamBuffer paramBuffer;
10496
10497 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
10498 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
10499 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
10500 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
10501 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
10502
10503 if (isCallValid)
10504 {
10505 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10506 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
10507 CaptureDrawRangeElementsBaseVertexOES_indices(glState, isCallValid, modePacked, start, end,
10508 count, typePacked, indices, basevertex,
10509 &indicesParam);
10510 paramBuffer.addParam(std::move(indicesParam));
10511 }
10512 else
10513 {
10514 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
10515 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
10516 &indicesParam.value);
10517 paramBuffer.addParam(std::move(indicesParam));
10518 }
10519
10520 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
10521
10522 return CallCapture(angle::EntryPoint::GLDrawRangeElementsBaseVertexOES, std::move(paramBuffer));
10523 }
10524
CaptureDrawTexfOES(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)10525 CallCapture CaptureDrawTexfOES(const State &glState,
10526 bool isCallValid,
10527 GLfloat x,
10528 GLfloat y,
10529 GLfloat z,
10530 GLfloat width,
10531 GLfloat height)
10532 {
10533 ParamBuffer paramBuffer;
10534
10535 paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
10536 paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
10537 paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
10538 paramBuffer.addValueParam("width", ParamType::TGLfloat, width);
10539 paramBuffer.addValueParam("height", ParamType::TGLfloat, height);
10540
10541 return CallCapture(angle::EntryPoint::GLDrawTexfOES, std::move(paramBuffer));
10542 }
10543
CaptureDrawTexfvOES(const State & glState,bool isCallValid,const GLfloat * coords)10544 CallCapture CaptureDrawTexfvOES(const State &glState, bool isCallValid, const GLfloat *coords)
10545 {
10546 ParamBuffer paramBuffer;
10547
10548 if (isCallValid)
10549 {
10550 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
10551 InitParamValue(ParamType::TGLfloatConstPointer, coords, &coordsParam.value);
10552 CaptureDrawTexfvOES_coords(glState, isCallValid, coords, &coordsParam);
10553 paramBuffer.addParam(std::move(coordsParam));
10554 }
10555 else
10556 {
10557 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
10558 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
10559 &coordsParam.value);
10560 paramBuffer.addParam(std::move(coordsParam));
10561 }
10562
10563 return CallCapture(angle::EntryPoint::GLDrawTexfvOES, std::move(paramBuffer));
10564 }
10565
CaptureDrawTexiOES(const State & glState,bool isCallValid,GLint x,GLint y,GLint z,GLint width,GLint height)10566 CallCapture CaptureDrawTexiOES(const State &glState,
10567 bool isCallValid,
10568 GLint x,
10569 GLint y,
10570 GLint z,
10571 GLint width,
10572 GLint height)
10573 {
10574 ParamBuffer paramBuffer;
10575
10576 paramBuffer.addValueParam("x", ParamType::TGLint, x);
10577 paramBuffer.addValueParam("y", ParamType::TGLint, y);
10578 paramBuffer.addValueParam("z", ParamType::TGLint, z);
10579 paramBuffer.addValueParam("width", ParamType::TGLint, width);
10580 paramBuffer.addValueParam("height", ParamType::TGLint, height);
10581
10582 return CallCapture(angle::EntryPoint::GLDrawTexiOES, std::move(paramBuffer));
10583 }
10584
CaptureDrawTexivOES(const State & glState,bool isCallValid,const GLint * coords)10585 CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords)
10586 {
10587 ParamBuffer paramBuffer;
10588
10589 if (isCallValid)
10590 {
10591 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
10592 InitParamValue(ParamType::TGLintConstPointer, coords, &coordsParam.value);
10593 CaptureDrawTexivOES_coords(glState, isCallValid, coords, &coordsParam);
10594 paramBuffer.addParam(std::move(coordsParam));
10595 }
10596 else
10597 {
10598 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
10599 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
10600 &coordsParam.value);
10601 paramBuffer.addParam(std::move(coordsParam));
10602 }
10603
10604 return CallCapture(angle::EntryPoint::GLDrawTexivOES, std::move(paramBuffer));
10605 }
10606
CaptureDrawTexsOES(const State & glState,bool isCallValid,GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)10607 CallCapture CaptureDrawTexsOES(const State &glState,
10608 bool isCallValid,
10609 GLshort x,
10610 GLshort y,
10611 GLshort z,
10612 GLshort width,
10613 GLshort height)
10614 {
10615 ParamBuffer paramBuffer;
10616
10617 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
10618 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
10619 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
10620 paramBuffer.addValueParam("width", ParamType::TGLshort, width);
10621 paramBuffer.addValueParam("height", ParamType::TGLshort, height);
10622
10623 return CallCapture(angle::EntryPoint::GLDrawTexsOES, std::move(paramBuffer));
10624 }
10625
CaptureDrawTexsvOES(const State & glState,bool isCallValid,const GLshort * coords)10626 CallCapture CaptureDrawTexsvOES(const State &glState, bool isCallValid, const GLshort *coords)
10627 {
10628 ParamBuffer paramBuffer;
10629
10630 if (isCallValid)
10631 {
10632 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
10633 InitParamValue(ParamType::TGLshortConstPointer, coords, &coordsParam.value);
10634 CaptureDrawTexsvOES_coords(glState, isCallValid, coords, &coordsParam);
10635 paramBuffer.addParam(std::move(coordsParam));
10636 }
10637 else
10638 {
10639 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
10640 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
10641 &coordsParam.value);
10642 paramBuffer.addParam(std::move(coordsParam));
10643 }
10644
10645 return CallCapture(angle::EntryPoint::GLDrawTexsvOES, std::move(paramBuffer));
10646 }
10647
CaptureDrawTexxOES(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)10648 CallCapture CaptureDrawTexxOES(const State &glState,
10649 bool isCallValid,
10650 GLfixed x,
10651 GLfixed y,
10652 GLfixed z,
10653 GLfixed width,
10654 GLfixed height)
10655 {
10656 ParamBuffer paramBuffer;
10657
10658 paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
10659 paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
10660 paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
10661 paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
10662 paramBuffer.addValueParam("height", ParamType::TGLfixed, height);
10663
10664 return CallCapture(angle::EntryPoint::GLDrawTexxOES, std::move(paramBuffer));
10665 }
10666
CaptureDrawTexxvOES(const State & glState,bool isCallValid,const GLfixed * coords)10667 CallCapture CaptureDrawTexxvOES(const State &glState, bool isCallValid, const GLfixed *coords)
10668 {
10669 ParamBuffer paramBuffer;
10670
10671 if (isCallValid)
10672 {
10673 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
10674 InitParamValue(ParamType::TGLfixedConstPointer, coords, &coordsParam.value);
10675 CaptureDrawTexxvOES_coords(glState, isCallValid, coords, &coordsParam);
10676 paramBuffer.addParam(std::move(coordsParam));
10677 }
10678 else
10679 {
10680 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
10681 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
10682 &coordsParam.value);
10683 paramBuffer.addParam(std::move(coordsParam));
10684 }
10685
10686 return CallCapture(angle::EntryPoint::GLDrawTexxvOES, std::move(paramBuffer));
10687 }
10688
CaptureBindFramebufferOES(const State & glState,bool isCallValid,GLenum target,FramebufferID framebufferPacked)10689 CallCapture CaptureBindFramebufferOES(const State &glState,
10690 bool isCallValid,
10691 GLenum target,
10692 FramebufferID framebufferPacked)
10693 {
10694 ParamBuffer paramBuffer;
10695
10696 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10697 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
10698
10699 return CallCapture(angle::EntryPoint::GLBindFramebufferOES, std::move(paramBuffer));
10700 }
10701
CaptureBindRenderbufferOES(const State & glState,bool isCallValid,GLenum target,RenderbufferID renderbufferPacked)10702 CallCapture CaptureBindRenderbufferOES(const State &glState,
10703 bool isCallValid,
10704 GLenum target,
10705 RenderbufferID renderbufferPacked)
10706 {
10707 ParamBuffer paramBuffer;
10708
10709 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10710 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10711
10712 return CallCapture(angle::EntryPoint::GLBindRenderbufferOES, std::move(paramBuffer));
10713 }
10714
CaptureCheckFramebufferStatusOES(const State & glState,bool isCallValid,GLenum target,GLenum returnValue)10715 CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
10716 bool isCallValid,
10717 GLenum target,
10718 GLenum returnValue)
10719 {
10720 ParamBuffer paramBuffer;
10721
10722 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10723
10724 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
10725 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
10726 paramBuffer.addReturnValue(std::move(returnValueCapture));
10727
10728 return CallCapture(angle::EntryPoint::GLCheckFramebufferStatusOES, std::move(paramBuffer));
10729 }
10730
CaptureDeleteFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,const FramebufferID * framebuffersPacked)10731 CallCapture CaptureDeleteFramebuffersOES(const State &glState,
10732 bool isCallValid,
10733 GLsizei n,
10734 const FramebufferID *framebuffersPacked)
10735 {
10736 ParamBuffer paramBuffer;
10737
10738 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10739
10740 if (isCallValid)
10741 {
10742 ParamCapture framebuffersPackedParam("framebuffersPacked",
10743 ParamType::TFramebufferIDConstPointer);
10744 InitParamValue(ParamType::TFramebufferIDConstPointer, framebuffersPacked,
10745 &framebuffersPackedParam.value);
10746 CaptureDeleteFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
10747 &framebuffersPackedParam);
10748 paramBuffer.addParam(std::move(framebuffersPackedParam));
10749 }
10750 else
10751 {
10752 ParamCapture framebuffersPackedParam("framebuffersPacked",
10753 ParamType::TFramebufferIDConstPointer);
10754 InitParamValue(ParamType::TFramebufferIDConstPointer,
10755 static_cast<const FramebufferID *>(nullptr), &framebuffersPackedParam.value);
10756 paramBuffer.addParam(std::move(framebuffersPackedParam));
10757 }
10758
10759 return CallCapture(angle::EntryPoint::GLDeleteFramebuffersOES, std::move(paramBuffer));
10760 }
10761
CaptureDeleteRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,const RenderbufferID * renderbuffersPacked)10762 CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
10763 bool isCallValid,
10764 GLsizei n,
10765 const RenderbufferID *renderbuffersPacked)
10766 {
10767 ParamBuffer paramBuffer;
10768
10769 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10770
10771 if (isCallValid)
10772 {
10773 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10774 ParamType::TRenderbufferIDConstPointer);
10775 InitParamValue(ParamType::TRenderbufferIDConstPointer, renderbuffersPacked,
10776 &renderbuffersPackedParam.value);
10777 CaptureDeleteRenderbuffersOES_renderbuffersPacked(
10778 glState, isCallValid, n, renderbuffersPacked, &renderbuffersPackedParam);
10779 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10780 }
10781 else
10782 {
10783 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10784 ParamType::TRenderbufferIDConstPointer);
10785 InitParamValue(ParamType::TRenderbufferIDConstPointer,
10786 static_cast<const RenderbufferID *>(nullptr),
10787 &renderbuffersPackedParam.value);
10788 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10789 }
10790
10791 return CallCapture(angle::EntryPoint::GLDeleteRenderbuffersOES, std::move(paramBuffer));
10792 }
10793
CaptureFramebufferRenderbufferOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum renderbuffertarget,RenderbufferID renderbufferPacked)10794 CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
10795 bool isCallValid,
10796 GLenum target,
10797 GLenum attachment,
10798 GLenum renderbuffertarget,
10799 RenderbufferID renderbufferPacked)
10800 {
10801 ParamBuffer paramBuffer;
10802
10803 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10804 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10805 attachment);
10806 paramBuffer.addEnumParam("renderbuffertarget", GLESEnum::RenderbufferTarget, ParamType::TGLenum,
10807 renderbuffertarget);
10808 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10809
10810 return CallCapture(angle::EntryPoint::GLFramebufferRenderbufferOES, std::move(paramBuffer));
10811 }
10812
CaptureFramebufferTexture2DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level)10813 CallCapture CaptureFramebufferTexture2DOES(const State &glState,
10814 bool isCallValid,
10815 GLenum target,
10816 GLenum attachment,
10817 TextureTarget textargetPacked,
10818 TextureID texturePacked,
10819 GLint level)
10820 {
10821 ParamBuffer paramBuffer;
10822
10823 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10824 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10825 attachment);
10826 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
10827 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
10828 paramBuffer.addValueParam("level", ParamType::TGLint, level);
10829
10830 return CallCapture(angle::EntryPoint::GLFramebufferTexture2DOES, std::move(paramBuffer));
10831 }
10832
CaptureGenFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,FramebufferID * framebuffersPacked)10833 CallCapture CaptureGenFramebuffersOES(const State &glState,
10834 bool isCallValid,
10835 GLsizei n,
10836 FramebufferID *framebuffersPacked)
10837 {
10838 ParamBuffer paramBuffer;
10839
10840 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10841
10842 if (isCallValid)
10843 {
10844 ParamCapture framebuffersPackedParam("framebuffersPacked",
10845 ParamType::TFramebufferIDPointer);
10846 InitParamValue(ParamType::TFramebufferIDPointer, framebuffersPacked,
10847 &framebuffersPackedParam.value);
10848 CaptureGenFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
10849 &framebuffersPackedParam);
10850 paramBuffer.addParam(std::move(framebuffersPackedParam));
10851 }
10852 else
10853 {
10854 ParamCapture framebuffersPackedParam("framebuffersPacked",
10855 ParamType::TFramebufferIDPointer);
10856 InitParamValue(ParamType::TFramebufferIDPointer, static_cast<FramebufferID *>(nullptr),
10857 &framebuffersPackedParam.value);
10858 paramBuffer.addParam(std::move(framebuffersPackedParam));
10859 }
10860
10861 return CallCapture(angle::EntryPoint::GLGenFramebuffersOES, std::move(paramBuffer));
10862 }
10863
CaptureGenRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,RenderbufferID * renderbuffersPacked)10864 CallCapture CaptureGenRenderbuffersOES(const State &glState,
10865 bool isCallValid,
10866 GLsizei n,
10867 RenderbufferID *renderbuffersPacked)
10868 {
10869 ParamBuffer paramBuffer;
10870
10871 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
10872
10873 if (isCallValid)
10874 {
10875 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10876 ParamType::TRenderbufferIDPointer);
10877 InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
10878 &renderbuffersPackedParam.value);
10879 CaptureGenRenderbuffersOES_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
10880 &renderbuffersPackedParam);
10881 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10882 }
10883 else
10884 {
10885 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
10886 ParamType::TRenderbufferIDPointer);
10887 InitParamValue(ParamType::TRenderbufferIDPointer, static_cast<RenderbufferID *>(nullptr),
10888 &renderbuffersPackedParam.value);
10889 paramBuffer.addParam(std::move(renderbuffersPackedParam));
10890 }
10891
10892 return CallCapture(angle::EntryPoint::GLGenRenderbuffersOES, std::move(paramBuffer));
10893 }
10894
CaptureGenerateMipmapOES(const State & glState,bool isCallValid,TextureType targetPacked)10895 CallCapture CaptureGenerateMipmapOES(const State &glState,
10896 bool isCallValid,
10897 TextureType targetPacked)
10898 {
10899 ParamBuffer paramBuffer;
10900
10901 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
10902
10903 return CallCapture(angle::EntryPoint::GLGenerateMipmapOES, std::move(paramBuffer));
10904 }
10905
CaptureGetFramebufferAttachmentParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLint * params)10906 CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
10907 bool isCallValid,
10908 GLenum target,
10909 GLenum attachment,
10910 GLenum pname,
10911 GLint *params)
10912 {
10913 ParamBuffer paramBuffer;
10914
10915 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
10916 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
10917 attachment);
10918 paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName,
10919 ParamType::TGLenum, pname);
10920
10921 if (isCallValid)
10922 {
10923 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10924 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10925 CaptureGetFramebufferAttachmentParameterivOES_params(
10926 glState, isCallValid, target, attachment, pname, params, ¶msParam);
10927 paramBuffer.addParam(std::move(paramsParam));
10928 }
10929 else
10930 {
10931 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10932 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10933 paramBuffer.addParam(std::move(paramsParam));
10934 }
10935
10936 return CallCapture(angle::EntryPoint::GLGetFramebufferAttachmentParameterivOES,
10937 std::move(paramBuffer));
10938 }
10939
CaptureGetRenderbufferParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)10940 CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
10941 bool isCallValid,
10942 GLenum target,
10943 GLenum pname,
10944 GLint *params)
10945 {
10946 ParamBuffer paramBuffer;
10947
10948 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
10949 paramBuffer.addEnumParam("pname", GLESEnum::RenderbufferParameterName, ParamType::TGLenum,
10950 pname);
10951
10952 if (isCallValid)
10953 {
10954 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10955 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
10956 CaptureGetRenderbufferParameterivOES_params(glState, isCallValid, target, pname, params,
10957 ¶msParam);
10958 paramBuffer.addParam(std::move(paramsParam));
10959 }
10960 else
10961 {
10962 ParamCapture paramsParam("params", ParamType::TGLintPointer);
10963 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
10964 paramBuffer.addParam(std::move(paramsParam));
10965 }
10966
10967 return CallCapture(angle::EntryPoint::GLGetRenderbufferParameterivOES, std::move(paramBuffer));
10968 }
10969
CaptureIsFramebufferOES(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLboolean returnValue)10970 CallCapture CaptureIsFramebufferOES(const State &glState,
10971 bool isCallValid,
10972 FramebufferID framebufferPacked,
10973 GLboolean returnValue)
10974 {
10975 ParamBuffer paramBuffer;
10976
10977 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
10978
10979 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10980 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10981 paramBuffer.addReturnValue(std::move(returnValueCapture));
10982
10983 return CallCapture(angle::EntryPoint::GLIsFramebufferOES, std::move(paramBuffer));
10984 }
10985
CaptureIsRenderbufferOES(const State & glState,bool isCallValid,RenderbufferID renderbufferPacked,GLboolean returnValue)10986 CallCapture CaptureIsRenderbufferOES(const State &glState,
10987 bool isCallValid,
10988 RenderbufferID renderbufferPacked,
10989 GLboolean returnValue)
10990 {
10991 ParamBuffer paramBuffer;
10992
10993 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
10994
10995 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
10996 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
10997 paramBuffer.addReturnValue(std::move(returnValueCapture));
10998
10999 return CallCapture(angle::EntryPoint::GLIsRenderbufferOES, std::move(paramBuffer));
11000 }
11001
CaptureRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)11002 CallCapture CaptureRenderbufferStorageOES(const State &glState,
11003 bool isCallValid,
11004 GLenum target,
11005 GLenum internalformat,
11006 GLsizei width,
11007 GLsizei height)
11008 {
11009 ParamBuffer paramBuffer;
11010
11011 paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target);
11012 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11013 internalformat);
11014 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11015 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11016
11017 return CallCapture(angle::EntryPoint::GLRenderbufferStorageOES, std::move(paramBuffer));
11018 }
11019
CaptureFramebufferTextureOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)11020 CallCapture CaptureFramebufferTextureOES(const State &glState,
11021 bool isCallValid,
11022 GLenum target,
11023 GLenum attachment,
11024 TextureID texturePacked,
11025 GLint level)
11026 {
11027 ParamBuffer paramBuffer;
11028
11029 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
11030 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
11031 attachment);
11032 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
11033 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11034
11035 return CallCapture(angle::EntryPoint::GLFramebufferTextureOES, std::move(paramBuffer));
11036 }
11037
CaptureGetProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)11038 CallCapture CaptureGetProgramBinaryOES(const State &glState,
11039 bool isCallValid,
11040 ShaderProgramID programPacked,
11041 GLsizei bufSize,
11042 GLsizei *length,
11043 GLenum *binaryFormat,
11044 void *binary)
11045 {
11046 ParamBuffer paramBuffer;
11047
11048 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
11049 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
11050
11051 if (isCallValid)
11052 {
11053 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
11054 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
11055 CaptureGetProgramBinaryOES_length(glState, isCallValid, programPacked, bufSize, length,
11056 binaryFormat, binary, &lengthParam);
11057 paramBuffer.addParam(std::move(lengthParam));
11058 }
11059 else
11060 {
11061 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
11062 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
11063 &lengthParam.value);
11064 paramBuffer.addParam(std::move(lengthParam));
11065 }
11066
11067 if (isCallValid)
11068 {
11069 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
11070 InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
11071 CaptureGetProgramBinaryOES_binaryFormat(glState, isCallValid, programPacked, bufSize,
11072 length, binaryFormat, binary, &binaryFormatParam);
11073 paramBuffer.addParam(std::move(binaryFormatParam));
11074 }
11075 else
11076 {
11077 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
11078 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
11079 &binaryFormatParam.value);
11080 paramBuffer.addParam(std::move(binaryFormatParam));
11081 }
11082
11083 if (isCallValid)
11084 {
11085 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
11086 InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
11087 CaptureGetProgramBinaryOES_binary(glState, isCallValid, programPacked, bufSize, length,
11088 binaryFormat, binary, &binaryParam);
11089 paramBuffer.addParam(std::move(binaryParam));
11090 }
11091 else
11092 {
11093 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
11094 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &binaryParam.value);
11095 paramBuffer.addParam(std::move(binaryParam));
11096 }
11097
11098 return CallCapture(angle::EntryPoint::GLGetProgramBinaryOES, std::move(paramBuffer));
11099 }
11100
CaptureProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum binaryFormat,const void * binary,GLint length)11101 CallCapture CaptureProgramBinaryOES(const State &glState,
11102 bool isCallValid,
11103 ShaderProgramID programPacked,
11104 GLenum binaryFormat,
11105 const void *binary,
11106 GLint length)
11107 {
11108 ParamBuffer paramBuffer;
11109
11110 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
11111 paramBuffer.addEnumParam("binaryFormat", GLESEnum::AllEnums, ParamType::TGLenum, binaryFormat);
11112
11113 if (isCallValid)
11114 {
11115 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
11116 InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
11117 CaptureProgramBinaryOES_binary(glState, isCallValid, programPacked, binaryFormat, binary,
11118 length, &binaryParam);
11119 paramBuffer.addParam(std::move(binaryParam));
11120 }
11121 else
11122 {
11123 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
11124 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11125 &binaryParam.value);
11126 paramBuffer.addParam(std::move(binaryParam));
11127 }
11128
11129 paramBuffer.addValueParam("length", ParamType::TGLint, length);
11130
11131 return CallCapture(angle::EntryPoint::GLProgramBinaryOES, std::move(paramBuffer));
11132 }
11133
CaptureGetBufferPointervOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,void ** params)11134 CallCapture CaptureGetBufferPointervOES(const State &glState,
11135 bool isCallValid,
11136 BufferBinding targetPacked,
11137 GLenum pname,
11138 void **params)
11139 {
11140 ParamBuffer paramBuffer;
11141
11142 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
11143 paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname);
11144
11145 if (isCallValid)
11146 {
11147 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
11148 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
11149 CaptureGetBufferPointervOES_params(glState, isCallValid, targetPacked, pname, params,
11150 ¶msParam);
11151 paramBuffer.addParam(std::move(paramsParam));
11152 }
11153 else
11154 {
11155 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
11156 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
11157 ¶msParam.value);
11158 paramBuffer.addParam(std::move(paramsParam));
11159 }
11160
11161 return CallCapture(angle::EntryPoint::GLGetBufferPointervOES, std::move(paramBuffer));
11162 }
11163
CaptureMapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum access,void * returnValue)11164 CallCapture CaptureMapBufferOES(const State &glState,
11165 bool isCallValid,
11166 BufferBinding targetPacked,
11167 GLenum access,
11168 void *returnValue)
11169 {
11170 ParamBuffer paramBuffer;
11171
11172 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
11173 paramBuffer.addEnumParam("access", GLESEnum::BufferAccessARB, ParamType::TGLenum, access);
11174
11175 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
11176 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
11177 paramBuffer.addReturnValue(std::move(returnValueCapture));
11178
11179 return CallCapture(angle::EntryPoint::GLMapBufferOES, std::move(paramBuffer));
11180 }
11181
CaptureUnmapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLboolean returnValue)11182 CallCapture CaptureUnmapBufferOES(const State &glState,
11183 bool isCallValid,
11184 BufferBinding targetPacked,
11185 GLboolean returnValue)
11186 {
11187 ParamBuffer paramBuffer;
11188
11189 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
11190
11191 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
11192 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
11193 paramBuffer.addReturnValue(std::move(returnValueCapture));
11194
11195 return CallCapture(angle::EntryPoint::GLUnmapBufferOES, std::move(paramBuffer));
11196 }
11197
CaptureCurrentPaletteMatrixOES(const State & glState,bool isCallValid,GLuint matrixpaletteindex)11198 CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
11199 bool isCallValid,
11200 GLuint matrixpaletteindex)
11201 {
11202 ParamBuffer paramBuffer;
11203
11204 paramBuffer.addValueParam("matrixpaletteindex", ParamType::TGLuint, matrixpaletteindex);
11205
11206 return CallCapture(angle::EntryPoint::GLCurrentPaletteMatrixOES, std::move(paramBuffer));
11207 }
11208
CaptureLoadPaletteFromModelViewMatrixOES(const State & glState,bool isCallValid)11209 CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid)
11210 {
11211 ParamBuffer paramBuffer;
11212
11213 return CallCapture(angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES,
11214 std::move(paramBuffer));
11215 }
11216
CaptureMatrixIndexPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)11217 CallCapture CaptureMatrixIndexPointerOES(const State &glState,
11218 bool isCallValid,
11219 GLint size,
11220 GLenum type,
11221 GLsizei stride,
11222 const void *pointer)
11223 {
11224 ParamBuffer paramBuffer;
11225
11226 paramBuffer.addValueParam("size", ParamType::TGLint, size);
11227 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
11228 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
11229
11230 if (isCallValid)
11231 {
11232 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11233 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
11234 CaptureMatrixIndexPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
11235 &pointerParam);
11236 paramBuffer.addParam(std::move(pointerParam));
11237 }
11238 else
11239 {
11240 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11241 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11242 &pointerParam.value);
11243 paramBuffer.addParam(std::move(pointerParam));
11244 }
11245
11246 return CallCapture(angle::EntryPoint::GLMatrixIndexPointerOES, std::move(paramBuffer));
11247 }
11248
CaptureWeightPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)11249 CallCapture CaptureWeightPointerOES(const State &glState,
11250 bool isCallValid,
11251 GLint size,
11252 GLenum type,
11253 GLsizei stride,
11254 const void *pointer)
11255 {
11256 ParamBuffer paramBuffer;
11257
11258 paramBuffer.addValueParam("size", ParamType::TGLint, size);
11259 paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type);
11260 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
11261
11262 if (isCallValid)
11263 {
11264 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11265 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
11266 CaptureWeightPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
11267 &pointerParam);
11268 paramBuffer.addParam(std::move(pointerParam));
11269 }
11270 else
11271 {
11272 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11273 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11274 &pointerParam.value);
11275 paramBuffer.addParam(std::move(pointerParam));
11276 }
11277
11278 return CallCapture(angle::EntryPoint::GLWeightPointerOES, std::move(paramBuffer));
11279 }
11280
CapturePointSizePointerOES(const State & glState,bool isCallValid,VertexAttribType typePacked,GLsizei stride,const void * pointer)11281 CallCapture CapturePointSizePointerOES(const State &glState,
11282 bool isCallValid,
11283 VertexAttribType typePacked,
11284 GLsizei stride,
11285 const void *pointer)
11286 {
11287 ParamBuffer paramBuffer;
11288
11289 paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
11290 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
11291
11292 if (isCallValid)
11293 {
11294 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11295 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
11296 CapturePointSizePointerOES_pointer(glState, isCallValid, typePacked, stride, pointer,
11297 &pointerParam);
11298 paramBuffer.addParam(std::move(pointerParam));
11299 }
11300 else
11301 {
11302 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
11303 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11304 &pointerParam.value);
11305 paramBuffer.addParam(std::move(pointerParam));
11306 }
11307
11308 return CallCapture(angle::EntryPoint::GLPointSizePointerOES, std::move(paramBuffer));
11309 }
11310
CapturePrimitiveBoundingBoxOES(const State & glState,bool isCallValid,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)11311 CallCapture CapturePrimitiveBoundingBoxOES(const State &glState,
11312 bool isCallValid,
11313 GLfloat minX,
11314 GLfloat minY,
11315 GLfloat minZ,
11316 GLfloat minW,
11317 GLfloat maxX,
11318 GLfloat maxY,
11319 GLfloat maxZ,
11320 GLfloat maxW)
11321 {
11322 ParamBuffer paramBuffer;
11323
11324 paramBuffer.addValueParam("minX", ParamType::TGLfloat, minX);
11325 paramBuffer.addValueParam("minY", ParamType::TGLfloat, minY);
11326 paramBuffer.addValueParam("minZ", ParamType::TGLfloat, minZ);
11327 paramBuffer.addValueParam("minW", ParamType::TGLfloat, minW);
11328 paramBuffer.addValueParam("maxX", ParamType::TGLfloat, maxX);
11329 paramBuffer.addValueParam("maxY", ParamType::TGLfloat, maxY);
11330 paramBuffer.addValueParam("maxZ", ParamType::TGLfloat, maxZ);
11331 paramBuffer.addValueParam("maxW", ParamType::TGLfloat, maxW);
11332
11333 return CallCapture(angle::EntryPoint::GLPrimitiveBoundingBoxOES, std::move(paramBuffer));
11334 }
11335
CaptureQueryMatrixxOES(const State & glState,bool isCallValid,GLfixed * mantissa,GLint * exponent,GLbitfield returnValue)11336 CallCapture CaptureQueryMatrixxOES(const State &glState,
11337 bool isCallValid,
11338 GLfixed *mantissa,
11339 GLint *exponent,
11340 GLbitfield returnValue)
11341 {
11342 ParamBuffer paramBuffer;
11343
11344 if (isCallValid)
11345 {
11346 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
11347 InitParamValue(ParamType::TGLfixedPointer, mantissa, &mantissaParam.value);
11348 CaptureQueryMatrixxOES_mantissa(glState, isCallValid, mantissa, exponent, &mantissaParam);
11349 paramBuffer.addParam(std::move(mantissaParam));
11350 }
11351 else
11352 {
11353 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
11354 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
11355 &mantissaParam.value);
11356 paramBuffer.addParam(std::move(mantissaParam));
11357 }
11358
11359 if (isCallValid)
11360 {
11361 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
11362 InitParamValue(ParamType::TGLintPointer, exponent, &exponentParam.value);
11363 CaptureQueryMatrixxOES_exponent(glState, isCallValid, mantissa, exponent, &exponentParam);
11364 paramBuffer.addParam(std::move(exponentParam));
11365 }
11366 else
11367 {
11368 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
11369 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
11370 &exponentParam.value);
11371 paramBuffer.addParam(std::move(exponentParam));
11372 }
11373
11374 ParamCapture returnValueCapture("returnValue", ParamType::TGLbitfield);
11375 InitParamValue(ParamType::TGLbitfield, returnValue, &returnValueCapture.value);
11376 paramBuffer.addReturnValue(std::move(returnValueCapture));
11377
11378 return CallCapture(angle::EntryPoint::GLQueryMatrixxOES, std::move(paramBuffer));
11379 }
11380
CaptureMinSampleShadingOES(const State & glState,bool isCallValid,GLfloat value)11381 CallCapture CaptureMinSampleShadingOES(const State &glState, bool isCallValid, GLfloat value)
11382 {
11383 ParamBuffer paramBuffer;
11384
11385 paramBuffer.addValueParam("value", ParamType::TGLfloat, value);
11386
11387 return CallCapture(angle::EntryPoint::GLMinSampleShadingOES, std::move(paramBuffer));
11388 }
11389
CapturePatchParameteriOES(const State & glState,bool isCallValid,GLenum pname,GLint value)11390 CallCapture CapturePatchParameteriOES(const State &glState,
11391 bool isCallValid,
11392 GLenum pname,
11393 GLint value)
11394 {
11395 ParamBuffer paramBuffer;
11396
11397 paramBuffer.addEnumParam("pname", GLESEnum::PatchParameterName, ParamType::TGLenum, pname);
11398 paramBuffer.addValueParam("value", ParamType::TGLint, value);
11399
11400 return CallCapture(angle::EntryPoint::GLPatchParameteriOES, std::move(paramBuffer));
11401 }
11402
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)11403 CallCapture CaptureCompressedTexImage3DOES(const State &glState,
11404 bool isCallValid,
11405 TextureTarget targetPacked,
11406 GLint level,
11407 GLenum internalformat,
11408 GLsizei width,
11409 GLsizei height,
11410 GLsizei depth,
11411 GLint border,
11412 GLsizei imageSize,
11413 const void *data)
11414 {
11415 ParamBuffer paramBuffer;
11416
11417 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11418 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11419 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11420 internalformat);
11421 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11422 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11423 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11424 paramBuffer.addValueParam("border", ParamType::TGLint, border);
11425 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
11426
11427 if (isCallValid)
11428 {
11429 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11430 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
11431 CaptureCompressedTexImage3DOES_data(glState, isCallValid, targetPacked, level,
11432 internalformat, width, height, depth, border, imageSize,
11433 data, &dataParam);
11434 paramBuffer.addParam(std::move(dataParam));
11435 }
11436 else
11437 {
11438 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11439 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11440 &dataParam.value);
11441 paramBuffer.addParam(std::move(dataParam));
11442 }
11443
11444 return CallCapture(angle::EntryPoint::GLCompressedTexImage3DOES, std::move(paramBuffer));
11445 }
11446
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)11447 CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
11448 bool isCallValid,
11449 TextureTarget targetPacked,
11450 GLint level,
11451 GLint xoffset,
11452 GLint yoffset,
11453 GLint zoffset,
11454 GLsizei width,
11455 GLsizei height,
11456 GLsizei depth,
11457 GLenum format,
11458 GLsizei imageSize,
11459 const void *data)
11460 {
11461 ParamBuffer paramBuffer;
11462
11463 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11464 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11465 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11466 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11467 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11468 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11469 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11470 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11471 paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format);
11472 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
11473
11474 if (isCallValid)
11475 {
11476 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11477 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
11478 CaptureCompressedTexSubImage3DOES_data(glState, isCallValid, targetPacked, level, xoffset,
11479 yoffset, zoffset, width, height, depth, format,
11480 imageSize, data, &dataParam);
11481 paramBuffer.addParam(std::move(dataParam));
11482 }
11483 else
11484 {
11485 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
11486 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11487 &dataParam.value);
11488 paramBuffer.addParam(std::move(dataParam));
11489 }
11490
11491 return CallCapture(angle::EntryPoint::GLCompressedTexSubImage3DOES, std::move(paramBuffer));
11492 }
11493
CaptureCopyTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)11494 CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
11495 bool isCallValid,
11496 TextureTarget targetPacked,
11497 GLint level,
11498 GLint xoffset,
11499 GLint yoffset,
11500 GLint zoffset,
11501 GLint x,
11502 GLint y,
11503 GLsizei width,
11504 GLsizei height)
11505 {
11506 ParamBuffer paramBuffer;
11507
11508 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11509 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11510 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11511 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11512 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11513 paramBuffer.addValueParam("x", ParamType::TGLint, x);
11514 paramBuffer.addValueParam("y", ParamType::TGLint, y);
11515 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11516 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11517
11518 return CallCapture(angle::EntryPoint::GLCopyTexSubImage3DOES, std::move(paramBuffer));
11519 }
11520
CaptureFramebufferTexture3DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLint zoffset)11521 CallCapture CaptureFramebufferTexture3DOES(const State &glState,
11522 bool isCallValid,
11523 GLenum target,
11524 GLenum attachment,
11525 TextureTarget textargetPacked,
11526 TextureID texturePacked,
11527 GLint level,
11528 GLint zoffset)
11529 {
11530 ParamBuffer paramBuffer;
11531
11532 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
11533 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
11534 attachment);
11535 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
11536 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
11537 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11538 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11539
11540 return CallCapture(angle::EntryPoint::GLFramebufferTexture3DOES, std::move(paramBuffer));
11541 }
11542
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)11543 CallCapture CaptureTexImage3DOES(const State &glState,
11544 bool isCallValid,
11545 TextureTarget targetPacked,
11546 GLint level,
11547 GLenum internalformat,
11548 GLsizei width,
11549 GLsizei height,
11550 GLsizei depth,
11551 GLint border,
11552 GLenum format,
11553 GLenum type,
11554 const void *pixels)
11555 {
11556 ParamBuffer paramBuffer;
11557
11558 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11559 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11560 paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum,
11561 internalformat);
11562 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11563 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11564 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11565 paramBuffer.addValueParam("border", ParamType::TGLint, border);
11566 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
11567 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
11568
11569 if (isCallValid)
11570 {
11571 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11572 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
11573 CaptureTexImage3DOES_pixels(glState, isCallValid, targetPacked, level, internalformat,
11574 width, height, depth, border, format, type, pixels,
11575 &pixelsParam);
11576 paramBuffer.addParam(std::move(pixelsParam));
11577 }
11578 else
11579 {
11580 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11581 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11582 &pixelsParam.value);
11583 paramBuffer.addParam(std::move(pixelsParam));
11584 }
11585
11586 return CallCapture(angle::EntryPoint::GLTexImage3DOES, std::move(paramBuffer));
11587 }
11588
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)11589 CallCapture CaptureTexSubImage3DOES(const State &glState,
11590 bool isCallValid,
11591 TextureTarget targetPacked,
11592 GLint level,
11593 GLint xoffset,
11594 GLint yoffset,
11595 GLint zoffset,
11596 GLsizei width,
11597 GLsizei height,
11598 GLsizei depth,
11599 GLenum format,
11600 GLenum type,
11601 const void *pixels)
11602 {
11603 ParamBuffer paramBuffer;
11604
11605 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
11606 paramBuffer.addValueParam("level", ParamType::TGLint, level);
11607 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
11608 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
11609 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
11610 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
11611 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
11612 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
11613 paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format);
11614 paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type);
11615
11616 if (isCallValid)
11617 {
11618 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11619 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
11620 CaptureTexSubImage3DOES_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
11621 zoffset, width, height, depth, format, type, pixels,
11622 &pixelsParam);
11623 paramBuffer.addParam(std::move(pixelsParam));
11624 }
11625 else
11626 {
11627 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
11628 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
11629 &pixelsParam.value);
11630 paramBuffer.addParam(std::move(pixelsParam));
11631 }
11632
11633 return CallCapture(angle::EntryPoint::GLTexSubImage3DOES, std::move(paramBuffer));
11634 }
11635
CaptureGetSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)11636 CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
11637 bool isCallValid,
11638 SamplerID samplerPacked,
11639 GLenum pname,
11640 GLint *params)
11641 {
11642 ParamBuffer paramBuffer;
11643
11644 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11645 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11646
11647 if (isCallValid)
11648 {
11649 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11650 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11651 CaptureGetSamplerParameterIivOES_params(glState, isCallValid, samplerPacked, pname, params,
11652 ¶msParam);
11653 paramBuffer.addParam(std::move(paramsParam));
11654 }
11655 else
11656 {
11657 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11658 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11659 paramBuffer.addParam(std::move(paramsParam));
11660 }
11661
11662 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIivOES, std::move(paramBuffer));
11663 }
11664
CaptureGetSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)11665 CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
11666 bool isCallValid,
11667 SamplerID samplerPacked,
11668 GLenum pname,
11669 GLuint *params)
11670 {
11671 ParamBuffer paramBuffer;
11672
11673 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11674 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11675
11676 if (isCallValid)
11677 {
11678 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11679 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
11680 CaptureGetSamplerParameterIuivOES_params(glState, isCallValid, samplerPacked, pname, params,
11681 ¶msParam);
11682 paramBuffer.addParam(std::move(paramsParam));
11683 }
11684 else
11685 {
11686 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11687 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
11688 ¶msParam.value);
11689 paramBuffer.addParam(std::move(paramsParam));
11690 }
11691
11692 return CallCapture(angle::EntryPoint::GLGetSamplerParameterIuivOES, std::move(paramBuffer));
11693 }
11694
CaptureGetTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)11695 CallCapture CaptureGetTexParameterIivOES(const State &glState,
11696 bool isCallValid,
11697 TextureType targetPacked,
11698 GLenum pname,
11699 GLint *params)
11700 {
11701 ParamBuffer paramBuffer;
11702
11703 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11704 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
11705
11706 if (isCallValid)
11707 {
11708 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11709 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11710 CaptureGetTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
11711 ¶msParam);
11712 paramBuffer.addParam(std::move(paramsParam));
11713 }
11714 else
11715 {
11716 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11717 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11718 paramBuffer.addParam(std::move(paramsParam));
11719 }
11720
11721 return CallCapture(angle::EntryPoint::GLGetTexParameterIivOES, std::move(paramBuffer));
11722 }
11723
CaptureGetTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)11724 CallCapture CaptureGetTexParameterIuivOES(const State &glState,
11725 bool isCallValid,
11726 TextureType targetPacked,
11727 GLenum pname,
11728 GLuint *params)
11729 {
11730 ParamBuffer paramBuffer;
11731
11732 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11733 paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname);
11734
11735 if (isCallValid)
11736 {
11737 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11738 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
11739 CaptureGetTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
11740 ¶msParam);
11741 paramBuffer.addParam(std::move(paramsParam));
11742 }
11743 else
11744 {
11745 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
11746 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
11747 ¶msParam.value);
11748 paramBuffer.addParam(std::move(paramsParam));
11749 }
11750
11751 return CallCapture(angle::EntryPoint::GLGetTexParameterIuivOES, std::move(paramBuffer));
11752 }
11753
CaptureSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)11754 CallCapture CaptureSamplerParameterIivOES(const State &glState,
11755 bool isCallValid,
11756 SamplerID samplerPacked,
11757 GLenum pname,
11758 const GLint *param)
11759 {
11760 ParamBuffer paramBuffer;
11761
11762 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11763 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11764
11765 if (isCallValid)
11766 {
11767 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
11768 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
11769 CaptureSamplerParameterIivOES_param(glState, isCallValid, samplerPacked, pname, param,
11770 ¶mParam);
11771 paramBuffer.addParam(std::move(paramParam));
11772 }
11773 else
11774 {
11775 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
11776 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11777 ¶mParam.value);
11778 paramBuffer.addParam(std::move(paramParam));
11779 }
11780
11781 return CallCapture(angle::EntryPoint::GLSamplerParameterIivOES, std::move(paramBuffer));
11782 }
11783
CaptureSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)11784 CallCapture CaptureSamplerParameterIuivOES(const State &glState,
11785 bool isCallValid,
11786 SamplerID samplerPacked,
11787 GLenum pname,
11788 const GLuint *param)
11789 {
11790 ParamBuffer paramBuffer;
11791
11792 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
11793 paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname);
11794
11795 if (isCallValid)
11796 {
11797 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
11798 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
11799 CaptureSamplerParameterIuivOES_param(glState, isCallValid, samplerPacked, pname, param,
11800 ¶mParam);
11801 paramBuffer.addParam(std::move(paramParam));
11802 }
11803 else
11804 {
11805 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
11806 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
11807 ¶mParam.value);
11808 paramBuffer.addParam(std::move(paramParam));
11809 }
11810
11811 return CallCapture(angle::EntryPoint::GLSamplerParameterIuivOES, std::move(paramBuffer));
11812 }
11813
CaptureTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)11814 CallCapture CaptureTexParameterIivOES(const State &glState,
11815 bool isCallValid,
11816 TextureType targetPacked,
11817 GLenum pname,
11818 const GLint *params)
11819 {
11820 ParamBuffer paramBuffer;
11821
11822 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11823 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
11824
11825 if (isCallValid)
11826 {
11827 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11828 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
11829 CaptureTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
11830 ¶msParam);
11831 paramBuffer.addParam(std::move(paramsParam));
11832 }
11833 else
11834 {
11835 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
11836 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
11837 ¶msParam.value);
11838 paramBuffer.addParam(std::move(paramsParam));
11839 }
11840
11841 return CallCapture(angle::EntryPoint::GLTexParameterIivOES, std::move(paramBuffer));
11842 }
11843
CaptureTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)11844 CallCapture CaptureTexParameterIuivOES(const State &glState,
11845 bool isCallValid,
11846 TextureType targetPacked,
11847 GLenum pname,
11848 const GLuint *params)
11849 {
11850 ParamBuffer paramBuffer;
11851
11852 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11853 paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname);
11854
11855 if (isCallValid)
11856 {
11857 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
11858 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
11859 CaptureTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
11860 ¶msParam);
11861 paramBuffer.addParam(std::move(paramsParam));
11862 }
11863 else
11864 {
11865 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
11866 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
11867 ¶msParam.value);
11868 paramBuffer.addParam(std::move(paramsParam));
11869 }
11870
11871 return CallCapture(angle::EntryPoint::GLTexParameterIuivOES, std::move(paramBuffer));
11872 }
11873
CaptureTexBufferOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)11874 CallCapture CaptureTexBufferOES(const State &glState,
11875 bool isCallValid,
11876 TextureType targetPacked,
11877 GLenum internalformat,
11878 BufferID bufferPacked)
11879 {
11880 ParamBuffer paramBuffer;
11881
11882 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11883 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11884 internalformat);
11885 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
11886
11887 return CallCapture(angle::EntryPoint::GLTexBufferOES, std::move(paramBuffer));
11888 }
11889
CaptureTexBufferRangeOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)11890 CallCapture CaptureTexBufferRangeOES(const State &glState,
11891 bool isCallValid,
11892 TextureType targetPacked,
11893 GLenum internalformat,
11894 BufferID bufferPacked,
11895 GLintptr offset,
11896 GLsizeiptr size)
11897 {
11898 ParamBuffer paramBuffer;
11899
11900 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
11901 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
11902 internalformat);
11903 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
11904 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
11905 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
11906
11907 return CallCapture(angle::EntryPoint::GLTexBufferRangeOES, std::move(paramBuffer));
11908 }
11909
CaptureGetTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat * params)11910 CallCapture CaptureGetTexGenfvOES(const State &glState,
11911 bool isCallValid,
11912 GLenum coord,
11913 GLenum pname,
11914 GLfloat *params)
11915 {
11916 ParamBuffer paramBuffer;
11917
11918 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11919 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11920
11921 if (isCallValid)
11922 {
11923 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
11924 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
11925 CaptureGetTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11926 paramBuffer.addParam(std::move(paramsParam));
11927 }
11928 else
11929 {
11930 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
11931 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
11932 ¶msParam.value);
11933 paramBuffer.addParam(std::move(paramsParam));
11934 }
11935
11936 return CallCapture(angle::EntryPoint::GLGetTexGenfvOES, std::move(paramBuffer));
11937 }
11938
CaptureGetTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint * params)11939 CallCapture CaptureGetTexGenivOES(const State &glState,
11940 bool isCallValid,
11941 GLenum coord,
11942 GLenum pname,
11943 GLint *params)
11944 {
11945 ParamBuffer paramBuffer;
11946
11947 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11948 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11949
11950 if (isCallValid)
11951 {
11952 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11953 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
11954 CaptureGetTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11955 paramBuffer.addParam(std::move(paramsParam));
11956 }
11957 else
11958 {
11959 ParamCapture paramsParam("params", ParamType::TGLintPointer);
11960 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
11961 paramBuffer.addParam(std::move(paramsParam));
11962 }
11963
11964 return CallCapture(angle::EntryPoint::GLGetTexGenivOES, std::move(paramBuffer));
11965 }
11966
CaptureGetTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed * params)11967 CallCapture CaptureGetTexGenxvOES(const State &glState,
11968 bool isCallValid,
11969 GLenum coord,
11970 GLenum pname,
11971 GLfixed *params)
11972 {
11973 ParamBuffer paramBuffer;
11974
11975 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
11976 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
11977
11978 if (isCallValid)
11979 {
11980 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
11981 InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value);
11982 CaptureGetTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
11983 paramBuffer.addParam(std::move(paramsParam));
11984 }
11985 else
11986 {
11987 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
11988 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
11989 ¶msParam.value);
11990 paramBuffer.addParam(std::move(paramsParam));
11991 }
11992
11993 return CallCapture(angle::EntryPoint::GLGetTexGenxvOES, std::move(paramBuffer));
11994 }
11995
CaptureTexGenfOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat param)11996 CallCapture CaptureTexGenfOES(const State &glState,
11997 bool isCallValid,
11998 GLenum coord,
11999 GLenum pname,
12000 GLfloat param)
12001 {
12002 ParamBuffer paramBuffer;
12003
12004 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
12005 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
12006 paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
12007
12008 return CallCapture(angle::EntryPoint::GLTexGenfOES, std::move(paramBuffer));
12009 }
12010
CaptureTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfloat * params)12011 CallCapture CaptureTexGenfvOES(const State &glState,
12012 bool isCallValid,
12013 GLenum coord,
12014 GLenum pname,
12015 const GLfloat *params)
12016 {
12017 ParamBuffer paramBuffer;
12018
12019 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
12020 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
12021
12022 if (isCallValid)
12023 {
12024 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
12025 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
12026 CaptureTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
12027 paramBuffer.addParam(std::move(paramsParam));
12028 }
12029 else
12030 {
12031 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
12032 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
12033 ¶msParam.value);
12034 paramBuffer.addParam(std::move(paramsParam));
12035 }
12036
12037 return CallCapture(angle::EntryPoint::GLTexGenfvOES, std::move(paramBuffer));
12038 }
12039
CaptureTexGeniOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint param)12040 CallCapture CaptureTexGeniOES(const State &glState,
12041 bool isCallValid,
12042 GLenum coord,
12043 GLenum pname,
12044 GLint param)
12045 {
12046 ParamBuffer paramBuffer;
12047
12048 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
12049 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
12050 paramBuffer.addValueParam("param", ParamType::TGLint, param);
12051
12052 return CallCapture(angle::EntryPoint::GLTexGeniOES, std::move(paramBuffer));
12053 }
12054
CaptureTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLint * params)12055 CallCapture CaptureTexGenivOES(const State &glState,
12056 bool isCallValid,
12057 GLenum coord,
12058 GLenum pname,
12059 const GLint *params)
12060 {
12061 ParamBuffer paramBuffer;
12062
12063 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
12064 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
12065
12066 if (isCallValid)
12067 {
12068 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
12069 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
12070 CaptureTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
12071 paramBuffer.addParam(std::move(paramsParam));
12072 }
12073 else
12074 {
12075 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
12076 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
12077 ¶msParam.value);
12078 paramBuffer.addParam(std::move(paramsParam));
12079 }
12080
12081 return CallCapture(angle::EntryPoint::GLTexGenivOES, std::move(paramBuffer));
12082 }
12083
CaptureTexGenxOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed param)12084 CallCapture CaptureTexGenxOES(const State &glState,
12085 bool isCallValid,
12086 GLenum coord,
12087 GLenum pname,
12088 GLfixed param)
12089 {
12090 ParamBuffer paramBuffer;
12091
12092 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
12093 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
12094 paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
12095
12096 return CallCapture(angle::EntryPoint::GLTexGenxOES, std::move(paramBuffer));
12097 }
12098
CaptureTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfixed * params)12099 CallCapture CaptureTexGenxvOES(const State &glState,
12100 bool isCallValid,
12101 GLenum coord,
12102 GLenum pname,
12103 const GLfixed *params)
12104 {
12105 ParamBuffer paramBuffer;
12106
12107 paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord);
12108 paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname);
12109
12110 if (isCallValid)
12111 {
12112 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
12113 InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value);
12114 CaptureTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
12115 paramBuffer.addParam(std::move(paramsParam));
12116 }
12117 else
12118 {
12119 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
12120 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
12121 ¶msParam.value);
12122 paramBuffer.addParam(std::move(paramsParam));
12123 }
12124
12125 return CallCapture(angle::EntryPoint::GLTexGenxvOES, std::move(paramBuffer));
12126 }
12127
CaptureTexStorage3DMultisampleOES(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)12128 CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
12129 bool isCallValid,
12130 TextureType targetPacked,
12131 GLsizei samples,
12132 GLenum internalformat,
12133 GLsizei width,
12134 GLsizei height,
12135 GLsizei depth,
12136 GLboolean fixedsamplelocations)
12137 {
12138 ParamBuffer paramBuffer;
12139
12140 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
12141 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
12142 paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum,
12143 internalformat);
12144 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
12145 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
12146 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
12147 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
12148
12149 return CallCapture(angle::EntryPoint::GLTexStorage3DMultisampleOES, std::move(paramBuffer));
12150 }
12151
CaptureBindVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked)12152 CallCapture CaptureBindVertexArrayOES(const State &glState,
12153 bool isCallValid,
12154 VertexArrayID arrayPacked)
12155 {
12156 ParamBuffer paramBuffer;
12157
12158 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
12159
12160 return CallCapture(angle::EntryPoint::GLBindVertexArrayOES, std::move(paramBuffer));
12161 }
12162
CaptureDeleteVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,const VertexArrayID * arraysPacked)12163 CallCapture CaptureDeleteVertexArraysOES(const State &glState,
12164 bool isCallValid,
12165 GLsizei n,
12166 const VertexArrayID *arraysPacked)
12167 {
12168 ParamBuffer paramBuffer;
12169
12170 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
12171
12172 if (isCallValid)
12173 {
12174 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
12175 InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked,
12176 &arraysPackedParam.value);
12177 CaptureDeleteVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
12178 &arraysPackedParam);
12179 paramBuffer.addParam(std::move(arraysPackedParam));
12180 }
12181 else
12182 {
12183 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
12184 InitParamValue(ParamType::TVertexArrayIDConstPointer,
12185 static_cast<const VertexArrayID *>(nullptr), &arraysPackedParam.value);
12186 paramBuffer.addParam(std::move(arraysPackedParam));
12187 }
12188
12189 return CallCapture(angle::EntryPoint::GLDeleteVertexArraysOES, std::move(paramBuffer));
12190 }
12191
CaptureGenVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,VertexArrayID * arraysPacked)12192 CallCapture CaptureGenVertexArraysOES(const State &glState,
12193 bool isCallValid,
12194 GLsizei n,
12195 VertexArrayID *arraysPacked)
12196 {
12197 ParamBuffer paramBuffer;
12198
12199 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
12200
12201 if (isCallValid)
12202 {
12203 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
12204 InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
12205 CaptureGenVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
12206 &arraysPackedParam);
12207 paramBuffer.addParam(std::move(arraysPackedParam));
12208 }
12209 else
12210 {
12211 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
12212 InitParamValue(ParamType::TVertexArrayIDPointer, static_cast<VertexArrayID *>(nullptr),
12213 &arraysPackedParam.value);
12214 paramBuffer.addParam(std::move(arraysPackedParam));
12215 }
12216
12217 return CallCapture(angle::EntryPoint::GLGenVertexArraysOES, std::move(paramBuffer));
12218 }
12219
CaptureIsVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked,GLboolean returnValue)12220 CallCapture CaptureIsVertexArrayOES(const State &glState,
12221 bool isCallValid,
12222 VertexArrayID arrayPacked,
12223 GLboolean returnValue)
12224 {
12225 ParamBuffer paramBuffer;
12226
12227 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
12228
12229 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
12230 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
12231 paramBuffer.addReturnValue(std::move(returnValueCapture));
12232
12233 return CallCapture(angle::EntryPoint::GLIsVertexArrayOES, std::move(paramBuffer));
12234 }
12235
CaptureFramebufferTextureMultiviewOVR(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level,GLint baseViewIndex,GLsizei numViews)12236 CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
12237 bool isCallValid,
12238 GLenum target,
12239 GLenum attachment,
12240 TextureID texturePacked,
12241 GLint level,
12242 GLint baseViewIndex,
12243 GLsizei numViews)
12244 {
12245 ParamBuffer paramBuffer;
12246
12247 paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target);
12248 paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum,
12249 attachment);
12250 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
12251 paramBuffer.addValueParam("level", ParamType::TGLint, level);
12252 paramBuffer.addValueParam("baseViewIndex", ParamType::TGLint, baseViewIndex);
12253 paramBuffer.addValueParam("numViews", ParamType::TGLsizei, numViews);
12254
12255 return CallCapture(angle::EntryPoint::GLFramebufferTextureMultiviewOVR, std::move(paramBuffer));
12256 }
12257
CaptureFramebufferFoveationConfigQCOM(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLuint numLayers,GLuint focalPointsPerLayer,GLuint requestedFeatures,GLuint * providedFeatures)12258 CallCapture CaptureFramebufferFoveationConfigQCOM(const State &glState,
12259 bool isCallValid,
12260 FramebufferID framebufferPacked,
12261 GLuint numLayers,
12262 GLuint focalPointsPerLayer,
12263 GLuint requestedFeatures,
12264 GLuint *providedFeatures)
12265 {
12266 ParamBuffer paramBuffer;
12267
12268 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
12269 paramBuffer.addValueParam("numLayers", ParamType::TGLuint, numLayers);
12270 paramBuffer.addValueParam("focalPointsPerLayer", ParamType::TGLuint, focalPointsPerLayer);
12271 paramBuffer.addValueParam("requestedFeatures", ParamType::TGLuint, requestedFeatures);
12272
12273 if (isCallValid)
12274 {
12275 ParamCapture providedFeaturesParam("providedFeatures", ParamType::TGLuintPointer);
12276 InitParamValue(ParamType::TGLuintPointer, providedFeatures, &providedFeaturesParam.value);
12277 CaptureFramebufferFoveationConfigQCOM_providedFeatures(
12278 glState, isCallValid, framebufferPacked, numLayers, focalPointsPerLayer,
12279 requestedFeatures, providedFeatures, &providedFeaturesParam);
12280 paramBuffer.addParam(std::move(providedFeaturesParam));
12281 }
12282 else
12283 {
12284 ParamCapture providedFeaturesParam("providedFeatures", ParamType::TGLuintPointer);
12285 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
12286 &providedFeaturesParam.value);
12287 paramBuffer.addParam(std::move(providedFeaturesParam));
12288 }
12289
12290 return CallCapture(angle::EntryPoint::GLFramebufferFoveationConfigQCOM, std::move(paramBuffer));
12291 }
12292
CaptureFramebufferFoveationParametersQCOM(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLuint layer,GLuint focalPoint,GLfloat focalX,GLfloat focalY,GLfloat gainX,GLfloat gainY,GLfloat foveaArea)12293 CallCapture CaptureFramebufferFoveationParametersQCOM(const State &glState,
12294 bool isCallValid,
12295 FramebufferID framebufferPacked,
12296 GLuint layer,
12297 GLuint focalPoint,
12298 GLfloat focalX,
12299 GLfloat focalY,
12300 GLfloat gainX,
12301 GLfloat gainY,
12302 GLfloat foveaArea)
12303 {
12304 ParamBuffer paramBuffer;
12305
12306 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
12307 paramBuffer.addValueParam("layer", ParamType::TGLuint, layer);
12308 paramBuffer.addValueParam("focalPoint", ParamType::TGLuint, focalPoint);
12309 paramBuffer.addValueParam("focalX", ParamType::TGLfloat, focalX);
12310 paramBuffer.addValueParam("focalY", ParamType::TGLfloat, focalY);
12311 paramBuffer.addValueParam("gainX", ParamType::TGLfloat, gainX);
12312 paramBuffer.addValueParam("gainY", ParamType::TGLfloat, gainY);
12313 paramBuffer.addValueParam("foveaArea", ParamType::TGLfloat, foveaArea);
12314
12315 return CallCapture(angle::EntryPoint::GLFramebufferFoveationParametersQCOM,
12316 std::move(paramBuffer));
12317 }
12318
CaptureShadingRateQCOM(const State & glState,bool isCallValid,GLenum rate)12319 CallCapture CaptureShadingRateQCOM(const State &glState, bool isCallValid, GLenum rate)
12320 {
12321 ParamBuffer paramBuffer;
12322
12323 paramBuffer.addEnumParam("rate", GLESEnum::ShadingRateQCOM, ParamType::TGLenum, rate);
12324
12325 return CallCapture(angle::EntryPoint::GLShadingRateQCOM, std::move(paramBuffer));
12326 }
12327
CaptureTextureFoveationParametersQCOM(const State & glState,bool isCallValid,TextureID texturePacked,GLuint layer,GLuint focalPoint,GLfloat focalX,GLfloat focalY,GLfloat gainX,GLfloat gainY,GLfloat foveaArea)12328 CallCapture CaptureTextureFoveationParametersQCOM(const State &glState,
12329 bool isCallValid,
12330 TextureID texturePacked,
12331 GLuint layer,
12332 GLuint focalPoint,
12333 GLfloat focalX,
12334 GLfloat focalY,
12335 GLfloat gainX,
12336 GLfloat gainY,
12337 GLfloat foveaArea)
12338 {
12339 ParamBuffer paramBuffer;
12340
12341 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
12342 paramBuffer.addValueParam("layer", ParamType::TGLuint, layer);
12343 paramBuffer.addValueParam("focalPoint", ParamType::TGLuint, focalPoint);
12344 paramBuffer.addValueParam("focalX", ParamType::TGLfloat, focalX);
12345 paramBuffer.addValueParam("focalY", ParamType::TGLfloat, focalY);
12346 paramBuffer.addValueParam("gainX", ParamType::TGLfloat, gainX);
12347 paramBuffer.addValueParam("gainY", ParamType::TGLfloat, gainY);
12348 paramBuffer.addValueParam("foveaArea", ParamType::TGLfloat, foveaArea);
12349
12350 return CallCapture(angle::EntryPoint::GLTextureFoveationParametersQCOM, std::move(paramBuffer));
12351 }
12352
CaptureEndTilingQCOM(const State & glState,bool isCallValid,GLbitfield preserveMask)12353 CallCapture CaptureEndTilingQCOM(const State &glState, bool isCallValid, GLbitfield preserveMask)
12354 {
12355 ParamBuffer paramBuffer;
12356
12357 paramBuffer.addEnumParam("preserveMask", GLESEnum::BufferBitQCOM, ParamType::TGLbitfield,
12358 preserveMask);
12359
12360 return CallCapture(angle::EntryPoint::GLEndTilingQCOM, std::move(paramBuffer));
12361 }
12362
CaptureStartTilingQCOM(const State & glState,bool isCallValid,GLuint x,GLuint y,GLuint width,GLuint height,GLbitfield preserveMask)12363 CallCapture CaptureStartTilingQCOM(const State &glState,
12364 bool isCallValid,
12365 GLuint x,
12366 GLuint y,
12367 GLuint width,
12368 GLuint height,
12369 GLbitfield preserveMask)
12370 {
12371 ParamBuffer paramBuffer;
12372
12373 paramBuffer.addValueParam("x", ParamType::TGLuint, x);
12374 paramBuffer.addValueParam("y", ParamType::TGLuint, y);
12375 paramBuffer.addValueParam("width", ParamType::TGLuint, width);
12376 paramBuffer.addValueParam("height", ParamType::TGLuint, height);
12377 paramBuffer.addEnumParam("preserveMask", GLESEnum::BufferBitQCOM, ParamType::TGLbitfield,
12378 preserveMask);
12379
12380 return CallCapture(angle::EntryPoint::GLStartTilingQCOM, std::move(paramBuffer));
12381 }
12382
12383 } // namespace gl
12384