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_gles_ext_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/FrameCapture.h"
15 #include "libANGLE/gl_enum_utils.h"
16 #include "libANGLE/validationESEXT.h"
17
18 using namespace angle;
19
20 namespace gl
21 {
22
CaptureDrawArraysInstancedBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei instanceCount,GLuint baseInstance)23 CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const State &glState,
24 bool isCallValid,
25 PrimitiveMode modePacked,
26 GLint first,
27 GLsizei count,
28 GLsizei instanceCount,
29 GLuint baseInstance)
30 {
31 ParamBuffer paramBuffer;
32
33 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
34 paramBuffer.addValueParam("first", ParamType::TGLint, first);
35 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
36 paramBuffer.addValueParam("instanceCount", ParamType::TGLsizei, instanceCount);
37 paramBuffer.addValueParam("baseInstance", ParamType::TGLuint, baseInstance);
38
39 return CallCapture(gl::EntryPoint::DrawArraysInstancedBaseInstanceANGLE,
40 std::move(paramBuffer));
41 }
42
CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const GLvoid * indices,GLsizei instanceCounts,GLint baseVertex,GLuint baseInstance)43 CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(const State &glState,
44 bool isCallValid,
45 PrimitiveMode modePacked,
46 GLsizei count,
47 DrawElementsType typePacked,
48 const GLvoid *indices,
49 GLsizei instanceCounts,
50 GLint baseVertex,
51 GLuint baseInstance)
52 {
53 ParamBuffer paramBuffer;
54
55 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
56 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
57 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
58
59 if (isCallValid)
60 {
61 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointer);
62 InitParamValue(ParamType::TGLvoidConstPointer, indices, &indicesParam.value);
63 CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
64 glState, isCallValid, modePacked, count, typePacked, indices, instanceCounts,
65 baseVertex, baseInstance, &indicesParam);
66 paramBuffer.addParam(std::move(indicesParam));
67 }
68 else
69 {
70 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointer);
71 InitParamValue(ParamType::TGLvoidConstPointer, static_cast<const GLvoid *>(nullptr),
72 &indicesParam.value);
73 paramBuffer.addParam(std::move(indicesParam));
74 }
75
76 paramBuffer.addValueParam("instanceCounts", ParamType::TGLsizei, instanceCounts);
77 paramBuffer.addValueParam("baseVertex", ParamType::TGLint, baseVertex);
78 paramBuffer.addValueParam("baseInstance", ParamType::TGLuint, baseInstance);
79
80 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertexBaseInstanceANGLE,
81 std::move(paramBuffer));
82 }
83
CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)84 CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState,
85 bool isCallValid,
86 PrimitiveMode modePacked,
87 const GLint *firsts,
88 const GLsizei *counts,
89 const GLsizei *instanceCounts,
90 const GLuint *baseInstances,
91 GLsizei drawcount)
92 {
93 ParamBuffer paramBuffer;
94
95 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
96
97 if (isCallValid)
98 {
99 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
100 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
101 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(
102 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
103 drawcount, &firstsParam);
104 paramBuffer.addParam(std::move(firstsParam));
105 }
106 else
107 {
108 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
109 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
110 &firstsParam.value);
111 paramBuffer.addParam(std::move(firstsParam));
112 }
113
114 if (isCallValid)
115 {
116 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
117 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
118 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(
119 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
120 drawcount, &countsParam);
121 paramBuffer.addParam(std::move(countsParam));
122 }
123 else
124 {
125 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
126 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
127 &countsParam.value);
128 paramBuffer.addParam(std::move(countsParam));
129 }
130
131 if (isCallValid)
132 {
133 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
134 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
135 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
136 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
137 drawcount, &instanceCountsParam);
138 paramBuffer.addParam(std::move(instanceCountsParam));
139 }
140 else
141 {
142 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
143 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
144 &instanceCountsParam.value);
145 paramBuffer.addParam(std::move(instanceCountsParam));
146 }
147
148 if (isCallValid)
149 {
150 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
151 InitParamValue(ParamType::TGLuintConstPointer, baseInstances, &baseInstancesParam.value);
152 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
153 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances,
154 drawcount, &baseInstancesParam);
155 paramBuffer.addParam(std::move(baseInstancesParam));
156 }
157 else
158 {
159 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
160 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
161 &baseInstancesParam.value);
162 paramBuffer.addParam(std::move(baseInstancesParam));
163 }
164
165 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
166
167 return CallCapture(gl::EntryPoint::MultiDrawArraysInstancedBaseInstanceANGLE,
168 std::move(paramBuffer));
169 }
170
CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const GLvoid * const * indices,const GLsizei * instanceCounts,const GLint * baseVertices,const GLuint * baseInstances,GLsizei drawcount)171 CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
172 const State &glState,
173 bool isCallValid,
174 PrimitiveMode modePacked,
175 const GLsizei *counts,
176 DrawElementsType typePacked,
177 const GLvoid *const *indices,
178 const GLsizei *instanceCounts,
179 const GLint *baseVertices,
180 const GLuint *baseInstances,
181 GLsizei drawcount)
182 {
183 ParamBuffer paramBuffer;
184
185 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
186
187 if (isCallValid)
188 {
189 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
190 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
191 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
192 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
193 baseVertices, baseInstances, drawcount, &countsParam);
194 paramBuffer.addParam(std::move(countsParam));
195 }
196 else
197 {
198 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
199 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
200 &countsParam.value);
201 paramBuffer.addParam(std::move(countsParam));
202 }
203
204 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
205
206 if (isCallValid)
207 {
208 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
209 InitParamValue(ParamType::TGLvoidConstPointerPointer, indices, &indicesParam.value);
210 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
211 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
212 baseVertices, baseInstances, drawcount, &indicesParam);
213 paramBuffer.addParam(std::move(indicesParam));
214 }
215 else
216 {
217 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
218 InitParamValue(ParamType::TGLvoidConstPointerPointer,
219 static_cast<const GLvoid *const *>(nullptr), &indicesParam.value);
220 paramBuffer.addParam(std::move(indicesParam));
221 }
222
223 if (isCallValid)
224 {
225 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
226 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
227 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
228 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
229 baseVertices, baseInstances, drawcount, &instanceCountsParam);
230 paramBuffer.addParam(std::move(instanceCountsParam));
231 }
232 else
233 {
234 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
235 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
236 &instanceCountsParam.value);
237 paramBuffer.addParam(std::move(instanceCountsParam));
238 }
239
240 if (isCallValid)
241 {
242 ParamCapture baseVerticesParam("baseVertices", ParamType::TGLintConstPointer);
243 InitParamValue(ParamType::TGLintConstPointer, baseVertices, &baseVerticesParam.value);
244 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
245 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
246 baseVertices, baseInstances, drawcount, &baseVerticesParam);
247 paramBuffer.addParam(std::move(baseVerticesParam));
248 }
249 else
250 {
251 ParamCapture baseVerticesParam("baseVertices", ParamType::TGLintConstPointer);
252 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
253 &baseVerticesParam.value);
254 paramBuffer.addParam(std::move(baseVerticesParam));
255 }
256
257 if (isCallValid)
258 {
259 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
260 InitParamValue(ParamType::TGLuintConstPointer, baseInstances, &baseInstancesParam.value);
261 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
262 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
263 baseVertices, baseInstances, drawcount, &baseInstancesParam);
264 paramBuffer.addParam(std::move(baseInstancesParam));
265 }
266 else
267 {
268 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
269 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
270 &baseInstancesParam.value);
271 paramBuffer.addParam(std::move(baseInstancesParam));
272 }
273
274 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
275
276 return CallCapture(gl::EntryPoint::MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
277 std::move(paramBuffer));
278 }
279
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)280 CallCapture CaptureCopyTexture3DANGLE(const State &glState,
281 bool isCallValid,
282 TextureID sourceIdPacked,
283 GLint sourceLevel,
284 TextureTarget destTargetPacked,
285 TextureID destIdPacked,
286 GLint destLevel,
287 GLint internalFormat,
288 GLenum destType,
289 GLboolean unpackFlipY,
290 GLboolean unpackPremultiplyAlpha,
291 GLboolean unpackUnmultiplyAlpha)
292 {
293 ParamBuffer paramBuffer;
294
295 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
296 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
297 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
298 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
299 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
300 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
301 paramBuffer.addEnumParam("destType", GLenumGroup::DefaultGroup, ParamType::TGLenum, destType);
302 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
303 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
304 unpackPremultiplyAlpha);
305 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
306 unpackUnmultiplyAlpha);
307
308 return CallCapture(gl::EntryPoint::CopyTexture3DANGLE, std::move(paramBuffer));
309 }
310
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)311 CallCapture CaptureCopySubTexture3DANGLE(const State &glState,
312 bool isCallValid,
313 TextureID sourceIdPacked,
314 GLint sourceLevel,
315 TextureTarget destTargetPacked,
316 TextureID destIdPacked,
317 GLint destLevel,
318 GLint xoffset,
319 GLint yoffset,
320 GLint zoffset,
321 GLint x,
322 GLint y,
323 GLint z,
324 GLint width,
325 GLint height,
326 GLint depth,
327 GLboolean unpackFlipY,
328 GLboolean unpackPremultiplyAlpha,
329 GLboolean unpackUnmultiplyAlpha)
330 {
331 ParamBuffer paramBuffer;
332
333 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
334 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
335 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
336 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
337 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
338 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
339 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
340 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
341 paramBuffer.addValueParam("x", ParamType::TGLint, x);
342 paramBuffer.addValueParam("y", ParamType::TGLint, y);
343 paramBuffer.addValueParam("z", ParamType::TGLint, z);
344 paramBuffer.addValueParam("width", ParamType::TGLint, width);
345 paramBuffer.addValueParam("height", ParamType::TGLint, height);
346 paramBuffer.addValueParam("depth", ParamType::TGLint, depth);
347 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
348 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
349 unpackPremultiplyAlpha);
350 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
351 unpackUnmultiplyAlpha);
352
353 return CallCapture(gl::EntryPoint::CopySubTexture3DANGLE, std::move(paramBuffer));
354 }
355
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)356 CallCapture CaptureBlitFramebufferANGLE(const State &glState,
357 bool isCallValid,
358 GLint srcX0,
359 GLint srcY0,
360 GLint srcX1,
361 GLint srcY1,
362 GLint dstX0,
363 GLint dstY0,
364 GLint dstX1,
365 GLint dstY1,
366 GLbitfield mask,
367 GLenum filter)
368 {
369 ParamBuffer paramBuffer;
370
371 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
372 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
373 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
374 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
375 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
376 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
377 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
378 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
379 paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask);
380 paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum,
381 filter);
382
383 return CallCapture(gl::EntryPoint::BlitFramebufferANGLE, std::move(paramBuffer));
384 }
385
CaptureRenderbufferStorageMultisampleANGLE(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)386 CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
387 bool isCallValid,
388 GLenum target,
389 GLsizei samples,
390 GLenum internalformat,
391 GLsizei width,
392 GLsizei height)
393 {
394 ParamBuffer paramBuffer;
395
396 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
397 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
398 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
399 internalformat);
400 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
401 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
402
403 return CallCapture(gl::EntryPoint::RenderbufferStorageMultisampleANGLE, std::move(paramBuffer));
404 }
405
CaptureGetTexImageANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum format,GLenum type,void * pixels)406 CallCapture CaptureGetTexImageANGLE(const State &glState,
407 bool isCallValid,
408 TextureTarget targetPacked,
409 GLint level,
410 GLenum format,
411 GLenum type,
412 void *pixels)
413 {
414 ParamBuffer paramBuffer;
415
416 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
417 paramBuffer.addValueParam("level", ParamType::TGLint, level);
418 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
419 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
420
421 if (isCallValid)
422 {
423 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
424 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
425 CaptureGetTexImageANGLE_pixels(glState, isCallValid, targetPacked, level, format, type,
426 pixels, &pixelsParam);
427 paramBuffer.addParam(std::move(pixelsParam));
428 }
429 else
430 {
431 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
432 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
433 paramBuffer.addParam(std::move(pixelsParam));
434 }
435
436 return CallCapture(gl::EntryPoint::GetTexImageANGLE, std::move(paramBuffer));
437 }
438
CaptureGetRenderbufferImageANGLE(const State & glState,bool isCallValid,GLenum target,GLenum format,GLenum type,void * pixels)439 CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
440 bool isCallValid,
441 GLenum target,
442 GLenum format,
443 GLenum type,
444 void *pixels)
445 {
446 ParamBuffer paramBuffer;
447
448 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
449 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
450 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
451
452 if (isCallValid)
453 {
454 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
455 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
456 CaptureGetRenderbufferImageANGLE_pixels(glState, isCallValid, target, format, type, pixels,
457 &pixelsParam);
458 paramBuffer.addParam(std::move(pixelsParam));
459 }
460 else
461 {
462 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
463 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
464 paramBuffer.addParam(std::move(pixelsParam));
465 }
466
467 return CallCapture(gl::EntryPoint::GetRenderbufferImageANGLE, std::move(paramBuffer));
468 }
469
CaptureGetTexLevelParameterivANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLint * params)470 CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
471 bool isCallValid,
472 TextureTarget targetPacked,
473 GLint level,
474 GLenum pname,
475 GLint *params)
476 {
477 ParamBuffer paramBuffer;
478
479 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
480 paramBuffer.addValueParam("level", ParamType::TGLint, level);
481 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
482
483 if (isCallValid)
484 {
485 ParamCapture paramsParam("params", ParamType::TGLintPointer);
486 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
487 CaptureGetTexLevelParameterivANGLE_params(glState, isCallValid, targetPacked, level, pname,
488 params, ¶msParam);
489 paramBuffer.addParam(std::move(paramsParam));
490 }
491 else
492 {
493 ParamCapture paramsParam("params", ParamType::TGLintPointer);
494 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
495 paramBuffer.addParam(std::move(paramsParam));
496 }
497
498 return CallCapture(gl::EntryPoint::GetTexLevelParameterivANGLE, std::move(paramBuffer));
499 }
500
CaptureGetTexLevelParameterfvANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLfloat * params)501 CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
502 bool isCallValid,
503 TextureTarget targetPacked,
504 GLint level,
505 GLenum pname,
506 GLfloat *params)
507 {
508 ParamBuffer paramBuffer;
509
510 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
511 paramBuffer.addValueParam("level", ParamType::TGLint, level);
512 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
513
514 if (isCallValid)
515 {
516 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
517 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
518 CaptureGetTexLevelParameterfvANGLE_params(glState, isCallValid, targetPacked, level, pname,
519 params, ¶msParam);
520 paramBuffer.addParam(std::move(paramsParam));
521 }
522 else
523 {
524 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
525 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
526 ¶msParam.value);
527 paramBuffer.addParam(std::move(paramsParam));
528 }
529
530 return CallCapture(gl::EntryPoint::GetTexLevelParameterfvANGLE, std::move(paramBuffer));
531 }
532
CaptureDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei primcount)533 CallCapture CaptureDrawArraysInstancedANGLE(const State &glState,
534 bool isCallValid,
535 PrimitiveMode modePacked,
536 GLint first,
537 GLsizei count,
538 GLsizei primcount)
539 {
540 ParamBuffer paramBuffer;
541
542 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
543 paramBuffer.addValueParam("first", ParamType::TGLint, first);
544 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
545 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
546
547 return CallCapture(gl::EntryPoint::DrawArraysInstancedANGLE, std::move(paramBuffer));
548 }
549
CaptureDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)550 CallCapture CaptureDrawElementsInstancedANGLE(const State &glState,
551 bool isCallValid,
552 PrimitiveMode modePacked,
553 GLsizei count,
554 DrawElementsType typePacked,
555 const void *indices,
556 GLsizei primcount)
557 {
558 ParamBuffer paramBuffer;
559
560 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
561 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
562 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
563
564 if (isCallValid)
565 {
566 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
567 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
568 CaptureDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, count,
569 typePacked, indices, primcount, &indicesParam);
570 paramBuffer.addParam(std::move(indicesParam));
571 }
572 else
573 {
574 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
575 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
576 &indicesParam.value);
577 paramBuffer.addParam(std::move(indicesParam));
578 }
579
580 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
581
582 return CallCapture(gl::EntryPoint::DrawElementsInstancedANGLE, std::move(paramBuffer));
583 }
584
CaptureVertexAttribDivisorANGLE(const State & glState,bool isCallValid,GLuint index,GLuint divisor)585 CallCapture CaptureVertexAttribDivisorANGLE(const State &glState,
586 bool isCallValid,
587 GLuint index,
588 GLuint divisor)
589 {
590 ParamBuffer paramBuffer;
591
592 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
593 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
594
595 return CallCapture(gl::EntryPoint::VertexAttribDivisorANGLE, std::move(paramBuffer));
596 }
597
CaptureTexStorageMemFlags2DANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,MemoryObjectID memoryPacked,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags)598 CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState,
599 bool isCallValid,
600 TextureType targetPacked,
601 GLsizei levels,
602 GLenum internalFormat,
603 GLsizei width,
604 GLsizei height,
605 MemoryObjectID memoryPacked,
606 GLuint64 offset,
607 GLbitfield createFlags,
608 GLbitfield usageFlags)
609 {
610 ParamBuffer paramBuffer;
611
612 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
613 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
614 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
615 internalFormat);
616 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
617 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
618 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
619 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
620 paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
621 createFlags);
622 paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
623 usageFlags);
624
625 return CallCapture(gl::EntryPoint::TexStorageMemFlags2DANGLE, std::move(paramBuffer));
626 }
627
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)628 CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState,
629 bool isCallValid,
630 TextureType targetPacked,
631 GLsizei samples,
632 GLenum internalFormat,
633 GLsizei width,
634 GLsizei height,
635 GLboolean fixedSampleLocations,
636 MemoryObjectID memoryPacked,
637 GLuint64 offset,
638 GLbitfield createFlags,
639 GLbitfield usageFlags)
640 {
641 ParamBuffer paramBuffer;
642
643 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
644 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
645 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
646 internalFormat);
647 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
648 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
649 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
650 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
651 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
652 paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
653 createFlags);
654 paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
655 usageFlags);
656
657 return CallCapture(gl::EntryPoint::TexStorageMemFlags2DMultisampleANGLE,
658 std::move(paramBuffer));
659 }
660
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)661 CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState,
662 bool isCallValid,
663 TextureType targetPacked,
664 GLsizei levels,
665 GLenum internalFormat,
666 GLsizei width,
667 GLsizei height,
668 GLsizei depth,
669 MemoryObjectID memoryPacked,
670 GLuint64 offset,
671 GLbitfield createFlags,
672 GLbitfield usageFlags)
673 {
674 ParamBuffer paramBuffer;
675
676 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
677 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
678 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
679 internalFormat);
680 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
681 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
682 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
683 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
684 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
685 paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
686 createFlags);
687 paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
688 usageFlags);
689
690 return CallCapture(gl::EntryPoint::TexStorageMemFlags3DANGLE, std::move(paramBuffer));
691 }
692
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)693 CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState,
694 bool isCallValid,
695 TextureType targetPacked,
696 GLsizei samples,
697 GLenum internalFormat,
698 GLsizei width,
699 GLsizei height,
700 GLsizei depth,
701 GLboolean fixedSampleLocations,
702 MemoryObjectID memoryPacked,
703 GLuint64 offset,
704 GLbitfield createFlags,
705 GLbitfield usageFlags)
706 {
707 ParamBuffer paramBuffer;
708
709 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
710 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
711 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
712 internalFormat);
713 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
714 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
715 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
716 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
717 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
718 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
719 paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
720 createFlags);
721 paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield,
722 usageFlags);
723
724 return CallCapture(gl::EntryPoint::TexStorageMemFlags3DMultisampleANGLE,
725 std::move(paramBuffer));
726 }
727
CaptureImportMemoryZirconHandleANGLE(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLuint handle)728 CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
729 bool isCallValid,
730 MemoryObjectID memoryPacked,
731 GLuint64 size,
732 HandleType handleTypePacked,
733 GLuint handle)
734 {
735 ParamBuffer paramBuffer;
736
737 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
738 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
739 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
740 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
741
742 return CallCapture(gl::EntryPoint::ImportMemoryZirconHandleANGLE, std::move(paramBuffer));
743 }
744
CaptureMultiDrawArraysANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)745 CallCapture CaptureMultiDrawArraysANGLE(const State &glState,
746 bool isCallValid,
747 PrimitiveMode modePacked,
748 const GLint *firsts,
749 const GLsizei *counts,
750 GLsizei drawcount)
751 {
752 ParamBuffer paramBuffer;
753
754 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
755
756 if (isCallValid)
757 {
758 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
759 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
760 CaptureMultiDrawArraysANGLE_firsts(glState, isCallValid, modePacked, firsts, counts,
761 drawcount, &firstsParam);
762 paramBuffer.addParam(std::move(firstsParam));
763 }
764 else
765 {
766 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
767 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
768 &firstsParam.value);
769 paramBuffer.addParam(std::move(firstsParam));
770 }
771
772 if (isCallValid)
773 {
774 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
775 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
776 CaptureMultiDrawArraysANGLE_counts(glState, isCallValid, modePacked, firsts, counts,
777 drawcount, &countsParam);
778 paramBuffer.addParam(std::move(countsParam));
779 }
780 else
781 {
782 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
783 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
784 &countsParam.value);
785 paramBuffer.addParam(std::move(countsParam));
786 }
787
788 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
789
790 return CallCapture(gl::EntryPoint::MultiDrawArraysANGLE, std::move(paramBuffer));
791 }
792
CaptureMultiDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)793 CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState,
794 bool isCallValid,
795 PrimitiveMode modePacked,
796 const GLint *firsts,
797 const GLsizei *counts,
798 const GLsizei *instanceCounts,
799 GLsizei drawcount)
800 {
801 ParamBuffer paramBuffer;
802
803 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
804
805 if (isCallValid)
806 {
807 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
808 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
809 CaptureMultiDrawArraysInstancedANGLE_firsts(glState, isCallValid, modePacked, firsts,
810 counts, instanceCounts, drawcount,
811 &firstsParam);
812 paramBuffer.addParam(std::move(firstsParam));
813 }
814 else
815 {
816 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
817 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
818 &firstsParam.value);
819 paramBuffer.addParam(std::move(firstsParam));
820 }
821
822 if (isCallValid)
823 {
824 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
825 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
826 CaptureMultiDrawArraysInstancedANGLE_counts(glState, isCallValid, modePacked, firsts,
827 counts, instanceCounts, drawcount,
828 &countsParam);
829 paramBuffer.addParam(std::move(countsParam));
830 }
831 else
832 {
833 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
834 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
835 &countsParam.value);
836 paramBuffer.addParam(std::move(countsParam));
837 }
838
839 if (isCallValid)
840 {
841 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
842 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
843 CaptureMultiDrawArraysInstancedANGLE_instanceCounts(glState, isCallValid, modePacked,
844 firsts, counts, instanceCounts,
845 drawcount, &instanceCountsParam);
846 paramBuffer.addParam(std::move(instanceCountsParam));
847 }
848 else
849 {
850 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
851 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
852 &instanceCountsParam.value);
853 paramBuffer.addParam(std::move(instanceCountsParam));
854 }
855
856 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
857
858 return CallCapture(gl::EntryPoint::MultiDrawArraysInstancedANGLE, std::move(paramBuffer));
859 }
860
CaptureMultiDrawElementsANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const GLvoid * const * indices,GLsizei drawcount)861 CallCapture CaptureMultiDrawElementsANGLE(const State &glState,
862 bool isCallValid,
863 PrimitiveMode modePacked,
864 const GLsizei *counts,
865 DrawElementsType typePacked,
866 const GLvoid *const *indices,
867 GLsizei drawcount)
868 {
869 ParamBuffer paramBuffer;
870
871 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
872
873 if (isCallValid)
874 {
875 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
876 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
877 CaptureMultiDrawElementsANGLE_counts(glState, isCallValid, modePacked, counts, typePacked,
878 indices, drawcount, &countsParam);
879 paramBuffer.addParam(std::move(countsParam));
880 }
881 else
882 {
883 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
884 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
885 &countsParam.value);
886 paramBuffer.addParam(std::move(countsParam));
887 }
888
889 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
890
891 if (isCallValid)
892 {
893 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
894 InitParamValue(ParamType::TGLvoidConstPointerPointer, indices, &indicesParam.value);
895 CaptureMultiDrawElementsANGLE_indices(glState, isCallValid, modePacked, counts, typePacked,
896 indices, drawcount, &indicesParam);
897 paramBuffer.addParam(std::move(indicesParam));
898 }
899 else
900 {
901 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
902 InitParamValue(ParamType::TGLvoidConstPointerPointer,
903 static_cast<const GLvoid *const *>(nullptr), &indicesParam.value);
904 paramBuffer.addParam(std::move(indicesParam));
905 }
906
907 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
908
909 return CallCapture(gl::EntryPoint::MultiDrawElementsANGLE, std::move(paramBuffer));
910 }
911
CaptureMultiDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const GLvoid * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)912 CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
913 bool isCallValid,
914 PrimitiveMode modePacked,
915 const GLsizei *counts,
916 DrawElementsType typePacked,
917 const GLvoid *const *indices,
918 const GLsizei *instanceCounts,
919 GLsizei drawcount)
920 {
921 ParamBuffer paramBuffer;
922
923 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
924
925 if (isCallValid)
926 {
927 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
928 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
929 CaptureMultiDrawElementsInstancedANGLE_counts(glState, isCallValid, modePacked, counts,
930 typePacked, indices, instanceCounts,
931 drawcount, &countsParam);
932 paramBuffer.addParam(std::move(countsParam));
933 }
934 else
935 {
936 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
937 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
938 &countsParam.value);
939 paramBuffer.addParam(std::move(countsParam));
940 }
941
942 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
943
944 if (isCallValid)
945 {
946 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
947 InitParamValue(ParamType::TGLvoidConstPointerPointer, indices, &indicesParam.value);
948 CaptureMultiDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, counts,
949 typePacked, indices, instanceCounts,
950 drawcount, &indicesParam);
951 paramBuffer.addParam(std::move(indicesParam));
952 }
953 else
954 {
955 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
956 InitParamValue(ParamType::TGLvoidConstPointerPointer,
957 static_cast<const GLvoid *const *>(nullptr), &indicesParam.value);
958 paramBuffer.addParam(std::move(indicesParam));
959 }
960
961 if (isCallValid)
962 {
963 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
964 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
965 CaptureMultiDrawElementsInstancedANGLE_instanceCounts(
966 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts,
967 drawcount, &instanceCountsParam);
968 paramBuffer.addParam(std::move(instanceCountsParam));
969 }
970 else
971 {
972 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
973 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
974 &instanceCountsParam.value);
975 paramBuffer.addParam(std::move(instanceCountsParam));
976 }
977
978 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
979
980 return CallCapture(gl::EntryPoint::MultiDrawElementsInstancedANGLE, std::move(paramBuffer));
981 }
982
CaptureProvokingVertexANGLE(const State & glState,bool isCallValid,ProvokingVertexConvention modePacked)983 CallCapture CaptureProvokingVertexANGLE(const State &glState,
984 bool isCallValid,
985 ProvokingVertexConvention modePacked)
986 {
987 ParamBuffer paramBuffer;
988
989 paramBuffer.addValueParam("modePacked", ParamType::TProvokingVertexConvention, modePacked);
990
991 return CallCapture(gl::EntryPoint::ProvokingVertexANGLE, std::move(paramBuffer));
992 }
993
CaptureRequestExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)994 CallCapture CaptureRequestExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
995 {
996 ParamBuffer paramBuffer;
997
998 if (isCallValid)
999 {
1000 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1001 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
1002 CaptureRequestExtensionANGLE_name(glState, isCallValid, name, &nameParam);
1003 paramBuffer.addParam(std::move(nameParam));
1004 }
1005 else
1006 {
1007 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1008 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
1009 &nameParam.value);
1010 paramBuffer.addParam(std::move(nameParam));
1011 }
1012
1013 return CallCapture(gl::EntryPoint::RequestExtensionANGLE, std::move(paramBuffer));
1014 }
1015
CaptureDisableExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)1016 CallCapture CaptureDisableExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
1017 {
1018 ParamBuffer paramBuffer;
1019
1020 if (isCallValid)
1021 {
1022 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1023 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
1024 CaptureDisableExtensionANGLE_name(glState, isCallValid, name, &nameParam);
1025 paramBuffer.addParam(std::move(nameParam));
1026 }
1027 else
1028 {
1029 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
1030 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
1031 &nameParam.value);
1032 paramBuffer.addParam(std::move(nameParam));
1033 }
1034
1035 return CallCapture(gl::EntryPoint::DisableExtensionANGLE, std::move(paramBuffer));
1036 }
1037
CaptureGetBooleanvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)1038 CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
1039 bool isCallValid,
1040 GLenum pname,
1041 GLsizei bufSize,
1042 GLsizei *length,
1043 GLboolean *params)
1044 {
1045 ParamBuffer paramBuffer;
1046
1047 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1048 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1049
1050 if (isCallValid)
1051 {
1052 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1053 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1054 CaptureGetBooleanvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
1055 &lengthParam);
1056 paramBuffer.addParam(std::move(lengthParam));
1057 }
1058 else
1059 {
1060 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1061 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1062 &lengthParam.value);
1063 paramBuffer.addParam(std::move(lengthParam));
1064 }
1065
1066 if (isCallValid)
1067 {
1068 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
1069 InitParamValue(ParamType::TGLbooleanPointer, params, ¶msParam.value);
1070 CaptureGetBooleanvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
1071 ¶msParam);
1072 paramBuffer.addParam(std::move(paramsParam));
1073 }
1074 else
1075 {
1076 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
1077 InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
1078 ¶msParam.value);
1079 paramBuffer.addParam(std::move(paramsParam));
1080 }
1081
1082 return CallCapture(gl::EntryPoint::GetBooleanvRobustANGLE, std::move(paramBuffer));
1083 }
1084
CaptureGetBufferParameterivRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1085 CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
1086 bool isCallValid,
1087 BufferBinding targetPacked,
1088 GLenum pname,
1089 GLsizei bufSize,
1090 GLsizei *length,
1091 GLint *params)
1092 {
1093 ParamBuffer paramBuffer;
1094
1095 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1096 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1097 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1098
1099 if (isCallValid)
1100 {
1101 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1102 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1103 CaptureGetBufferParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1104 bufSize, length, params, &lengthParam);
1105 paramBuffer.addParam(std::move(lengthParam));
1106 }
1107 else
1108 {
1109 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1110 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1111 &lengthParam.value);
1112 paramBuffer.addParam(std::move(lengthParam));
1113 }
1114
1115 if (isCallValid)
1116 {
1117 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1118 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1119 CaptureGetBufferParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1120 bufSize, length, params, ¶msParam);
1121 paramBuffer.addParam(std::move(paramsParam));
1122 }
1123 else
1124 {
1125 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1126 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1127 paramBuffer.addParam(std::move(paramsParam));
1128 }
1129
1130 return CallCapture(gl::EntryPoint::GetBufferParameterivRobustANGLE, std::move(paramBuffer));
1131 }
1132
CaptureGetFloatvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1133 CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
1134 bool isCallValid,
1135 GLenum pname,
1136 GLsizei bufSize,
1137 GLsizei *length,
1138 GLfloat *params)
1139 {
1140 ParamBuffer paramBuffer;
1141
1142 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1143 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1144
1145 if (isCallValid)
1146 {
1147 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1148 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1149 CaptureGetFloatvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
1150 &lengthParam);
1151 paramBuffer.addParam(std::move(lengthParam));
1152 }
1153 else
1154 {
1155 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1156 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1157 &lengthParam.value);
1158 paramBuffer.addParam(std::move(lengthParam));
1159 }
1160
1161 if (isCallValid)
1162 {
1163 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1164 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1165 CaptureGetFloatvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
1166 ¶msParam);
1167 paramBuffer.addParam(std::move(paramsParam));
1168 }
1169 else
1170 {
1171 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1172 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1173 ¶msParam.value);
1174 paramBuffer.addParam(std::move(paramsParam));
1175 }
1176
1177 return CallCapture(gl::EntryPoint::GetFloatvRobustANGLE, std::move(paramBuffer));
1178 }
1179
CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1180 CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
1181 bool isCallValid,
1182 GLenum target,
1183 GLenum attachment,
1184 GLenum pname,
1185 GLsizei bufSize,
1186 GLsizei *length,
1187 GLint *params)
1188 {
1189 ParamBuffer paramBuffer;
1190
1191 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1192 paramBuffer.addEnumParam("attachment", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1193 attachment);
1194 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1195 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1196
1197 if (isCallValid)
1198 {
1199 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1200 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1201 CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
1202 glState, isCallValid, target, attachment, pname, bufSize, length, params, &lengthParam);
1203 paramBuffer.addParam(std::move(lengthParam));
1204 }
1205 else
1206 {
1207 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1208 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1209 &lengthParam.value);
1210 paramBuffer.addParam(std::move(lengthParam));
1211 }
1212
1213 if (isCallValid)
1214 {
1215 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1216 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1217 CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
1218 glState, isCallValid, target, attachment, pname, bufSize, length, params, ¶msParam);
1219 paramBuffer.addParam(std::move(paramsParam));
1220 }
1221 else
1222 {
1223 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1224 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1225 paramBuffer.addParam(std::move(paramsParam));
1226 }
1227
1228 return CallCapture(gl::EntryPoint::GetFramebufferAttachmentParameterivRobustANGLE,
1229 std::move(paramBuffer));
1230 }
1231
CaptureGetIntegervRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)1232 CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
1233 bool isCallValid,
1234 GLenum pname,
1235 GLsizei bufSize,
1236 GLsizei *length,
1237 GLint *data)
1238 {
1239 ParamBuffer paramBuffer;
1240
1241 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1242 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1243
1244 if (isCallValid)
1245 {
1246 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1247 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1248 CaptureGetIntegervRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
1249 &lengthParam);
1250 paramBuffer.addParam(std::move(lengthParam));
1251 }
1252 else
1253 {
1254 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1255 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1256 &lengthParam.value);
1257 paramBuffer.addParam(std::move(lengthParam));
1258 }
1259
1260 if (isCallValid)
1261 {
1262 ParamCapture dataParam("data", ParamType::TGLintPointer);
1263 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
1264 CaptureGetIntegervRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
1265 &dataParam);
1266 paramBuffer.addParam(std::move(dataParam));
1267 }
1268 else
1269 {
1270 ParamCapture dataParam("data", ParamType::TGLintPointer);
1271 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
1272 paramBuffer.addParam(std::move(dataParam));
1273 }
1274
1275 return CallCapture(gl::EntryPoint::GetIntegervRobustANGLE, std::move(paramBuffer));
1276 }
1277
CaptureGetProgramivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1278 CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
1279 bool isCallValid,
1280 ShaderProgramID programPacked,
1281 GLenum pname,
1282 GLsizei bufSize,
1283 GLsizei *length,
1284 GLint *params)
1285 {
1286 ParamBuffer paramBuffer;
1287
1288 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1289 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1290 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1291
1292 if (isCallValid)
1293 {
1294 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1295 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1296 CaptureGetProgramivRobustANGLE_length(glState, isCallValid, programPacked, pname, bufSize,
1297 length, params, &lengthParam);
1298 paramBuffer.addParam(std::move(lengthParam));
1299 }
1300 else
1301 {
1302 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1303 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1304 &lengthParam.value);
1305 paramBuffer.addParam(std::move(lengthParam));
1306 }
1307
1308 if (isCallValid)
1309 {
1310 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1311 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1312 CaptureGetProgramivRobustANGLE_params(glState, isCallValid, programPacked, pname, bufSize,
1313 length, params, ¶msParam);
1314 paramBuffer.addParam(std::move(paramsParam));
1315 }
1316 else
1317 {
1318 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1319 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1320 paramBuffer.addParam(std::move(paramsParam));
1321 }
1322
1323 return CallCapture(gl::EntryPoint::GetProgramivRobustANGLE, std::move(paramBuffer));
1324 }
1325
CaptureGetRenderbufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1326 CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
1327 bool isCallValid,
1328 GLenum target,
1329 GLenum pname,
1330 GLsizei bufSize,
1331 GLsizei *length,
1332 GLint *params)
1333 {
1334 ParamBuffer paramBuffer;
1335
1336 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1337 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1338 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1339
1340 if (isCallValid)
1341 {
1342 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1343 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1344 CaptureGetRenderbufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
1345 bufSize, length, params, &lengthParam);
1346 paramBuffer.addParam(std::move(lengthParam));
1347 }
1348 else
1349 {
1350 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1351 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1352 &lengthParam.value);
1353 paramBuffer.addParam(std::move(lengthParam));
1354 }
1355
1356 if (isCallValid)
1357 {
1358 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1359 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1360 CaptureGetRenderbufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
1361 bufSize, length, params, ¶msParam);
1362 paramBuffer.addParam(std::move(paramsParam));
1363 }
1364 else
1365 {
1366 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1367 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1368 paramBuffer.addParam(std::move(paramsParam));
1369 }
1370
1371 return CallCapture(gl::EntryPoint::GetRenderbufferParameterivRobustANGLE,
1372 std::move(paramBuffer));
1373 }
1374
CaptureGetShaderivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1375 CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
1376 bool isCallValid,
1377 ShaderProgramID shaderPacked,
1378 GLenum pname,
1379 GLsizei bufSize,
1380 GLsizei *length,
1381 GLint *params)
1382 {
1383 ParamBuffer paramBuffer;
1384
1385 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
1386 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1387 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1388
1389 if (isCallValid)
1390 {
1391 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1392 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1393 CaptureGetShaderivRobustANGLE_length(glState, isCallValid, shaderPacked, pname, bufSize,
1394 length, params, &lengthParam);
1395 paramBuffer.addParam(std::move(lengthParam));
1396 }
1397 else
1398 {
1399 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1400 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1401 &lengthParam.value);
1402 paramBuffer.addParam(std::move(lengthParam));
1403 }
1404
1405 if (isCallValid)
1406 {
1407 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1408 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1409 CaptureGetShaderivRobustANGLE_params(glState, isCallValid, shaderPacked, pname, bufSize,
1410 length, params, ¶msParam);
1411 paramBuffer.addParam(std::move(paramsParam));
1412 }
1413 else
1414 {
1415 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1416 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1417 paramBuffer.addParam(std::move(paramsParam));
1418 }
1419
1420 return CallCapture(gl::EntryPoint::GetShaderivRobustANGLE, std::move(paramBuffer));
1421 }
1422
CaptureGetTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1423 CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
1424 bool isCallValid,
1425 TextureType targetPacked,
1426 GLenum pname,
1427 GLsizei bufSize,
1428 GLsizei *length,
1429 GLfloat *params)
1430 {
1431 ParamBuffer paramBuffer;
1432
1433 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1434 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1435 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1436
1437 if (isCallValid)
1438 {
1439 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1440 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1441 CaptureGetTexParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1442 bufSize, length, params, &lengthParam);
1443 paramBuffer.addParam(std::move(lengthParam));
1444 }
1445 else
1446 {
1447 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1448 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1449 &lengthParam.value);
1450 paramBuffer.addParam(std::move(lengthParam));
1451 }
1452
1453 if (isCallValid)
1454 {
1455 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1456 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1457 CaptureGetTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1458 bufSize, length, params, ¶msParam);
1459 paramBuffer.addParam(std::move(paramsParam));
1460 }
1461 else
1462 {
1463 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1464 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1465 ¶msParam.value);
1466 paramBuffer.addParam(std::move(paramsParam));
1467 }
1468
1469 return CallCapture(gl::EntryPoint::GetTexParameterfvRobustANGLE, std::move(paramBuffer));
1470 }
1471
CaptureGetTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1472 CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
1473 bool isCallValid,
1474 TextureType targetPacked,
1475 GLenum pname,
1476 GLsizei bufSize,
1477 GLsizei *length,
1478 GLint *params)
1479 {
1480 ParamBuffer paramBuffer;
1481
1482 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1483 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1484 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1485
1486 if (isCallValid)
1487 {
1488 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1489 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1490 CaptureGetTexParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1491 bufSize, length, params, &lengthParam);
1492 paramBuffer.addParam(std::move(lengthParam));
1493 }
1494 else
1495 {
1496 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1497 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1498 &lengthParam.value);
1499 paramBuffer.addParam(std::move(lengthParam));
1500 }
1501
1502 if (isCallValid)
1503 {
1504 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1505 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1506 CaptureGetTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1507 bufSize, length, params, ¶msParam);
1508 paramBuffer.addParam(std::move(paramsParam));
1509 }
1510 else
1511 {
1512 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1513 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1514 paramBuffer.addParam(std::move(paramsParam));
1515 }
1516
1517 return CallCapture(gl::EntryPoint::GetTexParameterivRobustANGLE, std::move(paramBuffer));
1518 }
1519
CaptureGetUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)1520 CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
1521 bool isCallValid,
1522 ShaderProgramID programPacked,
1523 UniformLocation locationPacked,
1524 GLsizei bufSize,
1525 GLsizei *length,
1526 GLfloat *params)
1527 {
1528 ParamBuffer paramBuffer;
1529
1530 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1531 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
1532 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1533
1534 if (isCallValid)
1535 {
1536 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1537 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1538 CaptureGetUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
1539 bufSize, length, params, &lengthParam);
1540 paramBuffer.addParam(std::move(lengthParam));
1541 }
1542 else
1543 {
1544 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1545 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1546 &lengthParam.value);
1547 paramBuffer.addParam(std::move(lengthParam));
1548 }
1549
1550 if (isCallValid)
1551 {
1552 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1553 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1554 CaptureGetUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
1555 bufSize, length, params, ¶msParam);
1556 paramBuffer.addParam(std::move(paramsParam));
1557 }
1558 else
1559 {
1560 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1561 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1562 ¶msParam.value);
1563 paramBuffer.addParam(std::move(paramsParam));
1564 }
1565
1566 return CallCapture(gl::EntryPoint::GetUniformfvRobustANGLE, std::move(paramBuffer));
1567 }
1568
CaptureGetUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)1569 CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
1570 bool isCallValid,
1571 ShaderProgramID programPacked,
1572 UniformLocation locationPacked,
1573 GLsizei bufSize,
1574 GLsizei *length,
1575 GLint *params)
1576 {
1577 ParamBuffer paramBuffer;
1578
1579 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1580 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
1581 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1582
1583 if (isCallValid)
1584 {
1585 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1586 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1587 CaptureGetUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
1588 bufSize, length, params, &lengthParam);
1589 paramBuffer.addParam(std::move(lengthParam));
1590 }
1591 else
1592 {
1593 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1594 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1595 &lengthParam.value);
1596 paramBuffer.addParam(std::move(lengthParam));
1597 }
1598
1599 if (isCallValid)
1600 {
1601 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1602 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1603 CaptureGetUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
1604 bufSize, length, params, ¶msParam);
1605 paramBuffer.addParam(std::move(paramsParam));
1606 }
1607 else
1608 {
1609 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1610 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1611 paramBuffer.addParam(std::move(paramsParam));
1612 }
1613
1614 return CallCapture(gl::EntryPoint::GetUniformivRobustANGLE, std::move(paramBuffer));
1615 }
1616
CaptureGetVertexAttribfvRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1617 CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
1618 bool isCallValid,
1619 GLuint index,
1620 GLenum pname,
1621 GLsizei bufSize,
1622 GLsizei *length,
1623 GLfloat *params)
1624 {
1625 ParamBuffer paramBuffer;
1626
1627 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1628 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1629 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1630
1631 if (isCallValid)
1632 {
1633 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1634 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1635 CaptureGetVertexAttribfvRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
1636 length, params, &lengthParam);
1637 paramBuffer.addParam(std::move(lengthParam));
1638 }
1639 else
1640 {
1641 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1642 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1643 &lengthParam.value);
1644 paramBuffer.addParam(std::move(lengthParam));
1645 }
1646
1647 if (isCallValid)
1648 {
1649 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1650 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1651 CaptureGetVertexAttribfvRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
1652 length, params, ¶msParam);
1653 paramBuffer.addParam(std::move(paramsParam));
1654 }
1655 else
1656 {
1657 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1658 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
1659 ¶msParam.value);
1660 paramBuffer.addParam(std::move(paramsParam));
1661 }
1662
1663 return CallCapture(gl::EntryPoint::GetVertexAttribfvRobustANGLE, std::move(paramBuffer));
1664 }
1665
CaptureGetVertexAttribivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1666 CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
1667 bool isCallValid,
1668 GLuint index,
1669 GLenum pname,
1670 GLsizei bufSize,
1671 GLsizei *length,
1672 GLint *params)
1673 {
1674 ParamBuffer paramBuffer;
1675
1676 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1677 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1678 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1679
1680 if (isCallValid)
1681 {
1682 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1683 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1684 CaptureGetVertexAttribivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
1685 length, params, &lengthParam);
1686 paramBuffer.addParam(std::move(lengthParam));
1687 }
1688 else
1689 {
1690 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1691 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1692 &lengthParam.value);
1693 paramBuffer.addParam(std::move(lengthParam));
1694 }
1695
1696 if (isCallValid)
1697 {
1698 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1699 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1700 CaptureGetVertexAttribivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
1701 length, params, ¶msParam);
1702 paramBuffer.addParam(std::move(paramsParam));
1703 }
1704 else
1705 {
1706 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1707 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
1708 paramBuffer.addParam(std::move(paramsParam));
1709 }
1710
1711 return CallCapture(gl::EntryPoint::GetVertexAttribivRobustANGLE, std::move(paramBuffer));
1712 }
1713
CaptureGetVertexAttribPointervRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)1714 CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
1715 bool isCallValid,
1716 GLuint index,
1717 GLenum pname,
1718 GLsizei bufSize,
1719 GLsizei *length,
1720 void **pointer)
1721 {
1722 ParamBuffer paramBuffer;
1723
1724 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1725 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1726 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1727
1728 if (isCallValid)
1729 {
1730 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1731 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1732 CaptureGetVertexAttribPointervRobustANGLE_length(glState, isCallValid, index, pname,
1733 bufSize, length, pointer, &lengthParam);
1734 paramBuffer.addParam(std::move(lengthParam));
1735 }
1736 else
1737 {
1738 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1739 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1740 &lengthParam.value);
1741 paramBuffer.addParam(std::move(lengthParam));
1742 }
1743
1744 if (isCallValid)
1745 {
1746 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
1747 InitParamValue(ParamType::TvoidPointerPointer, pointer, &pointerParam.value);
1748 CaptureGetVertexAttribPointervRobustANGLE_pointer(glState, isCallValid, index, pname,
1749 bufSize, length, pointer, &pointerParam);
1750 paramBuffer.addParam(std::move(pointerParam));
1751 }
1752 else
1753 {
1754 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
1755 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
1756 &pointerParam.value);
1757 paramBuffer.addParam(std::move(pointerParam));
1758 }
1759
1760 return CallCapture(gl::EntryPoint::GetVertexAttribPointervRobustANGLE, std::move(paramBuffer));
1761 }
1762
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)1763 CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
1764 bool isCallValid,
1765 GLint x,
1766 GLint y,
1767 GLsizei width,
1768 GLsizei height,
1769 GLenum format,
1770 GLenum type,
1771 GLsizei bufSize,
1772 GLsizei *length,
1773 GLsizei *columns,
1774 GLsizei *rows,
1775 void *pixels)
1776 {
1777 ParamBuffer paramBuffer;
1778
1779 paramBuffer.addValueParam("x", ParamType::TGLint, x);
1780 paramBuffer.addValueParam("y", ParamType::TGLint, y);
1781 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1782 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1783 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1784 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
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 CaptureReadPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format, type,
1792 bufSize, length, columns, rows, pixels, &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 columnsParam("columns", ParamType::TGLsizeiPointer);
1806 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
1807 CaptureReadPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format,
1808 type, bufSize, length, columns, rows, pixels,
1809 &columnsParam);
1810 paramBuffer.addParam(std::move(columnsParam));
1811 }
1812 else
1813 {
1814 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
1815 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1816 &columnsParam.value);
1817 paramBuffer.addParam(std::move(columnsParam));
1818 }
1819
1820 if (isCallValid)
1821 {
1822 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
1823 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
1824 CaptureReadPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
1825 bufSize, length, columns, rows, pixels, &rowsParam);
1826 paramBuffer.addParam(std::move(rowsParam));
1827 }
1828 else
1829 {
1830 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
1831 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
1832 &rowsParam.value);
1833 paramBuffer.addParam(std::move(rowsParam));
1834 }
1835
1836 if (isCallValid)
1837 {
1838 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
1839 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
1840 CaptureReadPixelsRobustANGLE_pixels(glState, isCallValid, x, y, width, height, format, type,
1841 bufSize, length, columns, rows, pixels, &pixelsParam);
1842 paramBuffer.addParam(std::move(pixelsParam));
1843 }
1844 else
1845 {
1846 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
1847 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
1848 paramBuffer.addParam(std::move(pixelsParam));
1849 }
1850
1851 return CallCapture(gl::EntryPoint::ReadPixelsRobustANGLE, std::move(paramBuffer));
1852 }
1853
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)1854 CallCapture CaptureTexImage2DRobustANGLE(const State &glState,
1855 bool isCallValid,
1856 TextureTarget targetPacked,
1857 GLint level,
1858 GLint internalformat,
1859 GLsizei width,
1860 GLsizei height,
1861 GLint border,
1862 GLenum format,
1863 GLenum type,
1864 GLsizei bufSize,
1865 const void *pixels)
1866 {
1867 ParamBuffer paramBuffer;
1868
1869 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1870 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1871 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
1872 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1873 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1874 paramBuffer.addValueParam("border", ParamType::TGLint, border);
1875 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1876 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1877 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1878
1879 if (isCallValid)
1880 {
1881 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1882 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1883 CaptureTexImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level,
1884 internalformat, width, height, border, format, type,
1885 bufSize, pixels, &pixelsParam);
1886 paramBuffer.addParam(std::move(pixelsParam));
1887 }
1888 else
1889 {
1890 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1891 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
1892 &pixelsParam.value);
1893 paramBuffer.addParam(std::move(pixelsParam));
1894 }
1895
1896 return CallCapture(gl::EntryPoint::TexImage2DRobustANGLE, std::move(paramBuffer));
1897 }
1898
CaptureTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLfloat * params)1899 CallCapture CaptureTexParameterfvRobustANGLE(const State &glState,
1900 bool isCallValid,
1901 TextureType targetPacked,
1902 GLenum pname,
1903 GLsizei bufSize,
1904 const GLfloat *params)
1905 {
1906 ParamBuffer paramBuffer;
1907
1908 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1909 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1910 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1911
1912 if (isCallValid)
1913 {
1914 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1915 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
1916 CaptureTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
1917 params, ¶msParam);
1918 paramBuffer.addParam(std::move(paramsParam));
1919 }
1920 else
1921 {
1922 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1923 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
1924 ¶msParam.value);
1925 paramBuffer.addParam(std::move(paramsParam));
1926 }
1927
1928 return CallCapture(gl::EntryPoint::TexParameterfvRobustANGLE, std::move(paramBuffer));
1929 }
1930
CaptureTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)1931 CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
1932 bool isCallValid,
1933 TextureType targetPacked,
1934 GLenum pname,
1935 GLsizei bufSize,
1936 const GLint *params)
1937 {
1938 ParamBuffer paramBuffer;
1939
1940 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1941 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1942 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1943
1944 if (isCallValid)
1945 {
1946 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
1947 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
1948 CaptureTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
1949 params, ¶msParam);
1950 paramBuffer.addParam(std::move(paramsParam));
1951 }
1952 else
1953 {
1954 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
1955 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
1956 ¶msParam.value);
1957 paramBuffer.addParam(std::move(paramsParam));
1958 }
1959
1960 return CallCapture(gl::EntryPoint::TexParameterivRobustANGLE, std::move(paramBuffer));
1961 }
1962
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)1963 CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
1964 bool isCallValid,
1965 TextureTarget targetPacked,
1966 GLint level,
1967 GLint xoffset,
1968 GLint yoffset,
1969 GLsizei width,
1970 GLsizei height,
1971 GLenum format,
1972 GLenum type,
1973 GLsizei bufSize,
1974 const void *pixels)
1975 {
1976 ParamBuffer paramBuffer;
1977
1978 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1979 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1980 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
1981 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
1982 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1983 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1984 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1985 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1986 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1987
1988 if (isCallValid)
1989 {
1990 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1991 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1992 CaptureTexSubImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
1993 yoffset, width, height, format, type, bufSize,
1994 pixels, &pixelsParam);
1995 paramBuffer.addParam(std::move(pixelsParam));
1996 }
1997 else
1998 {
1999 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2000 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2001 &pixelsParam.value);
2002 paramBuffer.addParam(std::move(pixelsParam));
2003 }
2004
2005 return CallCapture(gl::EntryPoint::TexSubImage2DRobustANGLE, std::move(paramBuffer));
2006 }
2007
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)2008 CallCapture CaptureTexImage3DRobustANGLE(const State &glState,
2009 bool isCallValid,
2010 TextureTarget targetPacked,
2011 GLint level,
2012 GLint internalformat,
2013 GLsizei width,
2014 GLsizei height,
2015 GLsizei depth,
2016 GLint border,
2017 GLenum format,
2018 GLenum type,
2019 GLsizei bufSize,
2020 const void *pixels)
2021 {
2022 ParamBuffer paramBuffer;
2023
2024 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2025 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2026 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
2027 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2028 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2029 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2030 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2031 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
2032 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
2033 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2034
2035 if (isCallValid)
2036 {
2037 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2038 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2039 CaptureTexImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level,
2040 internalformat, width, height, depth, border, format,
2041 type, bufSize, pixels, &pixelsParam);
2042 paramBuffer.addParam(std::move(pixelsParam));
2043 }
2044 else
2045 {
2046 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2047 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2048 &pixelsParam.value);
2049 paramBuffer.addParam(std::move(pixelsParam));
2050 }
2051
2052 return CallCapture(gl::EntryPoint::TexImage3DRobustANGLE, std::move(paramBuffer));
2053 }
2054
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)2055 CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState,
2056 bool isCallValid,
2057 TextureTarget targetPacked,
2058 GLint level,
2059 GLint xoffset,
2060 GLint yoffset,
2061 GLint zoffset,
2062 GLsizei width,
2063 GLsizei height,
2064 GLsizei depth,
2065 GLenum format,
2066 GLenum type,
2067 GLsizei bufSize,
2068 const void *pixels)
2069 {
2070 ParamBuffer paramBuffer;
2071
2072 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2073 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2074 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2075 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2076 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
2077 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2078 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2079 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2080 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
2081 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
2082 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2083
2084 if (isCallValid)
2085 {
2086 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2087 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
2088 CaptureTexSubImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
2089 yoffset, zoffset, width, height, depth, format, type,
2090 bufSize, pixels, &pixelsParam);
2091 paramBuffer.addParam(std::move(pixelsParam));
2092 }
2093 else
2094 {
2095 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
2096 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
2097 &pixelsParam.value);
2098 paramBuffer.addParam(std::move(pixelsParam));
2099 }
2100
2101 return CallCapture(gl::EntryPoint::TexSubImage3DRobustANGLE, std::move(paramBuffer));
2102 }
2103
CaptureCompressedTexImage2DRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2104 CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState,
2105 bool isCallValid,
2106 TextureTarget targetPacked,
2107 GLint level,
2108 GLenum internalformat,
2109 GLsizei width,
2110 GLsizei height,
2111 GLint border,
2112 GLsizei imageSize,
2113 GLsizei dataSize,
2114 const GLvoid *data)
2115 {
2116 ParamBuffer paramBuffer;
2117
2118 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2119 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2120 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
2121 internalformat);
2122 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2123 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2124 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2125 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2126 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2127
2128 if (isCallValid)
2129 {
2130 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2131 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
2132 CaptureCompressedTexImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2133 internalformat, width, height, border,
2134 imageSize, dataSize, data, &dataParam);
2135 paramBuffer.addParam(std::move(dataParam));
2136 }
2137 else
2138 {
2139 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2140 InitParamValue(ParamType::TGLvoidConstPointer, static_cast<const GLvoid *>(nullptr),
2141 &dataParam.value);
2142 paramBuffer.addParam(std::move(dataParam));
2143 }
2144
2145 return CallCapture(gl::EntryPoint::CompressedTexImage2DRobustANGLE, std::move(paramBuffer));
2146 }
2147
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 GLvoid * data)2148 CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState,
2149 bool isCallValid,
2150 TextureTarget targetPacked,
2151 GLint level,
2152 GLsizei xoffset,
2153 GLsizei yoffset,
2154 GLsizei width,
2155 GLsizei height,
2156 GLenum format,
2157 GLsizei imageSize,
2158 GLsizei dataSize,
2159 const GLvoid *data)
2160 {
2161 ParamBuffer paramBuffer;
2162
2163 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2164 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2165 paramBuffer.addValueParam("xoffset", ParamType::TGLsizei, xoffset);
2166 paramBuffer.addValueParam("yoffset", ParamType::TGLsizei, yoffset);
2167 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2168 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2169 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
2170 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2171 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2172
2173 if (isCallValid)
2174 {
2175 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2176 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
2177 CaptureCompressedTexSubImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2178 xoffset, yoffset, width, height, format,
2179 imageSize, dataSize, data, &dataParam);
2180 paramBuffer.addParam(std::move(dataParam));
2181 }
2182 else
2183 {
2184 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2185 InitParamValue(ParamType::TGLvoidConstPointer, static_cast<const GLvoid *>(nullptr),
2186 &dataParam.value);
2187 paramBuffer.addParam(std::move(dataParam));
2188 }
2189
2190 return CallCapture(gl::EntryPoint::CompressedTexSubImage2DRobustANGLE, std::move(paramBuffer));
2191 }
2192
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 GLvoid * data)2193 CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState,
2194 bool isCallValid,
2195 TextureTarget targetPacked,
2196 GLint level,
2197 GLenum internalformat,
2198 GLsizei width,
2199 GLsizei height,
2200 GLsizei depth,
2201 GLint border,
2202 GLsizei imageSize,
2203 GLsizei dataSize,
2204 const GLvoid *data)
2205 {
2206 ParamBuffer paramBuffer;
2207
2208 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2209 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2210 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
2211 internalformat);
2212 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2213 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2214 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2215 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2216 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2217 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2218
2219 if (isCallValid)
2220 {
2221 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2222 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
2223 CaptureCompressedTexImage3DRobustANGLE_data(glState, isCallValid, targetPacked, level,
2224 internalformat, width, height, depth, border,
2225 imageSize, dataSize, data, &dataParam);
2226 paramBuffer.addParam(std::move(dataParam));
2227 }
2228 else
2229 {
2230 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2231 InitParamValue(ParamType::TGLvoidConstPointer, static_cast<const GLvoid *>(nullptr),
2232 &dataParam.value);
2233 paramBuffer.addParam(std::move(dataParam));
2234 }
2235
2236 return CallCapture(gl::EntryPoint::CompressedTexImage3DRobustANGLE, std::move(paramBuffer));
2237 }
2238
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 GLvoid * data)2239 CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState,
2240 bool isCallValid,
2241 TextureTarget targetPacked,
2242 GLint level,
2243 GLint xoffset,
2244 GLint yoffset,
2245 GLint zoffset,
2246 GLsizei width,
2247 GLsizei height,
2248 GLsizei depth,
2249 GLenum format,
2250 GLsizei imageSize,
2251 GLsizei dataSize,
2252 const GLvoid *data)
2253 {
2254 ParamBuffer paramBuffer;
2255
2256 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2257 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2258 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2259 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2260 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
2261 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2262 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2263 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
2264 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
2265 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
2266 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
2267
2268 if (isCallValid)
2269 {
2270 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2271 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
2272 CaptureCompressedTexSubImage3DRobustANGLE_data(
2273 glState, isCallValid, targetPacked, level, xoffset, yoffset, zoffset, width, height,
2274 depth, format, imageSize, dataSize, data, &dataParam);
2275 paramBuffer.addParam(std::move(dataParam));
2276 }
2277 else
2278 {
2279 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
2280 InitParamValue(ParamType::TGLvoidConstPointer, static_cast<const GLvoid *>(nullptr),
2281 &dataParam.value);
2282 paramBuffer.addParam(std::move(dataParam));
2283 }
2284
2285 return CallCapture(gl::EntryPoint::CompressedTexSubImage3DRobustANGLE, std::move(paramBuffer));
2286 }
2287
CaptureGetQueryivRobustANGLE(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2288 CallCapture CaptureGetQueryivRobustANGLE(const State &glState,
2289 bool isCallValid,
2290 QueryType targetPacked,
2291 GLenum pname,
2292 GLsizei bufSize,
2293 GLsizei *length,
2294 GLint *params)
2295 {
2296 ParamBuffer paramBuffer;
2297
2298 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
2299 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2300 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2301
2302 if (isCallValid)
2303 {
2304 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2305 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2306 CaptureGetQueryivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
2307 length, params, &lengthParam);
2308 paramBuffer.addParam(std::move(lengthParam));
2309 }
2310 else
2311 {
2312 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2313 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2314 &lengthParam.value);
2315 paramBuffer.addParam(std::move(lengthParam));
2316 }
2317
2318 if (isCallValid)
2319 {
2320 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2321 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2322 CaptureGetQueryivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2323 length, params, ¶msParam);
2324 paramBuffer.addParam(std::move(paramsParam));
2325 }
2326 else
2327 {
2328 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2329 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2330 paramBuffer.addParam(std::move(paramsParam));
2331 }
2332
2333 return CallCapture(gl::EntryPoint::GetQueryivRobustANGLE, std::move(paramBuffer));
2334 }
2335
CaptureGetQueryObjectuivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2336 CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
2337 bool isCallValid,
2338 QueryID idPacked,
2339 GLenum pname,
2340 GLsizei bufSize,
2341 GLsizei *length,
2342 GLuint *params)
2343 {
2344 ParamBuffer paramBuffer;
2345
2346 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2347 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2348 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2349
2350 if (isCallValid)
2351 {
2352 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2353 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2354 CaptureGetQueryObjectuivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
2355 length, params, &lengthParam);
2356 paramBuffer.addParam(std::move(lengthParam));
2357 }
2358 else
2359 {
2360 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2361 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2362 &lengthParam.value);
2363 paramBuffer.addParam(std::move(lengthParam));
2364 }
2365
2366 if (isCallValid)
2367 {
2368 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2369 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2370 CaptureGetQueryObjectuivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
2371 length, params, ¶msParam);
2372 paramBuffer.addParam(std::move(paramsParam));
2373 }
2374 else
2375 {
2376 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2377 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
2378 ¶msParam.value);
2379 paramBuffer.addParam(std::move(paramsParam));
2380 }
2381
2382 return CallCapture(gl::EntryPoint::GetQueryObjectuivRobustANGLE, std::move(paramBuffer));
2383 }
2384
CaptureGetBufferPointervRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2385 CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
2386 bool isCallValid,
2387 BufferBinding targetPacked,
2388 GLenum pname,
2389 GLsizei bufSize,
2390 GLsizei *length,
2391 void **params)
2392 {
2393 ParamBuffer paramBuffer;
2394
2395 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
2396 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2397 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2398
2399 if (isCallValid)
2400 {
2401 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2402 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2403 CaptureGetBufferPointervRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2404 bufSize, length, params, &lengthParam);
2405 paramBuffer.addParam(std::move(lengthParam));
2406 }
2407 else
2408 {
2409 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2410 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2411 &lengthParam.value);
2412 paramBuffer.addParam(std::move(lengthParam));
2413 }
2414
2415 if (isCallValid)
2416 {
2417 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
2418 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
2419 CaptureGetBufferPointervRobustANGLE_params(glState, isCallValid, targetPacked, pname,
2420 bufSize, length, params, ¶msParam);
2421 paramBuffer.addParam(std::move(paramsParam));
2422 }
2423 else
2424 {
2425 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
2426 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
2427 ¶msParam.value);
2428 paramBuffer.addParam(std::move(paramsParam));
2429 }
2430
2431 return CallCapture(gl::EntryPoint::GetBufferPointervRobustANGLE, std::move(paramBuffer));
2432 }
2433
CaptureGetIntegeri_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)2434 CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
2435 bool isCallValid,
2436 GLenum target,
2437 GLuint index,
2438 GLsizei bufSize,
2439 GLsizei *length,
2440 GLint *data)
2441 {
2442 ParamBuffer paramBuffer;
2443
2444 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
2445 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2446 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2447
2448 if (isCallValid)
2449 {
2450 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2451 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2452 CaptureGetIntegeri_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
2453 data, &lengthParam);
2454 paramBuffer.addParam(std::move(lengthParam));
2455 }
2456 else
2457 {
2458 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2459 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2460 &lengthParam.value);
2461 paramBuffer.addParam(std::move(lengthParam));
2462 }
2463
2464 if (isCallValid)
2465 {
2466 ParamCapture dataParam("data", ParamType::TGLintPointer);
2467 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
2468 CaptureGetIntegeri_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
2469 data, &dataParam);
2470 paramBuffer.addParam(std::move(dataParam));
2471 }
2472 else
2473 {
2474 ParamCapture dataParam("data", ParamType::TGLintPointer);
2475 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
2476 paramBuffer.addParam(std::move(dataParam));
2477 }
2478
2479 return CallCapture(gl::EntryPoint::GetIntegeri_vRobustANGLE, std::move(paramBuffer));
2480 }
2481
CaptureGetInternalformativRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2482 CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
2483 bool isCallValid,
2484 GLenum target,
2485 GLenum internalformat,
2486 GLenum pname,
2487 GLsizei bufSize,
2488 GLsizei *length,
2489 GLint *params)
2490 {
2491 ParamBuffer paramBuffer;
2492
2493 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
2494 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
2495 internalformat);
2496 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2497 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2498
2499 if (isCallValid)
2500 {
2501 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2502 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2503 CaptureGetInternalformativRobustANGLE_length(glState, isCallValid, target, internalformat,
2504 pname, bufSize, length, params, &lengthParam);
2505 paramBuffer.addParam(std::move(lengthParam));
2506 }
2507 else
2508 {
2509 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2510 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2511 &lengthParam.value);
2512 paramBuffer.addParam(std::move(lengthParam));
2513 }
2514
2515 if (isCallValid)
2516 {
2517 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2518 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2519 CaptureGetInternalformativRobustANGLE_params(glState, isCallValid, target, internalformat,
2520 pname, bufSize, length, params, ¶msParam);
2521 paramBuffer.addParam(std::move(paramsParam));
2522 }
2523 else
2524 {
2525 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2526 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2527 paramBuffer.addParam(std::move(paramsParam));
2528 }
2529
2530 return CallCapture(gl::EntryPoint::GetInternalformativRobustANGLE, std::move(paramBuffer));
2531 }
2532
CaptureGetVertexAttribIivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2533 CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
2534 bool isCallValid,
2535 GLuint index,
2536 GLenum pname,
2537 GLsizei bufSize,
2538 GLsizei *length,
2539 GLint *params)
2540 {
2541 ParamBuffer paramBuffer;
2542
2543 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2544 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2545 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2546
2547 if (isCallValid)
2548 {
2549 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2550 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2551 CaptureGetVertexAttribIivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
2552 length, params, &lengthParam);
2553 paramBuffer.addParam(std::move(lengthParam));
2554 }
2555 else
2556 {
2557 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2558 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2559 &lengthParam.value);
2560 paramBuffer.addParam(std::move(lengthParam));
2561 }
2562
2563 if (isCallValid)
2564 {
2565 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2566 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2567 CaptureGetVertexAttribIivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
2568 length, params, ¶msParam);
2569 paramBuffer.addParam(std::move(paramsParam));
2570 }
2571 else
2572 {
2573 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2574 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2575 paramBuffer.addParam(std::move(paramsParam));
2576 }
2577
2578 return CallCapture(gl::EntryPoint::GetVertexAttribIivRobustANGLE, std::move(paramBuffer));
2579 }
2580
CaptureGetVertexAttribIuivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2581 CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
2582 bool isCallValid,
2583 GLuint index,
2584 GLenum pname,
2585 GLsizei bufSize,
2586 GLsizei *length,
2587 GLuint *params)
2588 {
2589 ParamBuffer paramBuffer;
2590
2591 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2592 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2593 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2594
2595 if (isCallValid)
2596 {
2597 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2598 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2599 CaptureGetVertexAttribIuivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
2600 length, params, &lengthParam);
2601 paramBuffer.addParam(std::move(lengthParam));
2602 }
2603 else
2604 {
2605 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2606 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2607 &lengthParam.value);
2608 paramBuffer.addParam(std::move(lengthParam));
2609 }
2610
2611 if (isCallValid)
2612 {
2613 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2614 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2615 CaptureGetVertexAttribIuivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
2616 length, params, ¶msParam);
2617 paramBuffer.addParam(std::move(paramsParam));
2618 }
2619 else
2620 {
2621 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2622 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
2623 ¶msParam.value);
2624 paramBuffer.addParam(std::move(paramsParam));
2625 }
2626
2627 return CallCapture(gl::EntryPoint::GetVertexAttribIuivRobustANGLE, std::move(paramBuffer));
2628 }
2629
CaptureGetUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)2630 CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
2631 bool isCallValid,
2632 ShaderProgramID programPacked,
2633 UniformLocation locationPacked,
2634 GLsizei bufSize,
2635 GLsizei *length,
2636 GLuint *params)
2637 {
2638 ParamBuffer paramBuffer;
2639
2640 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2641 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2642 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2643
2644 if (isCallValid)
2645 {
2646 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2647 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2648 CaptureGetUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2649 bufSize, length, params, &lengthParam);
2650 paramBuffer.addParam(std::move(lengthParam));
2651 }
2652 else
2653 {
2654 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2655 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2656 &lengthParam.value);
2657 paramBuffer.addParam(std::move(lengthParam));
2658 }
2659
2660 if (isCallValid)
2661 {
2662 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2663 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2664 CaptureGetUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2665 bufSize, length, params, ¶msParam);
2666 paramBuffer.addParam(std::move(paramsParam));
2667 }
2668 else
2669 {
2670 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2671 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
2672 ¶msParam.value);
2673 paramBuffer.addParam(std::move(paramsParam));
2674 }
2675
2676 return CallCapture(gl::EntryPoint::GetUniformuivRobustANGLE, std::move(paramBuffer));
2677 }
2678
CaptureGetActiveUniformBlockivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2679 CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState,
2680 bool isCallValid,
2681 ShaderProgramID programPacked,
2682 GLuint uniformBlockIndex,
2683 GLenum pname,
2684 GLsizei bufSize,
2685 GLsizei *length,
2686 GLint *params)
2687 {
2688 ParamBuffer paramBuffer;
2689
2690 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2691 paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
2692 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2693 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2694
2695 if (isCallValid)
2696 {
2697 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2698 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2699 CaptureGetActiveUniformBlockivRobustANGLE_length(glState, isCallValid, programPacked,
2700 uniformBlockIndex, pname, bufSize, length,
2701 params, &lengthParam);
2702 paramBuffer.addParam(std::move(lengthParam));
2703 }
2704 else
2705 {
2706 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2707 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2708 &lengthParam.value);
2709 paramBuffer.addParam(std::move(lengthParam));
2710 }
2711
2712 if (isCallValid)
2713 {
2714 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2715 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2716 CaptureGetActiveUniformBlockivRobustANGLE_params(glState, isCallValid, programPacked,
2717 uniformBlockIndex, pname, bufSize, length,
2718 params, ¶msParam);
2719 paramBuffer.addParam(std::move(paramsParam));
2720 }
2721 else
2722 {
2723 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2724 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2725 paramBuffer.addParam(std::move(paramsParam));
2726 }
2727
2728 return CallCapture(gl::EntryPoint::GetActiveUniformBlockivRobustANGLE, std::move(paramBuffer));
2729 }
2730
CaptureGetInteger64vRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)2731 CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
2732 bool isCallValid,
2733 GLenum pname,
2734 GLsizei bufSize,
2735 GLsizei *length,
2736 GLint64 *data)
2737 {
2738 ParamBuffer paramBuffer;
2739
2740 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2741 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2742
2743 if (isCallValid)
2744 {
2745 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2746 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2747 CaptureGetInteger64vRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
2748 &lengthParam);
2749 paramBuffer.addParam(std::move(lengthParam));
2750 }
2751 else
2752 {
2753 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2754 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2755 &lengthParam.value);
2756 paramBuffer.addParam(std::move(lengthParam));
2757 }
2758
2759 if (isCallValid)
2760 {
2761 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
2762 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
2763 CaptureGetInteger64vRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
2764 &dataParam);
2765 paramBuffer.addParam(std::move(dataParam));
2766 }
2767 else
2768 {
2769 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
2770 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
2771 &dataParam.value);
2772 paramBuffer.addParam(std::move(dataParam));
2773 }
2774
2775 return CallCapture(gl::EntryPoint::GetInteger64vRobustANGLE, std::move(paramBuffer));
2776 }
2777
CaptureGetInteger64i_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)2778 CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
2779 bool isCallValid,
2780 GLenum target,
2781 GLuint index,
2782 GLsizei bufSize,
2783 GLsizei *length,
2784 GLint64 *data)
2785 {
2786 ParamBuffer paramBuffer;
2787
2788 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
2789 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2790 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2791
2792 if (isCallValid)
2793 {
2794 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2795 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2796 CaptureGetInteger64i_vRobustANGLE_length(glState, isCallValid, target, index, bufSize,
2797 length, data, &lengthParam);
2798 paramBuffer.addParam(std::move(lengthParam));
2799 }
2800 else
2801 {
2802 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2803 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2804 &lengthParam.value);
2805 paramBuffer.addParam(std::move(lengthParam));
2806 }
2807
2808 if (isCallValid)
2809 {
2810 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
2811 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
2812 CaptureGetInteger64i_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
2813 data, &dataParam);
2814 paramBuffer.addParam(std::move(dataParam));
2815 }
2816 else
2817 {
2818 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
2819 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
2820 &dataParam.value);
2821 paramBuffer.addParam(std::move(dataParam));
2822 }
2823
2824 return CallCapture(gl::EntryPoint::GetInteger64i_vRobustANGLE, std::move(paramBuffer));
2825 }
2826
CaptureGetBufferParameteri64vRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)2827 CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
2828 bool isCallValid,
2829 BufferBinding targetPacked,
2830 GLenum pname,
2831 GLsizei bufSize,
2832 GLsizei *length,
2833 GLint64 *params)
2834 {
2835 ParamBuffer paramBuffer;
2836
2837 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
2838 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2839 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2840
2841 if (isCallValid)
2842 {
2843 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2844 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2845 CaptureGetBufferParameteri64vRobustANGLE_length(glState, isCallValid, targetPacked, pname,
2846 bufSize, length, params, &lengthParam);
2847 paramBuffer.addParam(std::move(lengthParam));
2848 }
2849 else
2850 {
2851 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2852 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2853 &lengthParam.value);
2854 paramBuffer.addParam(std::move(lengthParam));
2855 }
2856
2857 if (isCallValid)
2858 {
2859 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
2860 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
2861 CaptureGetBufferParameteri64vRobustANGLE_params(glState, isCallValid, targetPacked, pname,
2862 bufSize, length, params, ¶msParam);
2863 paramBuffer.addParam(std::move(paramsParam));
2864 }
2865 else
2866 {
2867 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
2868 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
2869 ¶msParam.value);
2870 paramBuffer.addParam(std::move(paramsParam));
2871 }
2872
2873 return CallCapture(gl::EntryPoint::GetBufferParameteri64vRobustANGLE, std::move(paramBuffer));
2874 }
2875
CaptureSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLuint pname,GLsizei bufSize,const GLint * param)2876 CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
2877 bool isCallValid,
2878 SamplerID samplerPacked,
2879 GLuint pname,
2880 GLsizei bufSize,
2881 const GLint *param)
2882 {
2883 ParamBuffer paramBuffer;
2884
2885 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2886 paramBuffer.addValueParam("pname", ParamType::TGLuint, pname);
2887 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2888
2889 if (isCallValid)
2890 {
2891 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
2892 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
2893 CaptureSamplerParameterivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
2894 bufSize, param, ¶mParam);
2895 paramBuffer.addParam(std::move(paramParam));
2896 }
2897 else
2898 {
2899 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
2900 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
2901 ¶mParam.value);
2902 paramBuffer.addParam(std::move(paramParam));
2903 }
2904
2905 return CallCapture(gl::EntryPoint::SamplerParameterivRobustANGLE, std::move(paramBuffer));
2906 }
2907
CaptureSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLfloat * param)2908 CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
2909 bool isCallValid,
2910 SamplerID samplerPacked,
2911 GLenum pname,
2912 GLsizei bufSize,
2913 const GLfloat *param)
2914 {
2915 ParamBuffer paramBuffer;
2916
2917 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2918 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2919 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2920
2921 if (isCallValid)
2922 {
2923 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
2924 InitParamValue(ParamType::TGLfloatConstPointer, param, ¶mParam.value);
2925 CaptureSamplerParameterfvRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
2926 bufSize, param, ¶mParam);
2927 paramBuffer.addParam(std::move(paramParam));
2928 }
2929 else
2930 {
2931 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
2932 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
2933 ¶mParam.value);
2934 paramBuffer.addParam(std::move(paramParam));
2935 }
2936
2937 return CallCapture(gl::EntryPoint::SamplerParameterfvRobustANGLE, std::move(paramBuffer));
2938 }
2939
CaptureGetSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2940 CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
2941 bool isCallValid,
2942 SamplerID samplerPacked,
2943 GLenum pname,
2944 GLsizei bufSize,
2945 GLsizei *length,
2946 GLint *params)
2947 {
2948 ParamBuffer paramBuffer;
2949
2950 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2951 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2952 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2953
2954 if (isCallValid)
2955 {
2956 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2957 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2958 CaptureGetSamplerParameterivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
2959 bufSize, length, params, &lengthParam);
2960 paramBuffer.addParam(std::move(lengthParam));
2961 }
2962 else
2963 {
2964 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2965 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
2966 &lengthParam.value);
2967 paramBuffer.addParam(std::move(lengthParam));
2968 }
2969
2970 if (isCallValid)
2971 {
2972 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2973 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2974 CaptureGetSamplerParameterivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
2975 bufSize, length, params, ¶msParam);
2976 paramBuffer.addParam(std::move(paramsParam));
2977 }
2978 else
2979 {
2980 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2981 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
2982 paramBuffer.addParam(std::move(paramsParam));
2983 }
2984
2985 return CallCapture(gl::EntryPoint::GetSamplerParameterivRobustANGLE, std::move(paramBuffer));
2986 }
2987
CaptureGetSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2988 CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
2989 bool isCallValid,
2990 SamplerID samplerPacked,
2991 GLenum pname,
2992 GLsizei bufSize,
2993 GLsizei *length,
2994 GLfloat *params)
2995 {
2996 ParamBuffer paramBuffer;
2997
2998 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2999 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3000 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3001
3002 if (isCallValid)
3003 {
3004 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3005 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3006 CaptureGetSamplerParameterfvRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3007 bufSize, length, params, &lengthParam);
3008 paramBuffer.addParam(std::move(lengthParam));
3009 }
3010 else
3011 {
3012 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3013 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3014 &lengthParam.value);
3015 paramBuffer.addParam(std::move(lengthParam));
3016 }
3017
3018 if (isCallValid)
3019 {
3020 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3021 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3022 CaptureGetSamplerParameterfvRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3023 bufSize, length, params, ¶msParam);
3024 paramBuffer.addParam(std::move(paramsParam));
3025 }
3026 else
3027 {
3028 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3029 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3030 ¶msParam.value);
3031 paramBuffer.addParam(std::move(paramsParam));
3032 }
3033
3034 return CallCapture(gl::EntryPoint::GetSamplerParameterfvRobustANGLE, std::move(paramBuffer));
3035 }
3036
CaptureGetFramebufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3037 CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
3038 bool isCallValid,
3039 GLenum target,
3040 GLenum pname,
3041 GLsizei bufSize,
3042 GLsizei *length,
3043 GLint *params)
3044 {
3045 ParamBuffer paramBuffer;
3046
3047 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
3048 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3049 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3050
3051 if (isCallValid)
3052 {
3053 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3054 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3055 CaptureGetFramebufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
3056 bufSize, length, params, &lengthParam);
3057 paramBuffer.addParam(std::move(lengthParam));
3058 }
3059 else
3060 {
3061 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3062 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3063 &lengthParam.value);
3064 paramBuffer.addParam(std::move(lengthParam));
3065 }
3066
3067 if (isCallValid)
3068 {
3069 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3070 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3071 CaptureGetFramebufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
3072 bufSize, length, params, ¶msParam);
3073 paramBuffer.addParam(std::move(paramsParam));
3074 }
3075 else
3076 {
3077 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3078 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3079 paramBuffer.addParam(std::move(paramsParam));
3080 }
3081
3082 return CallCapture(gl::EntryPoint::GetFramebufferParameterivRobustANGLE,
3083 std::move(paramBuffer));
3084 }
3085
CaptureGetProgramInterfaceivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3086 CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
3087 bool isCallValid,
3088 ShaderProgramID programPacked,
3089 GLenum programInterface,
3090 GLenum pname,
3091 GLsizei bufSize,
3092 GLsizei *length,
3093 GLint *params)
3094 {
3095 ParamBuffer paramBuffer;
3096
3097 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3098 paramBuffer.addEnumParam("programInterface", GLenumGroup::DefaultGroup, ParamType::TGLenum,
3099 programInterface);
3100 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3101 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3102
3103 if (isCallValid)
3104 {
3105 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3106 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3107 CaptureGetProgramInterfaceivRobustANGLE_length(glState, isCallValid, programPacked,
3108 programInterface, pname, bufSize, length,
3109 params, &lengthParam);
3110 paramBuffer.addParam(std::move(lengthParam));
3111 }
3112 else
3113 {
3114 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3115 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3116 &lengthParam.value);
3117 paramBuffer.addParam(std::move(lengthParam));
3118 }
3119
3120 if (isCallValid)
3121 {
3122 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3123 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3124 CaptureGetProgramInterfaceivRobustANGLE_params(glState, isCallValid, programPacked,
3125 programInterface, pname, bufSize, length,
3126 params, ¶msParam);
3127 paramBuffer.addParam(std::move(paramsParam));
3128 }
3129 else
3130 {
3131 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3132 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3133 paramBuffer.addParam(std::move(paramsParam));
3134 }
3135
3136 return CallCapture(gl::EntryPoint::GetProgramInterfaceivRobustANGLE, std::move(paramBuffer));
3137 }
3138
CaptureGetBooleani_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)3139 CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
3140 bool isCallValid,
3141 GLenum target,
3142 GLuint index,
3143 GLsizei bufSize,
3144 GLsizei *length,
3145 GLboolean *data)
3146 {
3147 ParamBuffer paramBuffer;
3148
3149 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
3150 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3151 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3152
3153 if (isCallValid)
3154 {
3155 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3156 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3157 CaptureGetBooleani_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
3158 data, &lengthParam);
3159 paramBuffer.addParam(std::move(lengthParam));
3160 }
3161 else
3162 {
3163 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3164 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3165 &lengthParam.value);
3166 paramBuffer.addParam(std::move(lengthParam));
3167 }
3168
3169 if (isCallValid)
3170 {
3171 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
3172 InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
3173 CaptureGetBooleani_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
3174 data, &dataParam);
3175 paramBuffer.addParam(std::move(dataParam));
3176 }
3177 else
3178 {
3179 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
3180 InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
3181 &dataParam.value);
3182 paramBuffer.addParam(std::move(dataParam));
3183 }
3184
3185 return CallCapture(gl::EntryPoint::GetBooleani_vRobustANGLE, std::move(paramBuffer));
3186 }
3187
CaptureGetMultisamplefvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)3188 CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
3189 bool isCallValid,
3190 GLenum pname,
3191 GLuint index,
3192 GLsizei bufSize,
3193 GLsizei *length,
3194 GLfloat *val)
3195 {
3196 ParamBuffer paramBuffer;
3197
3198 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3199 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3200 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3201
3202 if (isCallValid)
3203 {
3204 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3205 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3206 CaptureGetMultisamplefvRobustANGLE_length(glState, isCallValid, pname, index, bufSize,
3207 length, val, &lengthParam);
3208 paramBuffer.addParam(std::move(lengthParam));
3209 }
3210 else
3211 {
3212 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3213 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3214 &lengthParam.value);
3215 paramBuffer.addParam(std::move(lengthParam));
3216 }
3217
3218 if (isCallValid)
3219 {
3220 ParamCapture valParam("val", ParamType::TGLfloatPointer);
3221 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
3222 CaptureGetMultisamplefvRobustANGLE_val(glState, isCallValid, pname, index, bufSize, length,
3223 val, &valParam);
3224 paramBuffer.addParam(std::move(valParam));
3225 }
3226 else
3227 {
3228 ParamCapture valParam("val", ParamType::TGLfloatPointer);
3229 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3230 &valParam.value);
3231 paramBuffer.addParam(std::move(valParam));
3232 }
3233
3234 return CallCapture(gl::EntryPoint::GetMultisamplefvRobustANGLE, std::move(paramBuffer));
3235 }
3236
CaptureGetTexLevelParameterivRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3237 CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
3238 bool isCallValid,
3239 TextureTarget targetPacked,
3240 GLint level,
3241 GLenum pname,
3242 GLsizei bufSize,
3243 GLsizei *length,
3244 GLint *params)
3245 {
3246 ParamBuffer paramBuffer;
3247
3248 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
3249 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3250 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3251 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3252
3253 if (isCallValid)
3254 {
3255 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3256 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3257 CaptureGetTexLevelParameterivRobustANGLE_length(glState, isCallValid, targetPacked, level,
3258 pname, bufSize, length, params,
3259 &lengthParam);
3260 paramBuffer.addParam(std::move(lengthParam));
3261 }
3262 else
3263 {
3264 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3265 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3266 &lengthParam.value);
3267 paramBuffer.addParam(std::move(lengthParam));
3268 }
3269
3270 if (isCallValid)
3271 {
3272 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3273 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3274 CaptureGetTexLevelParameterivRobustANGLE_params(glState, isCallValid, targetPacked, level,
3275 pname, bufSize, length, params,
3276 ¶msParam);
3277 paramBuffer.addParam(std::move(paramsParam));
3278 }
3279 else
3280 {
3281 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3282 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3283 paramBuffer.addParam(std::move(paramsParam));
3284 }
3285
3286 return CallCapture(gl::EntryPoint::GetTexLevelParameterivRobustANGLE, std::move(paramBuffer));
3287 }
3288
CaptureGetTexLevelParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3289 CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
3290 bool isCallValid,
3291 TextureTarget targetPacked,
3292 GLint level,
3293 GLenum pname,
3294 GLsizei bufSize,
3295 GLsizei *length,
3296 GLfloat *params)
3297 {
3298 ParamBuffer paramBuffer;
3299
3300 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
3301 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3302 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3303 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3304
3305 if (isCallValid)
3306 {
3307 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3308 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3309 CaptureGetTexLevelParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, level,
3310 pname, bufSize, length, params,
3311 &lengthParam);
3312 paramBuffer.addParam(std::move(lengthParam));
3313 }
3314 else
3315 {
3316 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3317 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3318 &lengthParam.value);
3319 paramBuffer.addParam(std::move(lengthParam));
3320 }
3321
3322 if (isCallValid)
3323 {
3324 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3325 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3326 CaptureGetTexLevelParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, level,
3327 pname, bufSize, length, params,
3328 ¶msParam);
3329 paramBuffer.addParam(std::move(paramsParam));
3330 }
3331 else
3332 {
3333 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3334 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3335 ¶msParam.value);
3336 paramBuffer.addParam(std::move(paramsParam));
3337 }
3338
3339 return CallCapture(gl::EntryPoint::GetTexLevelParameterfvRobustANGLE, std::move(paramBuffer));
3340 }
3341
CaptureGetPointervRobustANGLERobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)3342 CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
3343 bool isCallValid,
3344 GLenum pname,
3345 GLsizei bufSize,
3346 GLsizei *length,
3347 void **params)
3348 {
3349 ParamBuffer paramBuffer;
3350
3351 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3352 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3353
3354 if (isCallValid)
3355 {
3356 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3357 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3358 CaptureGetPointervRobustANGLERobustANGLE_length(glState, isCallValid, pname, bufSize,
3359 length, params, &lengthParam);
3360 paramBuffer.addParam(std::move(lengthParam));
3361 }
3362 else
3363 {
3364 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3365 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3366 &lengthParam.value);
3367 paramBuffer.addParam(std::move(lengthParam));
3368 }
3369
3370 if (isCallValid)
3371 {
3372 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3373 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
3374 CaptureGetPointervRobustANGLERobustANGLE_params(glState, isCallValid, pname, bufSize,
3375 length, params, ¶msParam);
3376 paramBuffer.addParam(std::move(paramsParam));
3377 }
3378 else
3379 {
3380 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
3381 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
3382 ¶msParam.value);
3383 paramBuffer.addParam(std::move(paramsParam));
3384 }
3385
3386 return CallCapture(gl::EntryPoint::GetPointervRobustANGLERobustANGLE, std::move(paramBuffer));
3387 }
3388
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)3389 CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
3390 bool isCallValid,
3391 GLint x,
3392 GLint y,
3393 GLsizei width,
3394 GLsizei height,
3395 GLenum format,
3396 GLenum type,
3397 GLsizei bufSize,
3398 GLsizei *length,
3399 GLsizei *columns,
3400 GLsizei *rows,
3401 void *data)
3402 {
3403 ParamBuffer paramBuffer;
3404
3405 paramBuffer.addValueParam("x", ParamType::TGLint, x);
3406 paramBuffer.addValueParam("y", ParamType::TGLint, y);
3407 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3408 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3409 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
3410 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
3411 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3412
3413 if (isCallValid)
3414 {
3415 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3416 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3417 CaptureReadnPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format,
3418 type, bufSize, length, columns, rows, data,
3419 &lengthParam);
3420 paramBuffer.addParam(std::move(lengthParam));
3421 }
3422 else
3423 {
3424 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3425 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3426 &lengthParam.value);
3427 paramBuffer.addParam(std::move(lengthParam));
3428 }
3429
3430 if (isCallValid)
3431 {
3432 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
3433 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
3434 CaptureReadnPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format,
3435 type, bufSize, length, columns, rows, data,
3436 &columnsParam);
3437 paramBuffer.addParam(std::move(columnsParam));
3438 }
3439 else
3440 {
3441 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
3442 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3443 &columnsParam.value);
3444 paramBuffer.addParam(std::move(columnsParam));
3445 }
3446
3447 if (isCallValid)
3448 {
3449 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
3450 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
3451 CaptureReadnPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
3452 bufSize, length, columns, rows, data, &rowsParam);
3453 paramBuffer.addParam(std::move(rowsParam));
3454 }
3455 else
3456 {
3457 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
3458 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3459 &rowsParam.value);
3460 paramBuffer.addParam(std::move(rowsParam));
3461 }
3462
3463 if (isCallValid)
3464 {
3465 ParamCapture dataParam("data", ParamType::TvoidPointer);
3466 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
3467 CaptureReadnPixelsRobustANGLE_data(glState, isCallValid, x, y, width, height, format, type,
3468 bufSize, length, columns, rows, data, &dataParam);
3469 paramBuffer.addParam(std::move(dataParam));
3470 }
3471 else
3472 {
3473 ParamCapture dataParam("data", ParamType::TvoidPointer);
3474 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
3475 paramBuffer.addParam(std::move(dataParam));
3476 }
3477
3478 return CallCapture(gl::EntryPoint::ReadnPixelsRobustANGLE, std::move(paramBuffer));
3479 }
3480
CaptureGetnUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)3481 CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
3482 bool isCallValid,
3483 ShaderProgramID programPacked,
3484 UniformLocation locationPacked,
3485 GLsizei bufSize,
3486 GLsizei *length,
3487 GLfloat *params)
3488 {
3489 ParamBuffer paramBuffer;
3490
3491 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3492 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3493 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3494
3495 if (isCallValid)
3496 {
3497 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3498 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3499 CaptureGetnUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
3500 bufSize, length, params, &lengthParam);
3501 paramBuffer.addParam(std::move(lengthParam));
3502 }
3503 else
3504 {
3505 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3506 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3507 &lengthParam.value);
3508 paramBuffer.addParam(std::move(lengthParam));
3509 }
3510
3511 if (isCallValid)
3512 {
3513 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3514 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3515 CaptureGetnUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
3516 bufSize, length, params, ¶msParam);
3517 paramBuffer.addParam(std::move(paramsParam));
3518 }
3519 else
3520 {
3521 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3522 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
3523 ¶msParam.value);
3524 paramBuffer.addParam(std::move(paramsParam));
3525 }
3526
3527 return CallCapture(gl::EntryPoint::GetnUniformfvRobustANGLE, std::move(paramBuffer));
3528 }
3529
CaptureGetnUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)3530 CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
3531 bool isCallValid,
3532 ShaderProgramID programPacked,
3533 UniformLocation locationPacked,
3534 GLsizei bufSize,
3535 GLsizei *length,
3536 GLint *params)
3537 {
3538 ParamBuffer paramBuffer;
3539
3540 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3541 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3542 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3543
3544 if (isCallValid)
3545 {
3546 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3547 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3548 CaptureGetnUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
3549 bufSize, length, params, &lengthParam);
3550 paramBuffer.addParam(std::move(lengthParam));
3551 }
3552 else
3553 {
3554 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3555 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3556 &lengthParam.value);
3557 paramBuffer.addParam(std::move(lengthParam));
3558 }
3559
3560 if (isCallValid)
3561 {
3562 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3563 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3564 CaptureGetnUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
3565 bufSize, length, params, ¶msParam);
3566 paramBuffer.addParam(std::move(paramsParam));
3567 }
3568 else
3569 {
3570 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3571 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3572 paramBuffer.addParam(std::move(paramsParam));
3573 }
3574
3575 return CallCapture(gl::EntryPoint::GetnUniformivRobustANGLE, std::move(paramBuffer));
3576 }
3577
CaptureGetnUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)3578 CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
3579 bool isCallValid,
3580 ShaderProgramID programPacked,
3581 UniformLocation locationPacked,
3582 GLsizei bufSize,
3583 GLsizei *length,
3584 GLuint *params)
3585 {
3586 ParamBuffer paramBuffer;
3587
3588 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3589 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3590 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3591
3592 if (isCallValid)
3593 {
3594 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3595 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3596 CaptureGetnUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
3597 bufSize, length, params, &lengthParam);
3598 paramBuffer.addParam(std::move(lengthParam));
3599 }
3600 else
3601 {
3602 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3603 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3604 &lengthParam.value);
3605 paramBuffer.addParam(std::move(lengthParam));
3606 }
3607
3608 if (isCallValid)
3609 {
3610 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3611 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3612 CaptureGetnUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
3613 bufSize, length, params, ¶msParam);
3614 paramBuffer.addParam(std::move(paramsParam));
3615 }
3616 else
3617 {
3618 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3619 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3620 ¶msParam.value);
3621 paramBuffer.addParam(std::move(paramsParam));
3622 }
3623
3624 return CallCapture(gl::EntryPoint::GetnUniformuivRobustANGLE, std::move(paramBuffer));
3625 }
3626
CaptureTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)3627 CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
3628 bool isCallValid,
3629 TextureType targetPacked,
3630 GLenum pname,
3631 GLsizei bufSize,
3632 const GLint *params)
3633 {
3634 ParamBuffer paramBuffer;
3635
3636 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3637 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3638 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3639
3640 if (isCallValid)
3641 {
3642 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
3643 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
3644 CaptureTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
3645 params, ¶msParam);
3646 paramBuffer.addParam(std::move(paramsParam));
3647 }
3648 else
3649 {
3650 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
3651 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
3652 ¶msParam.value);
3653 paramBuffer.addParam(std::move(paramsParam));
3654 }
3655
3656 return CallCapture(gl::EntryPoint::TexParameterIivRobustANGLE, std::move(paramBuffer));
3657 }
3658
CaptureTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLuint * params)3659 CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
3660 bool isCallValid,
3661 TextureType targetPacked,
3662 GLenum pname,
3663 GLsizei bufSize,
3664 const GLuint *params)
3665 {
3666 ParamBuffer paramBuffer;
3667
3668 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3669 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3670 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3671
3672 if (isCallValid)
3673 {
3674 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
3675 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
3676 CaptureTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
3677 bufSize, params, ¶msParam);
3678 paramBuffer.addParam(std::move(paramsParam));
3679 }
3680 else
3681 {
3682 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
3683 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
3684 ¶msParam.value);
3685 paramBuffer.addParam(std::move(paramsParam));
3686 }
3687
3688 return CallCapture(gl::EntryPoint::TexParameterIuivRobustANGLE, std::move(paramBuffer));
3689 }
3690
CaptureGetTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3691 CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
3692 bool isCallValid,
3693 TextureType targetPacked,
3694 GLenum pname,
3695 GLsizei bufSize,
3696 GLsizei *length,
3697 GLint *params)
3698 {
3699 ParamBuffer paramBuffer;
3700
3701 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3702 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3703 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3704
3705 if (isCallValid)
3706 {
3707 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3708 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3709 CaptureGetTexParameterIivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
3710 bufSize, length, params, &lengthParam);
3711 paramBuffer.addParam(std::move(lengthParam));
3712 }
3713 else
3714 {
3715 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3716 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3717 &lengthParam.value);
3718 paramBuffer.addParam(std::move(lengthParam));
3719 }
3720
3721 if (isCallValid)
3722 {
3723 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3724 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3725 CaptureGetTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
3726 bufSize, length, 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(gl::EntryPoint::GetTexParameterIivRobustANGLE, std::move(paramBuffer));
3737 }
3738
CaptureGetTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3739 CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
3740 bool isCallValid,
3741 TextureType targetPacked,
3742 GLenum pname,
3743 GLsizei bufSize,
3744 GLsizei *length,
3745 GLuint *params)
3746 {
3747 ParamBuffer paramBuffer;
3748
3749 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3750 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3751 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3752
3753 if (isCallValid)
3754 {
3755 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3756 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3757 CaptureGetTexParameterIuivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
3758 bufSize, length, params, &lengthParam);
3759 paramBuffer.addParam(std::move(lengthParam));
3760 }
3761 else
3762 {
3763 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3764 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3765 &lengthParam.value);
3766 paramBuffer.addParam(std::move(lengthParam));
3767 }
3768
3769 if (isCallValid)
3770 {
3771 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3772 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3773 CaptureGetTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
3774 bufSize, length, params, ¶msParam);
3775 paramBuffer.addParam(std::move(paramsParam));
3776 }
3777 else
3778 {
3779 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3780 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3781 ¶msParam.value);
3782 paramBuffer.addParam(std::move(paramsParam));
3783 }
3784
3785 return CallCapture(gl::EntryPoint::GetTexParameterIuivRobustANGLE, std::move(paramBuffer));
3786 }
3787
CaptureSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLint * param)3788 CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
3789 bool isCallValid,
3790 SamplerID samplerPacked,
3791 GLenum pname,
3792 GLsizei bufSize,
3793 const GLint *param)
3794 {
3795 ParamBuffer paramBuffer;
3796
3797 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3798 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3799 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3800
3801 if (isCallValid)
3802 {
3803 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
3804 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
3805 CaptureSamplerParameterIivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
3806 bufSize, param, ¶mParam);
3807 paramBuffer.addParam(std::move(paramParam));
3808 }
3809 else
3810 {
3811 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
3812 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
3813 ¶mParam.value);
3814 paramBuffer.addParam(std::move(paramParam));
3815 }
3816
3817 return CallCapture(gl::EntryPoint::SamplerParameterIivRobustANGLE, std::move(paramBuffer));
3818 }
3819
CaptureSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLuint * param)3820 CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
3821 bool isCallValid,
3822 SamplerID samplerPacked,
3823 GLenum pname,
3824 GLsizei bufSize,
3825 const GLuint *param)
3826 {
3827 ParamBuffer paramBuffer;
3828
3829 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3830 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3831 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3832
3833 if (isCallValid)
3834 {
3835 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
3836 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
3837 CaptureSamplerParameterIuivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
3838 bufSize, param, ¶mParam);
3839 paramBuffer.addParam(std::move(paramParam));
3840 }
3841 else
3842 {
3843 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
3844 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
3845 ¶mParam.value);
3846 paramBuffer.addParam(std::move(paramParam));
3847 }
3848
3849 return CallCapture(gl::EntryPoint::SamplerParameterIuivRobustANGLE, std::move(paramBuffer));
3850 }
3851
CaptureGetSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3852 CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
3853 bool isCallValid,
3854 SamplerID samplerPacked,
3855 GLenum pname,
3856 GLsizei bufSize,
3857 GLsizei *length,
3858 GLint *params)
3859 {
3860 ParamBuffer paramBuffer;
3861
3862 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3863 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3864 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3865
3866 if (isCallValid)
3867 {
3868 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3869 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3870 CaptureGetSamplerParameterIivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3871 bufSize, length, params, &lengthParam);
3872 paramBuffer.addParam(std::move(lengthParam));
3873 }
3874 else
3875 {
3876 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3877 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3878 &lengthParam.value);
3879 paramBuffer.addParam(std::move(lengthParam));
3880 }
3881
3882 if (isCallValid)
3883 {
3884 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3885 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3886 CaptureGetSamplerParameterIivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3887 bufSize, length, params, ¶msParam);
3888 paramBuffer.addParam(std::move(paramsParam));
3889 }
3890 else
3891 {
3892 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3893 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3894 paramBuffer.addParam(std::move(paramsParam));
3895 }
3896
3897 return CallCapture(gl::EntryPoint::GetSamplerParameterIivRobustANGLE, std::move(paramBuffer));
3898 }
3899
CaptureGetSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3900 CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
3901 bool isCallValid,
3902 SamplerID samplerPacked,
3903 GLenum pname,
3904 GLsizei bufSize,
3905 GLsizei *length,
3906 GLuint *params)
3907 {
3908 ParamBuffer paramBuffer;
3909
3910 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
3911 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3912 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3913
3914 if (isCallValid)
3915 {
3916 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3917 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3918 CaptureGetSamplerParameterIuivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
3919 bufSize, length, params, &lengthParam);
3920 paramBuffer.addParam(std::move(lengthParam));
3921 }
3922 else
3923 {
3924 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3925 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3926 &lengthParam.value);
3927 paramBuffer.addParam(std::move(lengthParam));
3928 }
3929
3930 if (isCallValid)
3931 {
3932 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3933 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3934 CaptureGetSamplerParameterIuivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
3935 bufSize, length, params, ¶msParam);
3936 paramBuffer.addParam(std::move(paramsParam));
3937 }
3938 else
3939 {
3940 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3941 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
3942 ¶msParam.value);
3943 paramBuffer.addParam(std::move(paramsParam));
3944 }
3945
3946 return CallCapture(gl::EntryPoint::GetSamplerParameterIuivRobustANGLE, std::move(paramBuffer));
3947 }
3948
CaptureGetQueryObjectivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3949 CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
3950 bool isCallValid,
3951 QueryID idPacked,
3952 GLenum pname,
3953 GLsizei bufSize,
3954 GLsizei *length,
3955 GLint *params)
3956 {
3957 ParamBuffer paramBuffer;
3958
3959 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3960 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
3961 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3962
3963 if (isCallValid)
3964 {
3965 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3966 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
3967 CaptureGetQueryObjectivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
3968 length, params, &lengthParam);
3969 paramBuffer.addParam(std::move(lengthParam));
3970 }
3971 else
3972 {
3973 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
3974 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
3975 &lengthParam.value);
3976 paramBuffer.addParam(std::move(lengthParam));
3977 }
3978
3979 if (isCallValid)
3980 {
3981 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3982 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3983 CaptureGetQueryObjectivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
3984 length, params, ¶msParam);
3985 paramBuffer.addParam(std::move(paramsParam));
3986 }
3987 else
3988 {
3989 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3990 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
3991 paramBuffer.addParam(std::move(paramsParam));
3992 }
3993
3994 return CallCapture(gl::EntryPoint::GetQueryObjectivRobustANGLE, std::move(paramBuffer));
3995 }
3996
CaptureGetQueryObjecti64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3997 CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
3998 bool isCallValid,
3999 QueryID idPacked,
4000 GLenum pname,
4001 GLsizei bufSize,
4002 GLsizei *length,
4003 GLint64 *params)
4004 {
4005 ParamBuffer paramBuffer;
4006
4007 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4008 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
4009 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4010
4011 if (isCallValid)
4012 {
4013 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4014 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4015 CaptureGetQueryObjecti64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4016 length, params, &lengthParam);
4017 paramBuffer.addParam(std::move(lengthParam));
4018 }
4019 else
4020 {
4021 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4022 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4023 &lengthParam.value);
4024 paramBuffer.addParam(std::move(lengthParam));
4025 }
4026
4027 if (isCallValid)
4028 {
4029 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4030 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
4031 CaptureGetQueryObjecti64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4032 length, params, ¶msParam);
4033 paramBuffer.addParam(std::move(paramsParam));
4034 }
4035 else
4036 {
4037 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4038 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
4039 ¶msParam.value);
4040 paramBuffer.addParam(std::move(paramsParam));
4041 }
4042
4043 return CallCapture(gl::EntryPoint::GetQueryObjecti64vRobustANGLE, std::move(paramBuffer));
4044 }
4045
CaptureGetQueryObjectui64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)4046 CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
4047 bool isCallValid,
4048 QueryID idPacked,
4049 GLenum pname,
4050 GLsizei bufSize,
4051 GLsizei *length,
4052 GLuint64 *params)
4053 {
4054 ParamBuffer paramBuffer;
4055
4056 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4057 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
4058 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4059
4060 if (isCallValid)
4061 {
4062 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4063 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4064 CaptureGetQueryObjectui64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
4065 length, params, &lengthParam);
4066 paramBuffer.addParam(std::move(lengthParam));
4067 }
4068 else
4069 {
4070 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4071 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4072 &lengthParam.value);
4073 paramBuffer.addParam(std::move(lengthParam));
4074 }
4075
4076 if (isCallValid)
4077 {
4078 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4079 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
4080 CaptureGetQueryObjectui64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
4081 length, params, ¶msParam);
4082 paramBuffer.addParam(std::move(paramsParam));
4083 }
4084 else
4085 {
4086 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4087 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
4088 ¶msParam.value);
4089 paramBuffer.addParam(std::move(paramsParam));
4090 }
4091
4092 return CallCapture(gl::EntryPoint::GetQueryObjectui64vRobustANGLE, std::move(paramBuffer));
4093 }
4094
CaptureImportSemaphoreZirconHandleANGLE(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLuint handle)4095 CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
4096 bool isCallValid,
4097 SemaphoreID semaphorePacked,
4098 HandleType handleTypePacked,
4099 GLuint handle)
4100 {
4101 ParamBuffer paramBuffer;
4102
4103 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4104 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
4105 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
4106
4107 return CallCapture(gl::EntryPoint::ImportSemaphoreZirconHandleANGLE, std::move(paramBuffer));
4108 }
4109
CaptureTexImage2DExternalANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)4110 CallCapture CaptureTexImage2DExternalANGLE(const State &glState,
4111 bool isCallValid,
4112 TextureTarget targetPacked,
4113 GLint level,
4114 GLint internalformat,
4115 GLsizei width,
4116 GLsizei height,
4117 GLint border,
4118 GLenum format,
4119 GLenum type)
4120 {
4121 ParamBuffer paramBuffer;
4122
4123 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
4124 paramBuffer.addValueParam("level", ParamType::TGLint, level);
4125 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
4126 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
4127 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
4128 paramBuffer.addValueParam("border", ParamType::TGLint, border);
4129 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
4130 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
4131
4132 return CallCapture(gl::EntryPoint::TexImage2DExternalANGLE, std::move(paramBuffer));
4133 }
4134
CaptureInvalidateTextureANGLE(const State & glState,bool isCallValid,TextureType targetPacked)4135 CallCapture CaptureInvalidateTextureANGLE(const State &glState,
4136 bool isCallValid,
4137 TextureType targetPacked)
4138 {
4139 ParamBuffer paramBuffer;
4140
4141 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4142
4143 return CallCapture(gl::EntryPoint::InvalidateTextureANGLE, std::move(paramBuffer));
4144 }
4145
CaptureTexStorage2DMultisampleANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)4146 CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
4147 bool isCallValid,
4148 TextureType targetPacked,
4149 GLsizei samples,
4150 GLenum internalformat,
4151 GLsizei width,
4152 GLsizei height,
4153 GLboolean fixedsamplelocations)
4154 {
4155 ParamBuffer paramBuffer;
4156
4157 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4158 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
4159 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
4160 internalformat);
4161 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
4162 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
4163 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
4164
4165 return CallCapture(gl::EntryPoint::TexStorage2DMultisampleANGLE, std::move(paramBuffer));
4166 }
4167
CaptureGetMultisamplefvANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLfloat * val)4168 CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
4169 bool isCallValid,
4170 GLenum pname,
4171 GLuint index,
4172 GLfloat *val)
4173 {
4174 ParamBuffer paramBuffer;
4175
4176 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
4177 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
4178
4179 if (isCallValid)
4180 {
4181 ParamCapture valParam("val", ParamType::TGLfloatPointer);
4182 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
4183 CaptureGetMultisamplefvANGLE_val(glState, isCallValid, pname, index, val, &valParam);
4184 paramBuffer.addParam(std::move(valParam));
4185 }
4186 else
4187 {
4188 ParamCapture valParam("val", ParamType::TGLfloatPointer);
4189 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
4190 &valParam.value);
4191 paramBuffer.addParam(std::move(valParam));
4192 }
4193
4194 return CallCapture(gl::EntryPoint::GetMultisamplefvANGLE, std::move(paramBuffer));
4195 }
4196
CaptureSampleMaskiANGLE(const State & glState,bool isCallValid,GLuint maskNumber,GLbitfield mask)4197 CallCapture CaptureSampleMaskiANGLE(const State &glState,
4198 bool isCallValid,
4199 GLuint maskNumber,
4200 GLbitfield mask)
4201 {
4202 ParamBuffer paramBuffer;
4203
4204 paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber);
4205 paramBuffer.addEnumParam("mask", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, mask);
4206
4207 return CallCapture(gl::EntryPoint::SampleMaskiANGLE, std::move(paramBuffer));
4208 }
4209
CaptureGetTranslatedShaderSourceANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLsizei bufsize,GLsizei * length,GLchar * source)4210 CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
4211 bool isCallValid,
4212 ShaderProgramID shaderPacked,
4213 GLsizei bufsize,
4214 GLsizei *length,
4215 GLchar *source)
4216 {
4217 ParamBuffer paramBuffer;
4218
4219 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
4220 paramBuffer.addValueParam("bufsize", ParamType::TGLsizei, bufsize);
4221
4222 if (isCallValid)
4223 {
4224 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4225 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4226 CaptureGetTranslatedShaderSourceANGLE_length(glState, isCallValid, shaderPacked, bufsize,
4227 length, source, &lengthParam);
4228 paramBuffer.addParam(std::move(lengthParam));
4229 }
4230 else
4231 {
4232 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4233 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
4234 &lengthParam.value);
4235 paramBuffer.addParam(std::move(lengthParam));
4236 }
4237
4238 if (isCallValid)
4239 {
4240 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
4241 InitParamValue(ParamType::TGLcharPointer, source, &sourceParam.value);
4242 CaptureGetTranslatedShaderSourceANGLE_source(glState, isCallValid, shaderPacked, bufsize,
4243 length, source, &sourceParam);
4244 paramBuffer.addParam(std::move(sourceParam));
4245 }
4246 else
4247 {
4248 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
4249 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
4250 &sourceParam.value);
4251 paramBuffer.addParam(std::move(sourceParam));
4252 }
4253
4254 return CallCapture(gl::EntryPoint::GetTranslatedShaderSourceANGLE, std::move(paramBuffer));
4255 }
4256
CaptureBindUniformLocationCHROMIUM(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,const GLchar * name)4257 CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
4258 bool isCallValid,
4259 ShaderProgramID programPacked,
4260 UniformLocation locationPacked,
4261 const GLchar *name)
4262 {
4263 ParamBuffer paramBuffer;
4264
4265 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4266 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
4267
4268 if (isCallValid)
4269 {
4270 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4271 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
4272 CaptureBindUniformLocationCHROMIUM_name(glState, isCallValid, programPacked, locationPacked,
4273 name, &nameParam);
4274 paramBuffer.addParam(std::move(nameParam));
4275 }
4276 else
4277 {
4278 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4279 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4280 &nameParam.value);
4281 paramBuffer.addParam(std::move(nameParam));
4282 }
4283
4284 return CallCapture(gl::EntryPoint::BindUniformLocationCHROMIUM, std::move(paramBuffer));
4285 }
4286
CaptureCompressedCopyTextureCHROMIUM(const State & glState,bool isCallValid,TextureID sourceIdPacked,TextureID destIdPacked)4287 CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
4288 bool isCallValid,
4289 TextureID sourceIdPacked,
4290 TextureID destIdPacked)
4291 {
4292 ParamBuffer paramBuffer;
4293
4294 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
4295 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
4296
4297 return CallCapture(gl::EntryPoint::CompressedCopyTextureCHROMIUM, std::move(paramBuffer));
4298 }
4299
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)4300 CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
4301 bool isCallValid,
4302 TextureID sourceIdPacked,
4303 GLint sourceLevel,
4304 TextureTarget destTargetPacked,
4305 TextureID destIdPacked,
4306 GLint destLevel,
4307 GLint internalFormat,
4308 GLenum destType,
4309 GLboolean unpackFlipY,
4310 GLboolean unpackPremultiplyAlpha,
4311 GLboolean unpackUnmultiplyAlpha)
4312 {
4313 ParamBuffer paramBuffer;
4314
4315 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
4316 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
4317 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
4318 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
4319 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
4320 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
4321 paramBuffer.addEnumParam("destType", GLenumGroup::DefaultGroup, ParamType::TGLenum, destType);
4322 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
4323 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
4324 unpackPremultiplyAlpha);
4325 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
4326 unpackUnmultiplyAlpha);
4327
4328 return CallCapture(gl::EntryPoint::CopyTextureCHROMIUM, std::move(paramBuffer));
4329 }
4330
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)4331 CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
4332 bool isCallValid,
4333 TextureID sourceIdPacked,
4334 GLint sourceLevel,
4335 TextureTarget destTargetPacked,
4336 TextureID destIdPacked,
4337 GLint destLevel,
4338 GLint xoffset,
4339 GLint yoffset,
4340 GLint x,
4341 GLint y,
4342 GLint width,
4343 GLint height,
4344 GLboolean unpackFlipY,
4345 GLboolean unpackPremultiplyAlpha,
4346 GLboolean unpackUnmultiplyAlpha)
4347 {
4348 ParamBuffer paramBuffer;
4349
4350 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
4351 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
4352 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
4353 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
4354 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
4355 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
4356 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
4357 paramBuffer.addValueParam("x", ParamType::TGLint, x);
4358 paramBuffer.addValueParam("y", ParamType::TGLint, y);
4359 paramBuffer.addValueParam("width", ParamType::TGLint, width);
4360 paramBuffer.addValueParam("height", ParamType::TGLint, height);
4361 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
4362 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
4363 unpackPremultiplyAlpha);
4364 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
4365 unpackUnmultiplyAlpha);
4366
4367 return CallCapture(gl::EntryPoint::CopySubTextureCHROMIUM, std::move(paramBuffer));
4368 }
4369
CaptureCoverageModulationCHROMIUM(const State & glState,bool isCallValid,GLenum components)4370 CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
4371 bool isCallValid,
4372 GLenum components)
4373 {
4374 ParamBuffer paramBuffer;
4375
4376 paramBuffer.addEnumParam("components", GLenumGroup::DefaultGroup, ParamType::TGLenum,
4377 components);
4378
4379 return CallCapture(gl::EntryPoint::CoverageModulationCHROMIUM, std::move(paramBuffer));
4380 }
4381
CaptureLoseContextCHROMIUM(const State & glState,bool isCallValid,GraphicsResetStatus currentPacked,GraphicsResetStatus otherPacked)4382 CallCapture CaptureLoseContextCHROMIUM(const State &glState,
4383 bool isCallValid,
4384 GraphicsResetStatus currentPacked,
4385 GraphicsResetStatus otherPacked)
4386 {
4387 ParamBuffer paramBuffer;
4388
4389 paramBuffer.addValueParam("currentPacked", ParamType::TGraphicsResetStatus, currentPacked);
4390 paramBuffer.addValueParam("otherPacked", ParamType::TGraphicsResetStatus, otherPacked);
4391
4392 return CallCapture(gl::EntryPoint::LoseContextCHROMIUM, std::move(paramBuffer));
4393 }
4394
CaptureBindFragDataLocationEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint color,const GLchar * name)4395 CallCapture CaptureBindFragDataLocationEXT(const State &glState,
4396 bool isCallValid,
4397 ShaderProgramID programPacked,
4398 GLuint color,
4399 const GLchar *name)
4400 {
4401 ParamBuffer paramBuffer;
4402
4403 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4404 paramBuffer.addValueParam("color", ParamType::TGLuint, color);
4405
4406 if (isCallValid)
4407 {
4408 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4409 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
4410 CaptureBindFragDataLocationEXT_name(glState, isCallValid, programPacked, color, name,
4411 &nameParam);
4412 paramBuffer.addParam(std::move(nameParam));
4413 }
4414 else
4415 {
4416 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4417 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4418 &nameParam.value);
4419 paramBuffer.addParam(std::move(nameParam));
4420 }
4421
4422 return CallCapture(gl::EntryPoint::BindFragDataLocationEXT, std::move(paramBuffer));
4423 }
4424
CaptureBindFragDataLocationIndexedEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint colorNumber,GLuint index,const GLchar * name)4425 CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
4426 bool isCallValid,
4427 ShaderProgramID programPacked,
4428 GLuint colorNumber,
4429 GLuint index,
4430 const GLchar *name)
4431 {
4432 ParamBuffer paramBuffer;
4433
4434 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4435 paramBuffer.addValueParam("colorNumber", ParamType::TGLuint, colorNumber);
4436 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
4437
4438 if (isCallValid)
4439 {
4440 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4441 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
4442 CaptureBindFragDataLocationIndexedEXT_name(glState, isCallValid, programPacked, colorNumber,
4443 index, name, &nameParam);
4444 paramBuffer.addParam(std::move(nameParam));
4445 }
4446 else
4447 {
4448 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4449 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4450 &nameParam.value);
4451 paramBuffer.addParam(std::move(nameParam));
4452 }
4453
4454 return CallCapture(gl::EntryPoint::BindFragDataLocationIndexedEXT, std::move(paramBuffer));
4455 }
4456
CaptureGetFragDataIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,const GLchar * name,GLint returnValue)4457 CallCapture CaptureGetFragDataIndexEXT(const State &glState,
4458 bool isCallValid,
4459 ShaderProgramID programPacked,
4460 const GLchar *name,
4461 GLint returnValue)
4462 {
4463 ParamBuffer paramBuffer;
4464
4465 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4466
4467 if (isCallValid)
4468 {
4469 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4470 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
4471 CaptureGetFragDataIndexEXT_name(glState, isCallValid, programPacked, name, &nameParam);
4472 paramBuffer.addParam(std::move(nameParam));
4473 }
4474 else
4475 {
4476 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4477 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4478 &nameParam.value);
4479 paramBuffer.addParam(std::move(nameParam));
4480 }
4481
4482 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
4483 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
4484 paramBuffer.addReturnValue(std::move(returnValueCapture));
4485
4486 return CallCapture(gl::EntryPoint::GetFragDataIndexEXT, std::move(paramBuffer));
4487 }
4488
CaptureGetProgramResourceLocationIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,const GLchar * name,GLint returnValue)4489 CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
4490 bool isCallValid,
4491 ShaderProgramID programPacked,
4492 GLenum programInterface,
4493 const GLchar *name,
4494 GLint returnValue)
4495 {
4496 ParamBuffer paramBuffer;
4497
4498 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
4499 paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
4500 programInterface);
4501
4502 if (isCallValid)
4503 {
4504 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4505 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
4506 CaptureGetProgramResourceLocationIndexEXT_name(glState, isCallValid, programPacked,
4507 programInterface, name, &nameParam);
4508 paramBuffer.addParam(std::move(nameParam));
4509 }
4510 else
4511 {
4512 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
4513 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4514 &nameParam.value);
4515 paramBuffer.addParam(std::move(nameParam));
4516 }
4517
4518 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
4519 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
4520 paramBuffer.addReturnValue(std::move(returnValueCapture));
4521
4522 return CallCapture(gl::EntryPoint::GetProgramResourceLocationIndexEXT, std::move(paramBuffer));
4523 }
4524
CaptureBufferStorageEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLsizeiptr size,const void * data,GLbitfield flags)4525 CallCapture CaptureBufferStorageEXT(const State &glState,
4526 bool isCallValid,
4527 BufferBinding targetPacked,
4528 GLsizeiptr size,
4529 const void *data,
4530 GLbitfield flags)
4531 {
4532 ParamBuffer paramBuffer;
4533
4534 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
4535 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
4536
4537 if (isCallValid)
4538 {
4539 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
4540 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
4541 CaptureBufferStorageEXT_data(glState, isCallValid, targetPacked, size, data, flags,
4542 &dataParam);
4543 paramBuffer.addParam(std::move(dataParam));
4544 }
4545 else
4546 {
4547 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
4548 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
4549 &dataParam.value);
4550 paramBuffer.addParam(std::move(dataParam));
4551 }
4552
4553 paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield,
4554 flags);
4555
4556 return CallCapture(gl::EntryPoint::BufferStorageEXT, std::move(paramBuffer));
4557 }
4558
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)4559 CallCapture CaptureCopyImageSubDataEXT(const State &glState,
4560 bool isCallValid,
4561 GLuint srcName,
4562 GLenum srcTarget,
4563 GLint srcLevel,
4564 GLint srcX,
4565 GLint srcY,
4566 GLint srcZ,
4567 GLuint dstName,
4568 GLenum dstTarget,
4569 GLint dstLevel,
4570 GLint dstX,
4571 GLint dstY,
4572 GLint dstZ,
4573 GLsizei srcWidth,
4574 GLsizei srcHeight,
4575 GLsizei srcDepth)
4576 {
4577 ParamBuffer paramBuffer;
4578
4579 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
4580 paramBuffer.addEnumParam("srcTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum,
4581 srcTarget);
4582 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
4583 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
4584 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
4585 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
4586 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
4587 paramBuffer.addEnumParam("dstTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum,
4588 dstTarget);
4589 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
4590 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
4591 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
4592 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
4593 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
4594 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
4595 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
4596
4597 return CallCapture(gl::EntryPoint::CopyImageSubDataEXT, std::move(paramBuffer));
4598 }
4599
CaptureInsertEventMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)4600 CallCapture CaptureInsertEventMarkerEXT(const State &glState,
4601 bool isCallValid,
4602 GLsizei length,
4603 const GLchar *marker)
4604 {
4605 ParamBuffer paramBuffer;
4606
4607 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
4608
4609 if (isCallValid)
4610 {
4611 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
4612 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
4613 CaptureInsertEventMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
4614 paramBuffer.addParam(std::move(markerParam));
4615 }
4616 else
4617 {
4618 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
4619 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4620 &markerParam.value);
4621 paramBuffer.addParam(std::move(markerParam));
4622 }
4623
4624 return CallCapture(gl::EntryPoint::InsertEventMarkerEXT, std::move(paramBuffer));
4625 }
4626
CapturePopGroupMarkerEXT(const State & glState,bool isCallValid)4627 CallCapture CapturePopGroupMarkerEXT(const State &glState, bool isCallValid)
4628 {
4629 ParamBuffer paramBuffer;
4630
4631 return CallCapture(gl::EntryPoint::PopGroupMarkerEXT, std::move(paramBuffer));
4632 }
4633
CapturePushGroupMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)4634 CallCapture CapturePushGroupMarkerEXT(const State &glState,
4635 bool isCallValid,
4636 GLsizei length,
4637 const GLchar *marker)
4638 {
4639 ParamBuffer paramBuffer;
4640
4641 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
4642
4643 if (isCallValid)
4644 {
4645 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
4646 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
4647 CapturePushGroupMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
4648 paramBuffer.addParam(std::move(markerParam));
4649 }
4650 else
4651 {
4652 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
4653 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
4654 &markerParam.value);
4655 paramBuffer.addParam(std::move(markerParam));
4656 }
4657
4658 return CallCapture(gl::EntryPoint::PushGroupMarkerEXT, std::move(paramBuffer));
4659 }
4660
CaptureDiscardFramebufferEXT(const State & glState,bool isCallValid,GLenum target,GLsizei numAttachments,const GLenum * attachments)4661 CallCapture CaptureDiscardFramebufferEXT(const State &glState,
4662 bool isCallValid,
4663 GLenum target,
4664 GLsizei numAttachments,
4665 const GLenum *attachments)
4666 {
4667 ParamBuffer paramBuffer;
4668
4669 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
4670 paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
4671
4672 if (isCallValid)
4673 {
4674 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
4675 InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
4676 CaptureDiscardFramebufferEXT_attachments(glState, isCallValid, target, numAttachments,
4677 attachments, &attachmentsParam);
4678 paramBuffer.addParam(std::move(attachmentsParam));
4679 }
4680 else
4681 {
4682 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
4683 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
4684 &attachmentsParam.value);
4685 paramBuffer.addParam(std::move(attachmentsParam));
4686 }
4687
4688 return CallCapture(gl::EntryPoint::DiscardFramebufferEXT, std::move(paramBuffer));
4689 }
4690
CaptureBeginQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked,QueryID idPacked)4691 CallCapture CaptureBeginQueryEXT(const State &glState,
4692 bool isCallValid,
4693 QueryType targetPacked,
4694 QueryID idPacked)
4695 {
4696 ParamBuffer paramBuffer;
4697
4698 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
4699 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4700
4701 return CallCapture(gl::EntryPoint::BeginQueryEXT, std::move(paramBuffer));
4702 }
4703
CaptureDeleteQueriesEXT(const State & glState,bool isCallValid,GLsizei n,const QueryID * idsPacked)4704 CallCapture CaptureDeleteQueriesEXT(const State &glState,
4705 bool isCallValid,
4706 GLsizei n,
4707 const QueryID *idsPacked)
4708 {
4709 ParamBuffer paramBuffer;
4710
4711 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4712
4713 if (isCallValid)
4714 {
4715 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
4716 InitParamValue(ParamType::TQueryIDConstPointer, idsPacked, &idsPackedParam.value);
4717 CaptureDeleteQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
4718 paramBuffer.addParam(std::move(idsPackedParam));
4719 }
4720 else
4721 {
4722 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
4723 InitParamValue(ParamType::TQueryIDConstPointer, static_cast<const QueryID *>(nullptr),
4724 &idsPackedParam.value);
4725 paramBuffer.addParam(std::move(idsPackedParam));
4726 }
4727
4728 return CallCapture(gl::EntryPoint::DeleteQueriesEXT, std::move(paramBuffer));
4729 }
4730
CaptureEndQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked)4731 CallCapture CaptureEndQueryEXT(const State &glState, bool isCallValid, QueryType targetPacked)
4732 {
4733 ParamBuffer paramBuffer;
4734
4735 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
4736
4737 return CallCapture(gl::EntryPoint::EndQueryEXT, std::move(paramBuffer));
4738 }
4739
CaptureGenQueriesEXT(const State & glState,bool isCallValid,GLsizei n,QueryID * idsPacked)4740 CallCapture CaptureGenQueriesEXT(const State &glState,
4741 bool isCallValid,
4742 GLsizei n,
4743 QueryID *idsPacked)
4744 {
4745 ParamBuffer paramBuffer;
4746
4747 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4748
4749 if (isCallValid)
4750 {
4751 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
4752 InitParamValue(ParamType::TQueryIDPointer, idsPacked, &idsPackedParam.value);
4753 CaptureGenQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
4754 paramBuffer.addParam(std::move(idsPackedParam));
4755 }
4756 else
4757 {
4758 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
4759 InitParamValue(ParamType::TQueryIDPointer, static_cast<QueryID *>(nullptr),
4760 &idsPackedParam.value);
4761 paramBuffer.addParam(std::move(idsPackedParam));
4762 }
4763
4764 return CallCapture(gl::EntryPoint::GenQueriesEXT, std::move(paramBuffer));
4765 }
4766
CaptureGetInteger64vEXT(const State & glState,bool isCallValid,GLenum pname,GLint64 * data)4767 CallCapture CaptureGetInteger64vEXT(const State &glState,
4768 bool isCallValid,
4769 GLenum pname,
4770 GLint64 *data)
4771 {
4772 ParamBuffer paramBuffer;
4773
4774 paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
4775
4776 if (isCallValid)
4777 {
4778 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
4779 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
4780 CaptureGetInteger64vEXT_data(glState, isCallValid, pname, data, &dataParam);
4781 paramBuffer.addParam(std::move(dataParam));
4782 }
4783 else
4784 {
4785 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
4786 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
4787 &dataParam.value);
4788 paramBuffer.addParam(std::move(dataParam));
4789 }
4790
4791 return CallCapture(gl::EntryPoint::GetInteger64vEXT, std::move(paramBuffer));
4792 }
4793
CaptureGetQueryObjecti64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint64 * params)4794 CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
4795 bool isCallValid,
4796 QueryID idPacked,
4797 GLenum pname,
4798 GLint64 *params)
4799 {
4800 ParamBuffer paramBuffer;
4801
4802 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4803 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
4804 pname);
4805
4806 if (isCallValid)
4807 {
4808 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4809 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
4810 CaptureGetQueryObjecti64vEXT_params(glState, isCallValid, idPacked, pname, params,
4811 ¶msParam);
4812 paramBuffer.addParam(std::move(paramsParam));
4813 }
4814 else
4815 {
4816 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
4817 InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
4818 ¶msParam.value);
4819 paramBuffer.addParam(std::move(paramsParam));
4820 }
4821
4822 return CallCapture(gl::EntryPoint::GetQueryObjecti64vEXT, std::move(paramBuffer));
4823 }
4824
CaptureGetQueryObjectivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint * params)4825 CallCapture CaptureGetQueryObjectivEXT(const State &glState,
4826 bool isCallValid,
4827 QueryID idPacked,
4828 GLenum pname,
4829 GLint *params)
4830 {
4831 ParamBuffer paramBuffer;
4832
4833 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4834 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
4835 pname);
4836
4837 if (isCallValid)
4838 {
4839 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4840 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4841 CaptureGetQueryObjectivEXT_params(glState, isCallValid, idPacked, pname, params,
4842 ¶msParam);
4843 paramBuffer.addParam(std::move(paramsParam));
4844 }
4845 else
4846 {
4847 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4848 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4849 paramBuffer.addParam(std::move(paramsParam));
4850 }
4851
4852 return CallCapture(gl::EntryPoint::GetQueryObjectivEXT, std::move(paramBuffer));
4853 }
4854
CaptureGetQueryObjectui64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint64 * params)4855 CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
4856 bool isCallValid,
4857 QueryID idPacked,
4858 GLenum pname,
4859 GLuint64 *params)
4860 {
4861 ParamBuffer paramBuffer;
4862
4863 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4864 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
4865 pname);
4866
4867 if (isCallValid)
4868 {
4869 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4870 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
4871 CaptureGetQueryObjectui64vEXT_params(glState, isCallValid, idPacked, pname, params,
4872 ¶msParam);
4873 paramBuffer.addParam(std::move(paramsParam));
4874 }
4875 else
4876 {
4877 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
4878 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
4879 ¶msParam.value);
4880 paramBuffer.addParam(std::move(paramsParam));
4881 }
4882
4883 return CallCapture(gl::EntryPoint::GetQueryObjectui64vEXT, std::move(paramBuffer));
4884 }
4885
CaptureGetQueryObjectuivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint * params)4886 CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
4887 bool isCallValid,
4888 QueryID idPacked,
4889 GLenum pname,
4890 GLuint *params)
4891 {
4892 ParamBuffer paramBuffer;
4893
4894 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4895 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
4896 pname);
4897
4898 if (isCallValid)
4899 {
4900 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4901 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
4902 CaptureGetQueryObjectuivEXT_params(glState, isCallValid, idPacked, pname, params,
4903 ¶msParam);
4904 paramBuffer.addParam(std::move(paramsParam));
4905 }
4906 else
4907 {
4908 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
4909 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
4910 ¶msParam.value);
4911 paramBuffer.addParam(std::move(paramsParam));
4912 }
4913
4914 return CallCapture(gl::EntryPoint::GetQueryObjectuivEXT, std::move(paramBuffer));
4915 }
4916
CaptureGetQueryivEXT(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLint * params)4917 CallCapture CaptureGetQueryivEXT(const State &glState,
4918 bool isCallValid,
4919 QueryType targetPacked,
4920 GLenum pname,
4921 GLint *params)
4922 {
4923 ParamBuffer paramBuffer;
4924
4925 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
4926 paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname);
4927
4928 if (isCallValid)
4929 {
4930 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4931 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4932 CaptureGetQueryivEXT_params(glState, isCallValid, targetPacked, pname, params,
4933 ¶msParam);
4934 paramBuffer.addParam(std::move(paramsParam));
4935 }
4936 else
4937 {
4938 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4939 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
4940 paramBuffer.addParam(std::move(paramsParam));
4941 }
4942
4943 return CallCapture(gl::EntryPoint::GetQueryivEXT, std::move(paramBuffer));
4944 }
4945
CaptureIsQueryEXT(const State & glState,bool isCallValid,QueryID idPacked,GLboolean returnValue)4946 CallCapture CaptureIsQueryEXT(const State &glState,
4947 bool isCallValid,
4948 QueryID idPacked,
4949 GLboolean returnValue)
4950 {
4951 ParamBuffer paramBuffer;
4952
4953 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4954
4955 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
4956 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
4957 paramBuffer.addReturnValue(std::move(returnValueCapture));
4958
4959 return CallCapture(gl::EntryPoint::IsQueryEXT, std::move(paramBuffer));
4960 }
4961
CaptureQueryCounterEXT(const State & glState,bool isCallValid,QueryID idPacked,QueryType targetPacked)4962 CallCapture CaptureQueryCounterEXT(const State &glState,
4963 bool isCallValid,
4964 QueryID idPacked,
4965 QueryType targetPacked)
4966 {
4967 ParamBuffer paramBuffer;
4968
4969 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
4970 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
4971
4972 return CallCapture(gl::EntryPoint::QueryCounterEXT, std::move(paramBuffer));
4973 }
4974
CaptureDrawBuffersEXT(const State & glState,bool isCallValid,GLsizei n,const GLenum * bufs)4975 CallCapture CaptureDrawBuffersEXT(const State &glState,
4976 bool isCallValid,
4977 GLsizei n,
4978 const GLenum *bufs)
4979 {
4980 ParamBuffer paramBuffer;
4981
4982 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4983
4984 if (isCallValid)
4985 {
4986 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
4987 InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
4988 CaptureDrawBuffersEXT_bufs(glState, isCallValid, n, bufs, &bufsParam);
4989 paramBuffer.addParam(std::move(bufsParam));
4990 }
4991 else
4992 {
4993 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
4994 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
4995 &bufsParam.value);
4996 paramBuffer.addParam(std::move(bufsParam));
4997 }
4998
4999 return CallCapture(gl::EntryPoint::DrawBuffersEXT, std::move(paramBuffer));
5000 }
5001
CaptureBlendEquationSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)5002 CallCapture CaptureBlendEquationSeparateiEXT(const State &glState,
5003 bool isCallValid,
5004 GLuint buf,
5005 GLenum modeRGB,
5006 GLenum modeAlpha)
5007 {
5008 ParamBuffer paramBuffer;
5009
5010 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
5011 paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
5012 modeRGB);
5013 paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
5014 modeAlpha);
5015
5016 return CallCapture(gl::EntryPoint::BlendEquationSeparateiEXT, std::move(paramBuffer));
5017 }
5018
CaptureBlendEquationiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum mode)5019 CallCapture CaptureBlendEquationiEXT(const State &glState,
5020 bool isCallValid,
5021 GLuint buf,
5022 GLenum mode)
5023 {
5024 ParamBuffer paramBuffer;
5025
5026 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
5027 paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode);
5028
5029 return CallCapture(gl::EntryPoint::BlendEquationiEXT, std::move(paramBuffer));
5030 }
5031
CaptureBlendFuncSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)5032 CallCapture CaptureBlendFuncSeparateiEXT(const State &glState,
5033 bool isCallValid,
5034 GLuint buf,
5035 GLenum srcRGB,
5036 GLenum dstRGB,
5037 GLenum srcAlpha,
5038 GLenum dstAlpha)
5039 {
5040 ParamBuffer paramBuffer;
5041
5042 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
5043 paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB);
5044 paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB);
5045 paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha);
5046 paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha);
5047
5048 return CallCapture(gl::EntryPoint::BlendFuncSeparateiEXT, std::move(paramBuffer));
5049 }
5050
CaptureBlendFunciEXT(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)5051 CallCapture CaptureBlendFunciEXT(const State &glState,
5052 bool isCallValid,
5053 GLuint buf,
5054 GLenum src,
5055 GLenum dst)
5056 {
5057 ParamBuffer paramBuffer;
5058
5059 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
5060 paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src);
5061 paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst);
5062
5063 return CallCapture(gl::EntryPoint::BlendFunciEXT, std::move(paramBuffer));
5064 }
5065
CaptureColorMaskiEXT(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)5066 CallCapture CaptureColorMaskiEXT(const State &glState,
5067 bool isCallValid,
5068 GLuint index,
5069 GLboolean r,
5070 GLboolean g,
5071 GLboolean b,
5072 GLboolean a)
5073 {
5074 ParamBuffer paramBuffer;
5075
5076 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5077 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
5078 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
5079 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
5080 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
5081
5082 return CallCapture(gl::EntryPoint::ColorMaskiEXT, std::move(paramBuffer));
5083 }
5084
CaptureDisableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)5085 CallCapture CaptureDisableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
5086 {
5087 ParamBuffer paramBuffer;
5088
5089 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
5090 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5091
5092 return CallCapture(gl::EntryPoint::DisableiEXT, std::move(paramBuffer));
5093 }
5094
CaptureEnableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)5095 CallCapture CaptureEnableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
5096 {
5097 ParamBuffer paramBuffer;
5098
5099 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
5100 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5101
5102 return CallCapture(gl::EntryPoint::EnableiEXT, std::move(paramBuffer));
5103 }
5104
CaptureIsEnablediEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)5105 CallCapture CaptureIsEnablediEXT(const State &glState,
5106 bool isCallValid,
5107 GLenum target,
5108 GLuint index,
5109 GLboolean returnValue)
5110 {
5111 ParamBuffer paramBuffer;
5112
5113 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
5114 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5115
5116 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
5117 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
5118 paramBuffer.addReturnValue(std::move(returnValueCapture));
5119
5120 return CallCapture(gl::EntryPoint::IsEnablediEXT, std::move(paramBuffer));
5121 }
5122
CaptureDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)5123 CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
5124 bool isCallValid,
5125 PrimitiveMode modePacked,
5126 GLsizei count,
5127 DrawElementsType typePacked,
5128 const void *indices,
5129 GLint basevertex)
5130 {
5131 ParamBuffer paramBuffer;
5132
5133 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5134 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5135 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5136
5137 if (isCallValid)
5138 {
5139 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5140 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5141 CaptureDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
5142 typePacked, indices, basevertex, &indicesParam);
5143 paramBuffer.addParam(std::move(indicesParam));
5144 }
5145 else
5146 {
5147 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5148 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5149 &indicesParam.value);
5150 paramBuffer.addParam(std::move(indicesParam));
5151 }
5152
5153 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
5154
5155 return CallCapture(gl::EntryPoint::DrawElementsBaseVertexEXT, std::move(paramBuffer));
5156 }
5157
CaptureDrawElementsInstancedBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)5158 CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
5159 bool isCallValid,
5160 PrimitiveMode modePacked,
5161 GLsizei count,
5162 DrawElementsType typePacked,
5163 const void *indices,
5164 GLsizei instancecount,
5165 GLint basevertex)
5166 {
5167 ParamBuffer paramBuffer;
5168
5169 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5170 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5171 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5172
5173 if (isCallValid)
5174 {
5175 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5176 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5177 CaptureDrawElementsInstancedBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
5178 typePacked, indices, instancecount,
5179 basevertex, &indicesParam);
5180 paramBuffer.addParam(std::move(indicesParam));
5181 }
5182 else
5183 {
5184 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5185 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5186 &indicesParam.value);
5187 paramBuffer.addParam(std::move(indicesParam));
5188 }
5189
5190 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
5191 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
5192
5193 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertexEXT, std::move(paramBuffer));
5194 }
5195
CaptureDrawRangeElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)5196 CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
5197 bool isCallValid,
5198 PrimitiveMode modePacked,
5199 GLuint start,
5200 GLuint end,
5201 GLsizei count,
5202 DrawElementsType typePacked,
5203 const void *indices,
5204 GLint basevertex)
5205 {
5206 ParamBuffer paramBuffer;
5207
5208 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5209 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
5210 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
5211 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5212 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5213
5214 if (isCallValid)
5215 {
5216 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5217 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5218 CaptureDrawRangeElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, start, end,
5219 count, typePacked, indices, basevertex,
5220 &indicesParam);
5221 paramBuffer.addParam(std::move(indicesParam));
5222 }
5223 else
5224 {
5225 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5226 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5227 &indicesParam.value);
5228 paramBuffer.addParam(std::move(indicesParam));
5229 }
5230
5231 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
5232
5233 return CallCapture(gl::EntryPoint::DrawRangeElementsBaseVertexEXT, std::move(paramBuffer));
5234 }
5235
CaptureMultiDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei primcount,const GLint * basevertex)5236 CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
5237 bool isCallValid,
5238 PrimitiveMode modePacked,
5239 const GLsizei *count,
5240 DrawElementsType typePacked,
5241 const void *const *indices,
5242 GLsizei primcount,
5243 const GLint *basevertex)
5244 {
5245 ParamBuffer paramBuffer;
5246
5247 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5248
5249 if (isCallValid)
5250 {
5251 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
5252 InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value);
5253 CaptureMultiDrawElementsBaseVertexEXT_count(glState, isCallValid, modePacked, count,
5254 typePacked, indices, primcount, basevertex,
5255 &countParam);
5256 paramBuffer.addParam(std::move(countParam));
5257 }
5258 else
5259 {
5260 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
5261 InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
5262 &countParam.value);
5263 paramBuffer.addParam(std::move(countParam));
5264 }
5265
5266 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5267
5268 if (isCallValid)
5269 {
5270 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
5271 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
5272 CaptureMultiDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
5273 typePacked, indices, primcount, basevertex,
5274 &indicesParam);
5275 paramBuffer.addParam(std::move(indicesParam));
5276 }
5277 else
5278 {
5279 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
5280 InitParamValue(ParamType::TvoidConstPointerPointer,
5281 static_cast<const void *const *>(nullptr), &indicesParam.value);
5282 paramBuffer.addParam(std::move(indicesParam));
5283 }
5284
5285 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
5286
5287 if (isCallValid)
5288 {
5289 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
5290 InitParamValue(ParamType::TGLintConstPointer, basevertex, &basevertexParam.value);
5291 CaptureMultiDrawElementsBaseVertexEXT_basevertex(glState, isCallValid, modePacked, count,
5292 typePacked, indices, primcount, basevertex,
5293 &basevertexParam);
5294 paramBuffer.addParam(std::move(basevertexParam));
5295 }
5296 else
5297 {
5298 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
5299 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
5300 &basevertexParam.value);
5301 paramBuffer.addParam(std::move(basevertexParam));
5302 }
5303
5304 return CallCapture(gl::EntryPoint::MultiDrawElementsBaseVertexEXT, std::move(paramBuffer));
5305 }
5306
CaptureBufferStorageExternalEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)5307 CallCapture CaptureBufferStorageExternalEXT(const State &glState,
5308 bool isCallValid,
5309 BufferBinding targetPacked,
5310 GLintptr offset,
5311 GLsizeiptr size,
5312 GLeglClientBufferEXT clientBuffer,
5313 GLbitfield flags)
5314 {
5315 ParamBuffer paramBuffer;
5316
5317 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5318 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
5319 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
5320 paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer);
5321 paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield,
5322 flags);
5323
5324 return CallCapture(gl::EntryPoint::BufferStorageExternalEXT, std::move(paramBuffer));
5325 }
5326
CaptureNamedBufferStorageExternalEXT(const State & glState,bool isCallValid,GLuint buffer,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)5327 CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState,
5328 bool isCallValid,
5329 GLuint buffer,
5330 GLintptr offset,
5331 GLsizeiptr size,
5332 GLeglClientBufferEXT clientBuffer,
5333 GLbitfield flags)
5334 {
5335 ParamBuffer paramBuffer;
5336
5337 paramBuffer.addValueParam("buffer", ParamType::TGLuint, buffer);
5338 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
5339 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
5340 paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer);
5341 paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield,
5342 flags);
5343
5344 return CallCapture(gl::EntryPoint::NamedBufferStorageExternalEXT, std::move(paramBuffer));
5345 }
5346
CaptureFramebufferTextureEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)5347 CallCapture CaptureFramebufferTextureEXT(const State &glState,
5348 bool isCallValid,
5349 GLenum target,
5350 GLenum attachment,
5351 TextureID texturePacked,
5352 GLint level)
5353 {
5354 ParamBuffer paramBuffer;
5355
5356 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
5357 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
5358 attachment);
5359 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
5360 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5361
5362 return CallCapture(gl::EntryPoint::FramebufferTextureEXT, std::move(paramBuffer));
5363 }
5364
CaptureDrawArraysInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint start,GLsizei count,GLsizei primcount)5365 CallCapture CaptureDrawArraysInstancedEXT(const State &glState,
5366 bool isCallValid,
5367 PrimitiveMode modePacked,
5368 GLint start,
5369 GLsizei count,
5370 GLsizei primcount)
5371 {
5372 ParamBuffer paramBuffer;
5373
5374 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5375 paramBuffer.addValueParam("start", ParamType::TGLint, start);
5376 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5377 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
5378
5379 return CallCapture(gl::EntryPoint::DrawArraysInstancedEXT, std::move(paramBuffer));
5380 }
5381
CaptureDrawElementsInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)5382 CallCapture CaptureDrawElementsInstancedEXT(const State &glState,
5383 bool isCallValid,
5384 PrimitiveMode modePacked,
5385 GLsizei count,
5386 DrawElementsType typePacked,
5387 const void *indices,
5388 GLsizei primcount)
5389 {
5390 ParamBuffer paramBuffer;
5391
5392 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
5393 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
5394 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
5395
5396 if (isCallValid)
5397 {
5398 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5399 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
5400 CaptureDrawElementsInstancedEXT_indices(glState, isCallValid, modePacked, count, typePacked,
5401 indices, primcount, &indicesParam);
5402 paramBuffer.addParam(std::move(indicesParam));
5403 }
5404 else
5405 {
5406 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
5407 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
5408 &indicesParam.value);
5409 paramBuffer.addParam(std::move(indicesParam));
5410 }
5411
5412 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
5413
5414 return CallCapture(gl::EntryPoint::DrawElementsInstancedEXT, std::move(paramBuffer));
5415 }
5416
CaptureVertexAttribDivisorEXT(const State & glState,bool isCallValid,GLuint index,GLuint divisor)5417 CallCapture CaptureVertexAttribDivisorEXT(const State &glState,
5418 bool isCallValid,
5419 GLuint index,
5420 GLuint divisor)
5421 {
5422 ParamBuffer paramBuffer;
5423
5424 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5425 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
5426
5427 return CallCapture(gl::EntryPoint::VertexAttribDivisorEXT, std::move(paramBuffer));
5428 }
5429
CaptureFlushMappedBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length)5430 CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState,
5431 bool isCallValid,
5432 BufferBinding targetPacked,
5433 GLintptr offset,
5434 GLsizeiptr length)
5435 {
5436 ParamBuffer paramBuffer;
5437
5438 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5439 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
5440 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
5441
5442 return CallCapture(gl::EntryPoint::FlushMappedBufferRangeEXT, std::move(paramBuffer));
5443 }
5444
CaptureMapBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length,GLbitfield access,void * returnValue)5445 CallCapture CaptureMapBufferRangeEXT(const State &glState,
5446 bool isCallValid,
5447 BufferBinding targetPacked,
5448 GLintptr offset,
5449 GLsizeiptr length,
5450 GLbitfield access,
5451 void *returnValue)
5452 {
5453 ParamBuffer paramBuffer;
5454
5455 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5456 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
5457 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
5458 paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield,
5459 access);
5460
5461 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
5462 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
5463 paramBuffer.addReturnValue(std::move(returnValueCapture));
5464
5465 return CallCapture(gl::EntryPoint::MapBufferRangeEXT, std::move(paramBuffer));
5466 }
5467
CaptureBufferStorageMemEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizeiptr size,MemoryObjectID memoryPacked,GLuint64 offset)5468 CallCapture CaptureBufferStorageMemEXT(const State &glState,
5469 bool isCallValid,
5470 TextureType targetPacked,
5471 GLsizeiptr size,
5472 MemoryObjectID memoryPacked,
5473 GLuint64 offset)
5474 {
5475 ParamBuffer paramBuffer;
5476
5477 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5478 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
5479 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
5480 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
5481
5482 return CallCapture(gl::EntryPoint::BufferStorageMemEXT, std::move(paramBuffer));
5483 }
5484
CaptureCreateMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,MemoryObjectID * memoryObjectsPacked)5485 CallCapture CaptureCreateMemoryObjectsEXT(const State &glState,
5486 bool isCallValid,
5487 GLsizei n,
5488 MemoryObjectID *memoryObjectsPacked)
5489 {
5490 ParamBuffer paramBuffer;
5491
5492 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5493
5494 if (isCallValid)
5495 {
5496 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
5497 ParamType::TMemoryObjectIDPointer);
5498 InitParamValue(ParamType::TMemoryObjectIDPointer, memoryObjectsPacked,
5499 &memoryObjectsPackedParam.value);
5500 CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(
5501 glState, isCallValid, n, memoryObjectsPacked, &memoryObjectsPackedParam);
5502 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
5503 }
5504 else
5505 {
5506 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
5507 ParamType::TMemoryObjectIDPointer);
5508 InitParamValue(ParamType::TMemoryObjectIDPointer, static_cast<MemoryObjectID *>(nullptr),
5509 &memoryObjectsPackedParam.value);
5510 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
5511 }
5512
5513 return CallCapture(gl::EntryPoint::CreateMemoryObjectsEXT, std::move(paramBuffer));
5514 }
5515
CaptureDeleteMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,const MemoryObjectID * memoryObjectsPacked)5516 CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState,
5517 bool isCallValid,
5518 GLsizei n,
5519 const MemoryObjectID *memoryObjectsPacked)
5520 {
5521 ParamBuffer paramBuffer;
5522
5523 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5524
5525 if (isCallValid)
5526 {
5527 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
5528 ParamType::TMemoryObjectIDConstPointer);
5529 InitParamValue(ParamType::TMemoryObjectIDConstPointer, memoryObjectsPacked,
5530 &memoryObjectsPackedParam.value);
5531 CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(
5532 glState, isCallValid, n, memoryObjectsPacked, &memoryObjectsPackedParam);
5533 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
5534 }
5535 else
5536 {
5537 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
5538 ParamType::TMemoryObjectIDConstPointer);
5539 InitParamValue(ParamType::TMemoryObjectIDConstPointer,
5540 static_cast<const MemoryObjectID *>(nullptr),
5541 &memoryObjectsPackedParam.value);
5542 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
5543 }
5544
5545 return CallCapture(gl::EntryPoint::DeleteMemoryObjectsEXT, std::move(paramBuffer));
5546 }
5547
CaptureGetMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,GLint * params)5548 CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState,
5549 bool isCallValid,
5550 MemoryObjectID memoryObjectPacked,
5551 GLenum pname,
5552 GLint *params)
5553 {
5554 ParamBuffer paramBuffer;
5555
5556 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
5557 paramBuffer.addEnumParam("pname", GLenumGroup::MemoryObjectParameterName, ParamType::TGLenum,
5558 pname);
5559
5560 if (isCallValid)
5561 {
5562 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5563 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5564 CaptureGetMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
5565 params, ¶msParam);
5566 paramBuffer.addParam(std::move(paramsParam));
5567 }
5568 else
5569 {
5570 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5571 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
5572 paramBuffer.addParam(std::move(paramsParam));
5573 }
5574
5575 return CallCapture(gl::EntryPoint::GetMemoryObjectParameterivEXT, std::move(paramBuffer));
5576 }
5577
CaptureGetUnsignedBytevEXT(const State & glState,bool isCallValid,GLenum pname,GLubyte * data)5578 CallCapture CaptureGetUnsignedBytevEXT(const State &glState,
5579 bool isCallValid,
5580 GLenum pname,
5581 GLubyte *data)
5582 {
5583 ParamBuffer paramBuffer;
5584
5585 paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
5586
5587 if (isCallValid)
5588 {
5589 ParamCapture dataParam("data", ParamType::TGLubytePointer);
5590 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
5591 CaptureGetUnsignedBytevEXT_data(glState, isCallValid, pname, data, &dataParam);
5592 paramBuffer.addParam(std::move(dataParam));
5593 }
5594 else
5595 {
5596 ParamCapture dataParam("data", ParamType::TGLubytePointer);
5597 InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
5598 &dataParam.value);
5599 paramBuffer.addParam(std::move(dataParam));
5600 }
5601
5602 return CallCapture(gl::EntryPoint::GetUnsignedBytevEXT, std::move(paramBuffer));
5603 }
5604
CaptureGetUnsignedBytei_vEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLubyte * data)5605 CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState,
5606 bool isCallValid,
5607 GLenum target,
5608 GLuint index,
5609 GLubyte *data)
5610 {
5611 ParamBuffer paramBuffer;
5612
5613 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
5614 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
5615
5616 if (isCallValid)
5617 {
5618 ParamCapture dataParam("data", ParamType::TGLubytePointer);
5619 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
5620 CaptureGetUnsignedBytei_vEXT_data(glState, isCallValid, target, index, data, &dataParam);
5621 paramBuffer.addParam(std::move(dataParam));
5622 }
5623 else
5624 {
5625 ParamCapture dataParam("data", ParamType::TGLubytePointer);
5626 InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
5627 &dataParam.value);
5628 paramBuffer.addParam(std::move(dataParam));
5629 }
5630
5631 return CallCapture(gl::EntryPoint::GetUnsignedBytei_vEXT, std::move(paramBuffer));
5632 }
5633
CaptureIsMemoryObjectEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLboolean returnValue)5634 CallCapture CaptureIsMemoryObjectEXT(const State &glState,
5635 bool isCallValid,
5636 MemoryObjectID memoryObjectPacked,
5637 GLboolean returnValue)
5638 {
5639 ParamBuffer paramBuffer;
5640
5641 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
5642
5643 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
5644 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
5645 paramBuffer.addReturnValue(std::move(returnValueCapture));
5646
5647 return CallCapture(gl::EntryPoint::IsMemoryObjectEXT, std::move(paramBuffer));
5648 }
5649
CaptureMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,const GLint * params)5650 CallCapture CaptureMemoryObjectParameterivEXT(const State &glState,
5651 bool isCallValid,
5652 MemoryObjectID memoryObjectPacked,
5653 GLenum pname,
5654 const GLint *params)
5655 {
5656 ParamBuffer paramBuffer;
5657
5658 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
5659 paramBuffer.addEnumParam("pname", GLenumGroup::MemoryObjectParameterName, ParamType::TGLenum,
5660 pname);
5661
5662 if (isCallValid)
5663 {
5664 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
5665 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
5666 CaptureMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
5667 params, ¶msParam);
5668 paramBuffer.addParam(std::move(paramsParam));
5669 }
5670 else
5671 {
5672 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
5673 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
5674 ¶msParam.value);
5675 paramBuffer.addParam(std::move(paramsParam));
5676 }
5677
5678 return CallCapture(gl::EntryPoint::MemoryObjectParameterivEXT, std::move(paramBuffer));
5679 }
5680
CaptureTexStorageMem2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,MemoryObjectID memoryPacked,GLuint64 offset)5681 CallCapture CaptureTexStorageMem2DEXT(const State &glState,
5682 bool isCallValid,
5683 TextureType targetPacked,
5684 GLsizei levels,
5685 GLenum internalFormat,
5686 GLsizei width,
5687 GLsizei height,
5688 MemoryObjectID memoryPacked,
5689 GLuint64 offset)
5690 {
5691 ParamBuffer paramBuffer;
5692
5693 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5694 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
5695 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
5696 internalFormat);
5697 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5698 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5699 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
5700 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
5701
5702 return CallCapture(gl::EntryPoint::TexStorageMem2DEXT, std::move(paramBuffer));
5703 }
5704
CaptureTexStorageMem2DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)5705 CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState,
5706 bool isCallValid,
5707 TextureType targetPacked,
5708 GLsizei samples,
5709 GLenum internalFormat,
5710 GLsizei width,
5711 GLsizei height,
5712 GLboolean fixedSampleLocations,
5713 MemoryObjectID memoryPacked,
5714 GLuint64 offset)
5715 {
5716 ParamBuffer paramBuffer;
5717
5718 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5719 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5720 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
5721 internalFormat);
5722 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5723 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5724 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
5725 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
5726 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
5727
5728 return CallCapture(gl::EntryPoint::TexStorageMem2DMultisampleEXT, std::move(paramBuffer));
5729 }
5730
CaptureTexStorageMem3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,MemoryObjectID memoryPacked,GLuint64 offset)5731 CallCapture CaptureTexStorageMem3DEXT(const State &glState,
5732 bool isCallValid,
5733 TextureType targetPacked,
5734 GLsizei levels,
5735 GLenum internalFormat,
5736 GLsizei width,
5737 GLsizei height,
5738 GLsizei depth,
5739 MemoryObjectID memoryPacked,
5740 GLuint64 offset)
5741 {
5742 ParamBuffer paramBuffer;
5743
5744 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5745 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
5746 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
5747 internalFormat);
5748 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5749 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5750 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5751 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
5752 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
5753
5754 return CallCapture(gl::EntryPoint::TexStorageMem3DEXT, std::move(paramBuffer));
5755 }
5756
CaptureTexStorageMem3DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)5757 CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState,
5758 bool isCallValid,
5759 TextureType targetPacked,
5760 GLsizei samples,
5761 GLenum internalFormat,
5762 GLsizei width,
5763 GLsizei height,
5764 GLsizei depth,
5765 GLboolean fixedSampleLocations,
5766 MemoryObjectID memoryPacked,
5767 GLuint64 offset)
5768 {
5769 ParamBuffer paramBuffer;
5770
5771 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5772 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5773 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
5774 internalFormat);
5775 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5776 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5777 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5778 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
5779 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
5780 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
5781
5782 return CallCapture(gl::EntryPoint::TexStorageMem3DMultisampleEXT, std::move(paramBuffer));
5783 }
5784
CaptureImportMemoryFdEXT(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLint fd)5785 CallCapture CaptureImportMemoryFdEXT(const State &glState,
5786 bool isCallValid,
5787 MemoryObjectID memoryPacked,
5788 GLuint64 size,
5789 HandleType handleTypePacked,
5790 GLint fd)
5791 {
5792 ParamBuffer paramBuffer;
5793
5794 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
5795 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
5796 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
5797 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
5798
5799 return CallCapture(gl::EntryPoint::ImportMemoryFdEXT, std::move(paramBuffer));
5800 }
5801
CaptureFramebufferTexture2DMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLsizei samples)5802 CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
5803 bool isCallValid,
5804 GLenum target,
5805 GLenum attachment,
5806 TextureTarget textargetPacked,
5807 TextureID texturePacked,
5808 GLint level,
5809 GLsizei samples)
5810 {
5811 ParamBuffer paramBuffer;
5812
5813 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
5814 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
5815 attachment);
5816 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
5817 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
5818 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5819 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5820
5821 return CallCapture(gl::EntryPoint::FramebufferTexture2DMultisampleEXT, std::move(paramBuffer));
5822 }
5823
CaptureRenderbufferStorageMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)5824 CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
5825 bool isCallValid,
5826 GLenum target,
5827 GLsizei samples,
5828 GLenum internalformat,
5829 GLsizei width,
5830 GLsizei height)
5831 {
5832 ParamBuffer paramBuffer;
5833
5834 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
5835 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5836 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
5837 internalformat);
5838 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5839 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5840
5841 return CallCapture(gl::EntryPoint::RenderbufferStorageMultisampleEXT, std::move(paramBuffer));
5842 }
5843
CaptureGetGraphicsResetStatusEXT(const State & glState,bool isCallValid,GLenum returnValue)5844 CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
5845 bool isCallValid,
5846 GLenum returnValue)
5847 {
5848 ParamBuffer paramBuffer;
5849
5850 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
5851 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
5852 paramBuffer.addReturnValue(std::move(returnValueCapture));
5853
5854 return CallCapture(gl::EntryPoint::GetGraphicsResetStatusEXT, std::move(paramBuffer));
5855 }
5856
CaptureGetnUniformfvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)5857 CallCapture CaptureGetnUniformfvEXT(const State &glState,
5858 bool isCallValid,
5859 ShaderProgramID programPacked,
5860 UniformLocation locationPacked,
5861 GLsizei bufSize,
5862 GLfloat *params)
5863 {
5864 ParamBuffer paramBuffer;
5865
5866 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5867 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
5868 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5869
5870 if (isCallValid)
5871 {
5872 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
5873 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
5874 CaptureGetnUniformfvEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
5875 params, ¶msParam);
5876 paramBuffer.addParam(std::move(paramsParam));
5877 }
5878 else
5879 {
5880 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
5881 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
5882 ¶msParam.value);
5883 paramBuffer.addParam(std::move(paramsParam));
5884 }
5885
5886 return CallCapture(gl::EntryPoint::GetnUniformfvEXT, std::move(paramBuffer));
5887 }
5888
CaptureGetnUniformivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)5889 CallCapture CaptureGetnUniformivEXT(const State &glState,
5890 bool isCallValid,
5891 ShaderProgramID programPacked,
5892 UniformLocation locationPacked,
5893 GLsizei bufSize,
5894 GLint *params)
5895 {
5896 ParamBuffer paramBuffer;
5897
5898 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5899 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
5900 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5901
5902 if (isCallValid)
5903 {
5904 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5905 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5906 CaptureGetnUniformivEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
5907 params, ¶msParam);
5908 paramBuffer.addParam(std::move(paramsParam));
5909 }
5910 else
5911 {
5912 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5913 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
5914 paramBuffer.addParam(std::move(paramsParam));
5915 }
5916
5917 return CallCapture(gl::EntryPoint::GetnUniformivEXT, std::move(paramBuffer));
5918 }
5919
CaptureReadnPixelsEXT(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)5920 CallCapture CaptureReadnPixelsEXT(const State &glState,
5921 bool isCallValid,
5922 GLint x,
5923 GLint y,
5924 GLsizei width,
5925 GLsizei height,
5926 GLenum format,
5927 GLenum type,
5928 GLsizei bufSize,
5929 void *data)
5930 {
5931 ParamBuffer paramBuffer;
5932
5933 paramBuffer.addValueParam("x", ParamType::TGLint, x);
5934 paramBuffer.addValueParam("y", ParamType::TGLint, y);
5935 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5936 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5937 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
5938 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
5939 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5940
5941 if (isCallValid)
5942 {
5943 ParamCapture dataParam("data", ParamType::TvoidPointer);
5944 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
5945 CaptureReadnPixelsEXT_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
5946 data, &dataParam);
5947 paramBuffer.addParam(std::move(dataParam));
5948 }
5949 else
5950 {
5951 ParamCapture dataParam("data", ParamType::TvoidPointer);
5952 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
5953 paramBuffer.addParam(std::move(dataParam));
5954 }
5955
5956 return CallCapture(gl::EntryPoint::ReadnPixelsEXT, std::move(paramBuffer));
5957 }
5958
CaptureDeleteSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,const SemaphoreID * semaphoresPacked)5959 CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
5960 bool isCallValid,
5961 GLsizei n,
5962 const SemaphoreID *semaphoresPacked)
5963 {
5964 ParamBuffer paramBuffer;
5965
5966 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5967
5968 if (isCallValid)
5969 {
5970 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
5971 InitParamValue(ParamType::TSemaphoreIDConstPointer, semaphoresPacked,
5972 &semaphoresPackedParam.value);
5973 CaptureDeleteSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
5974 &semaphoresPackedParam);
5975 paramBuffer.addParam(std::move(semaphoresPackedParam));
5976 }
5977 else
5978 {
5979 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
5980 InitParamValue(ParamType::TSemaphoreIDConstPointer,
5981 static_cast<const SemaphoreID *>(nullptr), &semaphoresPackedParam.value);
5982 paramBuffer.addParam(std::move(semaphoresPackedParam));
5983 }
5984
5985 return CallCapture(gl::EntryPoint::DeleteSemaphoresEXT, std::move(paramBuffer));
5986 }
5987
CaptureGenSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,SemaphoreID * semaphoresPacked)5988 CallCapture CaptureGenSemaphoresEXT(const State &glState,
5989 bool isCallValid,
5990 GLsizei n,
5991 SemaphoreID *semaphoresPacked)
5992 {
5993 ParamBuffer paramBuffer;
5994
5995 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5996
5997 if (isCallValid)
5998 {
5999 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
6000 InitParamValue(ParamType::TSemaphoreIDPointer, semaphoresPacked,
6001 &semaphoresPackedParam.value);
6002 CaptureGenSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
6003 &semaphoresPackedParam);
6004 paramBuffer.addParam(std::move(semaphoresPackedParam));
6005 }
6006 else
6007 {
6008 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
6009 InitParamValue(ParamType::TSemaphoreIDPointer, static_cast<SemaphoreID *>(nullptr),
6010 &semaphoresPackedParam.value);
6011 paramBuffer.addParam(std::move(semaphoresPackedParam));
6012 }
6013
6014 return CallCapture(gl::EntryPoint::GenSemaphoresEXT, std::move(paramBuffer));
6015 }
6016
CaptureGetSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,GLuint64 * params)6017 CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
6018 bool isCallValid,
6019 SemaphoreID semaphorePacked,
6020 GLenum pname,
6021 GLuint64 *params)
6022 {
6023 ParamBuffer paramBuffer;
6024
6025 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
6026 paramBuffer.addEnumParam("pname", GLenumGroup::SemaphoreParameterName, ParamType::TGLenum,
6027 pname);
6028
6029 if (isCallValid)
6030 {
6031 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
6032 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
6033 CaptureGetSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
6034 params, ¶msParam);
6035 paramBuffer.addParam(std::move(paramsParam));
6036 }
6037 else
6038 {
6039 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
6040 InitParamValue(ParamType::TGLuint64Pointer, static_cast<GLuint64 *>(nullptr),
6041 ¶msParam.value);
6042 paramBuffer.addParam(std::move(paramsParam));
6043 }
6044
6045 return CallCapture(gl::EntryPoint::GetSemaphoreParameterui64vEXT, std::move(paramBuffer));
6046 }
6047
CaptureIsSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLboolean returnValue)6048 CallCapture CaptureIsSemaphoreEXT(const State &glState,
6049 bool isCallValid,
6050 SemaphoreID semaphorePacked,
6051 GLboolean returnValue)
6052 {
6053 ParamBuffer paramBuffer;
6054
6055 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
6056
6057 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6058 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6059 paramBuffer.addReturnValue(std::move(returnValueCapture));
6060
6061 return CallCapture(gl::EntryPoint::IsSemaphoreEXT, std::move(paramBuffer));
6062 }
6063
CaptureSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,const GLuint64 * params)6064 CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
6065 bool isCallValid,
6066 SemaphoreID semaphorePacked,
6067 GLenum pname,
6068 const GLuint64 *params)
6069 {
6070 ParamBuffer paramBuffer;
6071
6072 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
6073 paramBuffer.addEnumParam("pname", GLenumGroup::SemaphoreParameterName, ParamType::TGLenum,
6074 pname);
6075
6076 if (isCallValid)
6077 {
6078 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
6079 InitParamValue(ParamType::TGLuint64ConstPointer, params, ¶msParam.value);
6080 CaptureSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
6081 params, ¶msParam);
6082 paramBuffer.addParam(std::move(paramsParam));
6083 }
6084 else
6085 {
6086 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
6087 InitParamValue(ParamType::TGLuint64ConstPointer, static_cast<const GLuint64 *>(nullptr),
6088 ¶msParam.value);
6089 paramBuffer.addParam(std::move(paramsParam));
6090 }
6091
6092 return CallCapture(gl::EntryPoint::SemaphoreParameterui64vEXT, std::move(paramBuffer));
6093 }
6094
CaptureSignalSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * dstLayouts)6095 CallCapture CaptureSignalSemaphoreEXT(const State &glState,
6096 bool isCallValid,
6097 SemaphoreID semaphorePacked,
6098 GLuint numBufferBarriers,
6099 const BufferID *buffersPacked,
6100 GLuint numTextureBarriers,
6101 const TextureID *texturesPacked,
6102 const GLenum *dstLayouts)
6103 {
6104 ParamBuffer paramBuffer;
6105
6106 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
6107 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
6108
6109 if (isCallValid)
6110 {
6111 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
6112 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
6113 CaptureSignalSemaphoreEXT_buffersPacked(
6114 glState, isCallValid, semaphorePacked, numBufferBarriers, buffersPacked,
6115 numTextureBarriers, texturesPacked, dstLayouts, &buffersPackedParam);
6116 paramBuffer.addParam(std::move(buffersPackedParam));
6117 }
6118 else
6119 {
6120 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
6121 InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
6122 &buffersPackedParam.value);
6123 paramBuffer.addParam(std::move(buffersPackedParam));
6124 }
6125
6126 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
6127
6128 if (isCallValid)
6129 {
6130 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
6131 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
6132 &texturesPackedParam.value);
6133 CaptureSignalSemaphoreEXT_texturesPacked(
6134 glState, isCallValid, semaphorePacked, numBufferBarriers, buffersPacked,
6135 numTextureBarriers, texturesPacked, dstLayouts, &texturesPackedParam);
6136 paramBuffer.addParam(std::move(texturesPackedParam));
6137 }
6138 else
6139 {
6140 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
6141 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
6142 &texturesPackedParam.value);
6143 paramBuffer.addParam(std::move(texturesPackedParam));
6144 }
6145
6146 if (isCallValid)
6147 {
6148 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
6149 InitParamValue(ParamType::TGLenumConstPointer, dstLayouts, &dstLayoutsParam.value);
6150 CaptureSignalSemaphoreEXT_dstLayouts(glState, isCallValid, semaphorePacked,
6151 numBufferBarriers, buffersPacked, numTextureBarriers,
6152 texturesPacked, dstLayouts, &dstLayoutsParam);
6153 paramBuffer.addParam(std::move(dstLayoutsParam));
6154 }
6155 else
6156 {
6157 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
6158 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
6159 &dstLayoutsParam.value);
6160 paramBuffer.addParam(std::move(dstLayoutsParam));
6161 }
6162
6163 return CallCapture(gl::EntryPoint::SignalSemaphoreEXT, std::move(paramBuffer));
6164 }
6165
CaptureWaitSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * srcLayouts)6166 CallCapture CaptureWaitSemaphoreEXT(const State &glState,
6167 bool isCallValid,
6168 SemaphoreID semaphorePacked,
6169 GLuint numBufferBarriers,
6170 const BufferID *buffersPacked,
6171 GLuint numTextureBarriers,
6172 const TextureID *texturesPacked,
6173 const GLenum *srcLayouts)
6174 {
6175 ParamBuffer paramBuffer;
6176
6177 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
6178 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
6179
6180 if (isCallValid)
6181 {
6182 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
6183 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
6184 CaptureWaitSemaphoreEXT_buffersPacked(glState, isCallValid, semaphorePacked,
6185 numBufferBarriers, buffersPacked, numTextureBarriers,
6186 texturesPacked, srcLayouts, &buffersPackedParam);
6187 paramBuffer.addParam(std::move(buffersPackedParam));
6188 }
6189 else
6190 {
6191 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
6192 InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
6193 &buffersPackedParam.value);
6194 paramBuffer.addParam(std::move(buffersPackedParam));
6195 }
6196
6197 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
6198
6199 if (isCallValid)
6200 {
6201 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
6202 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
6203 &texturesPackedParam.value);
6204 CaptureWaitSemaphoreEXT_texturesPacked(glState, isCallValid, semaphorePacked,
6205 numBufferBarriers, buffersPacked, numTextureBarriers,
6206 texturesPacked, srcLayouts, &texturesPackedParam);
6207 paramBuffer.addParam(std::move(texturesPackedParam));
6208 }
6209 else
6210 {
6211 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
6212 InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
6213 &texturesPackedParam.value);
6214 paramBuffer.addParam(std::move(texturesPackedParam));
6215 }
6216
6217 if (isCallValid)
6218 {
6219 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
6220 InitParamValue(ParamType::TGLenumConstPointer, srcLayouts, &srcLayoutsParam.value);
6221 CaptureWaitSemaphoreEXT_srcLayouts(glState, isCallValid, semaphorePacked, numBufferBarriers,
6222 buffersPacked, numTextureBarriers, texturesPacked,
6223 srcLayouts, &srcLayoutsParam);
6224 paramBuffer.addParam(std::move(srcLayoutsParam));
6225 }
6226 else
6227 {
6228 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
6229 InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
6230 &srcLayoutsParam.value);
6231 paramBuffer.addParam(std::move(srcLayoutsParam));
6232 }
6233
6234 return CallCapture(gl::EntryPoint::WaitSemaphoreEXT, std::move(paramBuffer));
6235 }
6236
CaptureImportSemaphoreFdEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLint fd)6237 CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
6238 bool isCallValid,
6239 SemaphoreID semaphorePacked,
6240 HandleType handleTypePacked,
6241 GLint fd)
6242 {
6243 ParamBuffer paramBuffer;
6244
6245 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
6246 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
6247 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
6248
6249 return CallCapture(gl::EntryPoint::ImportSemaphoreFdEXT, std::move(paramBuffer));
6250 }
6251
CaptureTexBufferEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)6252 CallCapture CaptureTexBufferEXT(const State &glState,
6253 bool isCallValid,
6254 TextureType targetPacked,
6255 GLenum internalformat,
6256 BufferID bufferPacked)
6257 {
6258 ParamBuffer paramBuffer;
6259
6260 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6261 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
6262 internalformat);
6263 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
6264
6265 return CallCapture(gl::EntryPoint::TexBufferEXT, std::move(paramBuffer));
6266 }
6267
CaptureTexBufferRangeEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)6268 CallCapture CaptureTexBufferRangeEXT(const State &glState,
6269 bool isCallValid,
6270 TextureType targetPacked,
6271 GLenum internalformat,
6272 BufferID bufferPacked,
6273 GLintptr offset,
6274 GLsizeiptr size)
6275 {
6276 ParamBuffer paramBuffer;
6277
6278 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6279 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
6280 internalformat);
6281 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
6282 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
6283 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
6284
6285 return CallCapture(gl::EntryPoint::TexBufferRangeEXT, std::move(paramBuffer));
6286 }
6287
CaptureTexStorage1DEXT(const State & glState,bool isCallValid,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)6288 CallCapture CaptureTexStorage1DEXT(const State &glState,
6289 bool isCallValid,
6290 GLenum target,
6291 GLsizei levels,
6292 GLenum internalformat,
6293 GLsizei width)
6294 {
6295 ParamBuffer paramBuffer;
6296
6297 paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target);
6298 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
6299 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
6300 internalformat);
6301 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
6302
6303 return CallCapture(gl::EntryPoint::TexStorage1DEXT, std::move(paramBuffer));
6304 }
6305
CaptureTexStorage2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)6306 CallCapture CaptureTexStorage2DEXT(const State &glState,
6307 bool isCallValid,
6308 TextureType targetPacked,
6309 GLsizei levels,
6310 GLenum internalformat,
6311 GLsizei width,
6312 GLsizei height)
6313 {
6314 ParamBuffer paramBuffer;
6315
6316 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6317 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
6318 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
6319 internalformat);
6320 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
6321 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
6322
6323 return CallCapture(gl::EntryPoint::TexStorage2DEXT, std::move(paramBuffer));
6324 }
6325
CaptureTexStorage3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)6326 CallCapture CaptureTexStorage3DEXT(const State &glState,
6327 bool isCallValid,
6328 TextureType targetPacked,
6329 GLsizei levels,
6330 GLenum internalformat,
6331 GLsizei width,
6332 GLsizei height,
6333 GLsizei depth)
6334 {
6335 ParamBuffer paramBuffer;
6336
6337 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6338 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
6339 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
6340 internalformat);
6341 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
6342 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
6343 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
6344
6345 return CallCapture(gl::EntryPoint::TexStorage3DEXT, std::move(paramBuffer));
6346 }
6347
CaptureDebugMessageCallbackKHR(const State & glState,bool isCallValid,GLDEBUGPROCKHR callback,const void * userParam)6348 CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
6349 bool isCallValid,
6350 GLDEBUGPROCKHR callback,
6351 const void *userParam)
6352 {
6353 ParamBuffer paramBuffer;
6354
6355 paramBuffer.addValueParam("callback", ParamType::TGLDEBUGPROCKHR, callback);
6356
6357 if (isCallValid)
6358 {
6359 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
6360 InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
6361 CaptureDebugMessageCallbackKHR_userParam(glState, isCallValid, callback, userParam,
6362 &userParamParam);
6363 paramBuffer.addParam(std::move(userParamParam));
6364 }
6365 else
6366 {
6367 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
6368 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6369 &userParamParam.value);
6370 paramBuffer.addParam(std::move(userParamParam));
6371 }
6372
6373 return CallCapture(gl::EntryPoint::DebugMessageCallbackKHR, std::move(paramBuffer));
6374 }
6375
CaptureDebugMessageControlKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)6376 CallCapture CaptureDebugMessageControlKHR(const State &glState,
6377 bool isCallValid,
6378 GLenum source,
6379 GLenum type,
6380 GLenum severity,
6381 GLsizei count,
6382 const GLuint *ids,
6383 GLboolean enabled)
6384 {
6385 ParamBuffer paramBuffer;
6386
6387 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
6388 paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type);
6389 paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
6390 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
6391
6392 if (isCallValid)
6393 {
6394 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
6395 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
6396 CaptureDebugMessageControlKHR_ids(glState, isCallValid, source, type, severity, count, ids,
6397 enabled, &idsParam);
6398 paramBuffer.addParam(std::move(idsParam));
6399 }
6400 else
6401 {
6402 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
6403 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
6404 &idsParam.value);
6405 paramBuffer.addParam(std::move(idsParam));
6406 }
6407
6408 paramBuffer.addValueParam("enabled", ParamType::TGLboolean, enabled);
6409
6410 return CallCapture(gl::EntryPoint::DebugMessageControlKHR, std::move(paramBuffer));
6411 }
6412
CaptureDebugMessageInsertKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)6413 CallCapture CaptureDebugMessageInsertKHR(const State &glState,
6414 bool isCallValid,
6415 GLenum source,
6416 GLenum type,
6417 GLuint id,
6418 GLenum severity,
6419 GLsizei length,
6420 const GLchar *buf)
6421 {
6422 ParamBuffer paramBuffer;
6423
6424 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
6425 paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type);
6426 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
6427 paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
6428 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
6429
6430 if (isCallValid)
6431 {
6432 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
6433 InitParamValue(ParamType::TGLcharConstPointer, buf, &bufParam.value);
6434 CaptureDebugMessageInsertKHR_buf(glState, isCallValid, source, type, id, severity, length,
6435 buf, &bufParam);
6436 paramBuffer.addParam(std::move(bufParam));
6437 }
6438 else
6439 {
6440 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
6441 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
6442 &bufParam.value);
6443 paramBuffer.addParam(std::move(bufParam));
6444 }
6445
6446 return CallCapture(gl::EntryPoint::DebugMessageInsertKHR, std::move(paramBuffer));
6447 }
6448
CaptureGetDebugMessageLogKHR(const State & glState,bool isCallValid,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog,GLuint returnValue)6449 CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
6450 bool isCallValid,
6451 GLuint count,
6452 GLsizei bufSize,
6453 GLenum *sources,
6454 GLenum *types,
6455 GLuint *ids,
6456 GLenum *severities,
6457 GLsizei *lengths,
6458 GLchar *messageLog,
6459 GLuint returnValue)
6460 {
6461 ParamBuffer paramBuffer;
6462
6463 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
6464 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
6465
6466 if (isCallValid)
6467 {
6468 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
6469 InitParamValue(ParamType::TGLenumPointer, sources, &sourcesParam.value);
6470 CaptureGetDebugMessageLogKHR_sources(glState, isCallValid, count, bufSize, sources, types,
6471 ids, severities, lengths, messageLog, &sourcesParam);
6472 paramBuffer.addParam(std::move(sourcesParam));
6473 }
6474 else
6475 {
6476 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
6477 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
6478 &sourcesParam.value);
6479 paramBuffer.addParam(std::move(sourcesParam));
6480 }
6481
6482 if (isCallValid)
6483 {
6484 ParamCapture typesParam("types", ParamType::TGLenumPointer);
6485 InitParamValue(ParamType::TGLenumPointer, types, &typesParam.value);
6486 CaptureGetDebugMessageLogKHR_types(glState, isCallValid, count, bufSize, sources, types,
6487 ids, severities, lengths, messageLog, &typesParam);
6488 paramBuffer.addParam(std::move(typesParam));
6489 }
6490 else
6491 {
6492 ParamCapture typesParam("types", ParamType::TGLenumPointer);
6493 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
6494 &typesParam.value);
6495 paramBuffer.addParam(std::move(typesParam));
6496 }
6497
6498 if (isCallValid)
6499 {
6500 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
6501 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
6502 CaptureGetDebugMessageLogKHR_ids(glState, isCallValid, count, bufSize, sources, types, ids,
6503 severities, lengths, messageLog, &idsParam);
6504 paramBuffer.addParam(std::move(idsParam));
6505 }
6506 else
6507 {
6508 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
6509 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &idsParam.value);
6510 paramBuffer.addParam(std::move(idsParam));
6511 }
6512
6513 if (isCallValid)
6514 {
6515 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
6516 InitParamValue(ParamType::TGLenumPointer, severities, &severitiesParam.value);
6517 CaptureGetDebugMessageLogKHR_severities(glState, isCallValid, count, bufSize, sources,
6518 types, ids, severities, lengths, messageLog,
6519 &severitiesParam);
6520 paramBuffer.addParam(std::move(severitiesParam));
6521 }
6522 else
6523 {
6524 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
6525 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
6526 &severitiesParam.value);
6527 paramBuffer.addParam(std::move(severitiesParam));
6528 }
6529
6530 if (isCallValid)
6531 {
6532 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
6533 InitParamValue(ParamType::TGLsizeiPointer, lengths, &lengthsParam.value);
6534 CaptureGetDebugMessageLogKHR_lengths(glState, isCallValid, count, bufSize, sources, types,
6535 ids, severities, lengths, messageLog, &lengthsParam);
6536 paramBuffer.addParam(std::move(lengthsParam));
6537 }
6538 else
6539 {
6540 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
6541 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
6542 &lengthsParam.value);
6543 paramBuffer.addParam(std::move(lengthsParam));
6544 }
6545
6546 if (isCallValid)
6547 {
6548 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
6549 InitParamValue(ParamType::TGLcharPointer, messageLog, &messageLogParam.value);
6550 CaptureGetDebugMessageLogKHR_messageLog(glState, isCallValid, count, bufSize, sources,
6551 types, ids, severities, lengths, messageLog,
6552 &messageLogParam);
6553 paramBuffer.addParam(std::move(messageLogParam));
6554 }
6555 else
6556 {
6557 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
6558 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
6559 &messageLogParam.value);
6560 paramBuffer.addParam(std::move(messageLogParam));
6561 }
6562
6563 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
6564 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
6565 paramBuffer.addReturnValue(std::move(returnValueCapture));
6566
6567 return CallCapture(gl::EntryPoint::GetDebugMessageLogKHR, std::move(paramBuffer));
6568 }
6569
CaptureGetObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)6570 CallCapture CaptureGetObjectLabelKHR(const State &glState,
6571 bool isCallValid,
6572 GLenum identifier,
6573 GLuint name,
6574 GLsizei bufSize,
6575 GLsizei *length,
6576 GLchar *label)
6577 {
6578 ParamBuffer paramBuffer;
6579
6580 paramBuffer.addEnumParam("identifier", GLenumGroup::DefaultGroup, ParamType::TGLenum,
6581 identifier);
6582 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
6583 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
6584
6585 if (isCallValid)
6586 {
6587 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
6588 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
6589 CaptureGetObjectLabelKHR_length(glState, isCallValid, identifier, name, bufSize, length,
6590 label, &lengthParam);
6591 paramBuffer.addParam(std::move(lengthParam));
6592 }
6593 else
6594 {
6595 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
6596 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
6597 &lengthParam.value);
6598 paramBuffer.addParam(std::move(lengthParam));
6599 }
6600
6601 if (isCallValid)
6602 {
6603 ParamCapture labelParam("label", ParamType::TGLcharPointer);
6604 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
6605 CaptureGetObjectLabelKHR_label(glState, isCallValid, identifier, name, bufSize, length,
6606 label, &labelParam);
6607 paramBuffer.addParam(std::move(labelParam));
6608 }
6609 else
6610 {
6611 ParamCapture labelParam("label", ParamType::TGLcharPointer);
6612 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
6613 &labelParam.value);
6614 paramBuffer.addParam(std::move(labelParam));
6615 }
6616
6617 return CallCapture(gl::EntryPoint::GetObjectLabelKHR, std::move(paramBuffer));
6618 }
6619
CaptureGetObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)6620 CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
6621 bool isCallValid,
6622 const void *ptr,
6623 GLsizei bufSize,
6624 GLsizei *length,
6625 GLchar *label)
6626 {
6627 ParamBuffer paramBuffer;
6628
6629 if (isCallValid)
6630 {
6631 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
6632 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
6633 CaptureGetObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, bufSize, length, label,
6634 &ptrParam);
6635 paramBuffer.addParam(std::move(ptrParam));
6636 }
6637 else
6638 {
6639 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
6640 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6641 &ptrParam.value);
6642 paramBuffer.addParam(std::move(ptrParam));
6643 }
6644
6645 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
6646
6647 if (isCallValid)
6648 {
6649 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
6650 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
6651 CaptureGetObjectPtrLabelKHR_length(glState, isCallValid, ptr, bufSize, length, label,
6652 &lengthParam);
6653 paramBuffer.addParam(std::move(lengthParam));
6654 }
6655 else
6656 {
6657 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
6658 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
6659 &lengthParam.value);
6660 paramBuffer.addParam(std::move(lengthParam));
6661 }
6662
6663 if (isCallValid)
6664 {
6665 ParamCapture labelParam("label", ParamType::TGLcharPointer);
6666 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
6667 CaptureGetObjectPtrLabelKHR_label(glState, isCallValid, ptr, bufSize, length, label,
6668 &labelParam);
6669 paramBuffer.addParam(std::move(labelParam));
6670 }
6671 else
6672 {
6673 ParamCapture labelParam("label", ParamType::TGLcharPointer);
6674 InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
6675 &labelParam.value);
6676 paramBuffer.addParam(std::move(labelParam));
6677 }
6678
6679 return CallCapture(gl::EntryPoint::GetObjectPtrLabelKHR, std::move(paramBuffer));
6680 }
6681
CaptureGetPointervKHR(const State & glState,bool isCallValid,GLenum pname,void ** params)6682 CallCapture CaptureGetPointervKHR(const State &glState,
6683 bool isCallValid,
6684 GLenum pname,
6685 void **params)
6686 {
6687 ParamBuffer paramBuffer;
6688
6689 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
6690
6691 if (isCallValid)
6692 {
6693 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
6694 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
6695 CaptureGetPointervKHR_params(glState, isCallValid, pname, params, ¶msParam);
6696 paramBuffer.addParam(std::move(paramsParam));
6697 }
6698 else
6699 {
6700 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
6701 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
6702 ¶msParam.value);
6703 paramBuffer.addParam(std::move(paramsParam));
6704 }
6705
6706 return CallCapture(gl::EntryPoint::GetPointervKHR, std::move(paramBuffer));
6707 }
6708
CaptureObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)6709 CallCapture CaptureObjectLabelKHR(const State &glState,
6710 bool isCallValid,
6711 GLenum identifier,
6712 GLuint name,
6713 GLsizei length,
6714 const GLchar *label)
6715 {
6716 ParamBuffer paramBuffer;
6717
6718 paramBuffer.addEnumParam("identifier", GLenumGroup::ObjectIdentifier, ParamType::TGLenum,
6719 identifier);
6720 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
6721 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
6722
6723 if (isCallValid)
6724 {
6725 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
6726 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
6727 CaptureObjectLabelKHR_label(glState, isCallValid, identifier, name, length, label,
6728 &labelParam);
6729 paramBuffer.addParam(std::move(labelParam));
6730 }
6731 else
6732 {
6733 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
6734 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
6735 &labelParam.value);
6736 paramBuffer.addParam(std::move(labelParam));
6737 }
6738
6739 return CallCapture(gl::EntryPoint::ObjectLabelKHR, std::move(paramBuffer));
6740 }
6741
CaptureObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei length,const GLchar * label)6742 CallCapture CaptureObjectPtrLabelKHR(const State &glState,
6743 bool isCallValid,
6744 const void *ptr,
6745 GLsizei length,
6746 const GLchar *label)
6747 {
6748 ParamBuffer paramBuffer;
6749
6750 if (isCallValid)
6751 {
6752 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
6753 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
6754 CaptureObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, length, label, &ptrParam);
6755 paramBuffer.addParam(std::move(ptrParam));
6756 }
6757 else
6758 {
6759 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
6760 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
6761 &ptrParam.value);
6762 paramBuffer.addParam(std::move(ptrParam));
6763 }
6764
6765 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
6766
6767 if (isCallValid)
6768 {
6769 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
6770 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
6771 CaptureObjectPtrLabelKHR_label(glState, isCallValid, ptr, length, label, &labelParam);
6772 paramBuffer.addParam(std::move(labelParam));
6773 }
6774 else
6775 {
6776 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
6777 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
6778 &labelParam.value);
6779 paramBuffer.addParam(std::move(labelParam));
6780 }
6781
6782 return CallCapture(gl::EntryPoint::ObjectPtrLabelKHR, std::move(paramBuffer));
6783 }
6784
CapturePopDebugGroupKHR(const State & glState,bool isCallValid)6785 CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid)
6786 {
6787 ParamBuffer paramBuffer;
6788
6789 return CallCapture(gl::EntryPoint::PopDebugGroupKHR, std::move(paramBuffer));
6790 }
6791
CapturePushDebugGroupKHR(const State & glState,bool isCallValid,GLenum source,GLuint id,GLsizei length,const GLchar * message)6792 CallCapture CapturePushDebugGroupKHR(const State &glState,
6793 bool isCallValid,
6794 GLenum source,
6795 GLuint id,
6796 GLsizei length,
6797 const GLchar *message)
6798 {
6799 ParamBuffer paramBuffer;
6800
6801 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
6802 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
6803 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
6804
6805 if (isCallValid)
6806 {
6807 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
6808 InitParamValue(ParamType::TGLcharConstPointer, message, &messageParam.value);
6809 CapturePushDebugGroupKHR_message(glState, isCallValid, source, id, length, message,
6810 &messageParam);
6811 paramBuffer.addParam(std::move(messageParam));
6812 }
6813 else
6814 {
6815 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
6816 InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
6817 &messageParam.value);
6818 paramBuffer.addParam(std::move(messageParam));
6819 }
6820
6821 return CallCapture(gl::EntryPoint::PushDebugGroupKHR, std::move(paramBuffer));
6822 }
6823
CaptureMaxShaderCompilerThreadsKHR(const State & glState,bool isCallValid,GLuint count)6824 CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState, bool isCallValid, GLuint count)
6825 {
6826 ParamBuffer paramBuffer;
6827
6828 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
6829
6830 return CallCapture(gl::EntryPoint::MaxShaderCompilerThreadsKHR, std::move(paramBuffer));
6831 }
6832
CaptureDeleteFencesNV(const State & glState,bool isCallValid,GLsizei n,const FenceNVID * fencesPacked)6833 CallCapture CaptureDeleteFencesNV(const State &glState,
6834 bool isCallValid,
6835 GLsizei n,
6836 const FenceNVID *fencesPacked)
6837 {
6838 ParamBuffer paramBuffer;
6839
6840 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6841
6842 if (isCallValid)
6843 {
6844 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
6845 InitParamValue(ParamType::TFenceNVIDConstPointer, fencesPacked, &fencesPackedParam.value);
6846 CaptureDeleteFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked,
6847 &fencesPackedParam);
6848 paramBuffer.addParam(std::move(fencesPackedParam));
6849 }
6850 else
6851 {
6852 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
6853 InitParamValue(ParamType::TFenceNVIDConstPointer, static_cast<const FenceNVID *>(nullptr),
6854 &fencesPackedParam.value);
6855 paramBuffer.addParam(std::move(fencesPackedParam));
6856 }
6857
6858 return CallCapture(gl::EntryPoint::DeleteFencesNV, std::move(paramBuffer));
6859 }
6860
CaptureFinishFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked)6861 CallCapture CaptureFinishFenceNV(const State &glState, bool isCallValid, FenceNVID fencePacked)
6862 {
6863 ParamBuffer paramBuffer;
6864
6865 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
6866
6867 return CallCapture(gl::EntryPoint::FinishFenceNV, std::move(paramBuffer));
6868 }
6869
CaptureGenFencesNV(const State & glState,bool isCallValid,GLsizei n,FenceNVID * fencesPacked)6870 CallCapture CaptureGenFencesNV(const State &glState,
6871 bool isCallValid,
6872 GLsizei n,
6873 FenceNVID *fencesPacked)
6874 {
6875 ParamBuffer paramBuffer;
6876
6877 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6878
6879 if (isCallValid)
6880 {
6881 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
6882 InitParamValue(ParamType::TFenceNVIDPointer, fencesPacked, &fencesPackedParam.value);
6883 CaptureGenFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked, &fencesPackedParam);
6884 paramBuffer.addParam(std::move(fencesPackedParam));
6885 }
6886 else
6887 {
6888 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
6889 InitParamValue(ParamType::TFenceNVIDPointer, static_cast<FenceNVID *>(nullptr),
6890 &fencesPackedParam.value);
6891 paramBuffer.addParam(std::move(fencesPackedParam));
6892 }
6893
6894 return CallCapture(gl::EntryPoint::GenFencesNV, std::move(paramBuffer));
6895 }
6896
CaptureGetFenceivNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum pname,GLint * params)6897 CallCapture CaptureGetFenceivNV(const State &glState,
6898 bool isCallValid,
6899 FenceNVID fencePacked,
6900 GLenum pname,
6901 GLint *params)
6902 {
6903 ParamBuffer paramBuffer;
6904
6905 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
6906 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
6907
6908 if (isCallValid)
6909 {
6910 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6911 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
6912 CaptureGetFenceivNV_params(glState, isCallValid, fencePacked, pname, params, ¶msParam);
6913 paramBuffer.addParam(std::move(paramsParam));
6914 }
6915 else
6916 {
6917 ParamCapture paramsParam("params", ParamType::TGLintPointer);
6918 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
6919 paramBuffer.addParam(std::move(paramsParam));
6920 }
6921
6922 return CallCapture(gl::EntryPoint::GetFenceivNV, std::move(paramBuffer));
6923 }
6924
CaptureIsFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)6925 CallCapture CaptureIsFenceNV(const State &glState,
6926 bool isCallValid,
6927 FenceNVID fencePacked,
6928 GLboolean returnValue)
6929 {
6930 ParamBuffer paramBuffer;
6931
6932 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
6933
6934 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6935 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6936 paramBuffer.addReturnValue(std::move(returnValueCapture));
6937
6938 return CallCapture(gl::EntryPoint::IsFenceNV, std::move(paramBuffer));
6939 }
6940
CaptureSetFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum condition)6941 CallCapture CaptureSetFenceNV(const State &glState,
6942 bool isCallValid,
6943 FenceNVID fencePacked,
6944 GLenum condition)
6945 {
6946 ParamBuffer paramBuffer;
6947
6948 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
6949 paramBuffer.addEnumParam("condition", GLenumGroup::DefaultGroup, ParamType::TGLenum, condition);
6950
6951 return CallCapture(gl::EntryPoint::SetFenceNV, std::move(paramBuffer));
6952 }
6953
CaptureTestFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)6954 CallCapture CaptureTestFenceNV(const State &glState,
6955 bool isCallValid,
6956 FenceNVID fencePacked,
6957 GLboolean returnValue)
6958 {
6959 ParamBuffer paramBuffer;
6960
6961 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
6962
6963 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6964 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6965 paramBuffer.addReturnValue(std::move(returnValueCapture));
6966
6967 return CallCapture(gl::EntryPoint::TestFenceNV, std::move(paramBuffer));
6968 }
6969
CaptureEGLImageTargetRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLeglImageOES image)6970 CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
6971 bool isCallValid,
6972 GLenum target,
6973 GLeglImageOES image)
6974 {
6975 ParamBuffer paramBuffer;
6976
6977 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
6978 paramBuffer.addValueParam("image", ParamType::TGLeglImageOES, image);
6979
6980 return CallCapture(gl::EntryPoint::EGLImageTargetRenderbufferStorageOES,
6981 std::move(paramBuffer));
6982 }
6983
CaptureEGLImageTargetTexture2DOES(const State & glState,bool isCallValid,TextureType targetPacked,GLeglImageOES image)6984 CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
6985 bool isCallValid,
6986 TextureType targetPacked,
6987 GLeglImageOES image)
6988 {
6989 ParamBuffer paramBuffer;
6990
6991 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
6992 paramBuffer.addValueParam("image", ParamType::TGLeglImageOES, image);
6993
6994 return CallCapture(gl::EntryPoint::EGLImageTargetTexture2DOES, std::move(paramBuffer));
6995 }
6996
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)6997 CallCapture CaptureCopyImageSubDataOES(const State &glState,
6998 bool isCallValid,
6999 GLuint srcName,
7000 GLenum srcTarget,
7001 GLint srcLevel,
7002 GLint srcX,
7003 GLint srcY,
7004 GLint srcZ,
7005 GLuint dstName,
7006 GLenum dstTarget,
7007 GLint dstLevel,
7008 GLint dstX,
7009 GLint dstY,
7010 GLint dstZ,
7011 GLsizei srcWidth,
7012 GLsizei srcHeight,
7013 GLsizei srcDepth)
7014 {
7015 ParamBuffer paramBuffer;
7016
7017 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
7018 paramBuffer.addEnumParam("srcTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum,
7019 srcTarget);
7020 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
7021 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
7022 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
7023 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
7024 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
7025 paramBuffer.addEnumParam("dstTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum,
7026 dstTarget);
7027 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
7028 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
7029 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
7030 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
7031 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
7032 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
7033 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
7034
7035 return CallCapture(gl::EntryPoint::CopyImageSubDataOES, std::move(paramBuffer));
7036 }
7037
CaptureBlendEquationSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)7038 CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
7039 bool isCallValid,
7040 GLuint buf,
7041 GLenum modeRGB,
7042 GLenum modeAlpha)
7043 {
7044 ParamBuffer paramBuffer;
7045
7046 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
7047 paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
7048 modeRGB);
7049 paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
7050 modeAlpha);
7051
7052 return CallCapture(gl::EntryPoint::BlendEquationSeparateiOES, std::move(paramBuffer));
7053 }
7054
CaptureBlendEquationiOES(const State & glState,bool isCallValid,GLuint buf,GLenum mode)7055 CallCapture CaptureBlendEquationiOES(const State &glState,
7056 bool isCallValid,
7057 GLuint buf,
7058 GLenum mode)
7059 {
7060 ParamBuffer paramBuffer;
7061
7062 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
7063 paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode);
7064
7065 return CallCapture(gl::EntryPoint::BlendEquationiOES, std::move(paramBuffer));
7066 }
7067
CaptureBlendFuncSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)7068 CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
7069 bool isCallValid,
7070 GLuint buf,
7071 GLenum srcRGB,
7072 GLenum dstRGB,
7073 GLenum srcAlpha,
7074 GLenum dstAlpha)
7075 {
7076 ParamBuffer paramBuffer;
7077
7078 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
7079 paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB);
7080 paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB);
7081 paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha);
7082 paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha);
7083
7084 return CallCapture(gl::EntryPoint::BlendFuncSeparateiOES, std::move(paramBuffer));
7085 }
7086
CaptureBlendFunciOES(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)7087 CallCapture CaptureBlendFunciOES(const State &glState,
7088 bool isCallValid,
7089 GLuint buf,
7090 GLenum src,
7091 GLenum dst)
7092 {
7093 ParamBuffer paramBuffer;
7094
7095 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
7096 paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src);
7097 paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst);
7098
7099 return CallCapture(gl::EntryPoint::BlendFunciOES, std::move(paramBuffer));
7100 }
7101
CaptureColorMaskiOES(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)7102 CallCapture CaptureColorMaskiOES(const State &glState,
7103 bool isCallValid,
7104 GLuint index,
7105 GLboolean r,
7106 GLboolean g,
7107 GLboolean b,
7108 GLboolean a)
7109 {
7110 ParamBuffer paramBuffer;
7111
7112 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
7113 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
7114 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
7115 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
7116 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
7117
7118 return CallCapture(gl::EntryPoint::ColorMaskiOES, std::move(paramBuffer));
7119 }
7120
CaptureDisableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)7121 CallCapture CaptureDisableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
7122 {
7123 ParamBuffer paramBuffer;
7124
7125 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
7126 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
7127
7128 return CallCapture(gl::EntryPoint::DisableiOES, std::move(paramBuffer));
7129 }
7130
CaptureEnableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)7131 CallCapture CaptureEnableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
7132 {
7133 ParamBuffer paramBuffer;
7134
7135 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
7136 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
7137
7138 return CallCapture(gl::EntryPoint::EnableiOES, std::move(paramBuffer));
7139 }
7140
CaptureIsEnablediOES(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)7141 CallCapture CaptureIsEnablediOES(const State &glState,
7142 bool isCallValid,
7143 GLenum target,
7144 GLuint index,
7145 GLboolean returnValue)
7146 {
7147 ParamBuffer paramBuffer;
7148
7149 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
7150 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
7151
7152 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7153 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7154 paramBuffer.addReturnValue(std::move(returnValueCapture));
7155
7156 return CallCapture(gl::EntryPoint::IsEnablediOES, std::move(paramBuffer));
7157 }
7158
CaptureDrawElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)7159 CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
7160 bool isCallValid,
7161 PrimitiveMode modePacked,
7162 GLsizei count,
7163 DrawElementsType typePacked,
7164 const void *indices,
7165 GLint basevertex)
7166 {
7167 ParamBuffer paramBuffer;
7168
7169 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7170 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7171 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
7172
7173 if (isCallValid)
7174 {
7175 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
7176 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
7177 CaptureDrawElementsBaseVertexOES_indices(glState, isCallValid, modePacked, count,
7178 typePacked, indices, basevertex, &indicesParam);
7179 paramBuffer.addParam(std::move(indicesParam));
7180 }
7181 else
7182 {
7183 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
7184 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7185 &indicesParam.value);
7186 paramBuffer.addParam(std::move(indicesParam));
7187 }
7188
7189 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
7190
7191 return CallCapture(gl::EntryPoint::DrawElementsBaseVertexOES, std::move(paramBuffer));
7192 }
7193
CaptureDrawElementsInstancedBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)7194 CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
7195 bool isCallValid,
7196 PrimitiveMode modePacked,
7197 GLsizei count,
7198 DrawElementsType typePacked,
7199 const void *indices,
7200 GLsizei instancecount,
7201 GLint basevertex)
7202 {
7203 ParamBuffer paramBuffer;
7204
7205 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7206 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7207 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
7208
7209 if (isCallValid)
7210 {
7211 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
7212 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
7213 CaptureDrawElementsInstancedBaseVertexOES_indices(glState, isCallValid, modePacked, count,
7214 typePacked, indices, instancecount,
7215 basevertex, &indicesParam);
7216 paramBuffer.addParam(std::move(indicesParam));
7217 }
7218 else
7219 {
7220 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
7221 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7222 &indicesParam.value);
7223 paramBuffer.addParam(std::move(indicesParam));
7224 }
7225
7226 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
7227 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
7228
7229 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertexOES, std::move(paramBuffer));
7230 }
7231
CaptureDrawRangeElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)7232 CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
7233 bool isCallValid,
7234 PrimitiveMode modePacked,
7235 GLuint start,
7236 GLuint end,
7237 GLsizei count,
7238 DrawElementsType typePacked,
7239 const void *indices,
7240 GLint basevertex)
7241 {
7242 ParamBuffer paramBuffer;
7243
7244 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
7245 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
7246 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
7247 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
7248 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
7249
7250 if (isCallValid)
7251 {
7252 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
7253 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
7254 CaptureDrawRangeElementsBaseVertexOES_indices(glState, isCallValid, modePacked, start, end,
7255 count, typePacked, indices, basevertex,
7256 &indicesParam);
7257 paramBuffer.addParam(std::move(indicesParam));
7258 }
7259 else
7260 {
7261 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
7262 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7263 &indicesParam.value);
7264 paramBuffer.addParam(std::move(indicesParam));
7265 }
7266
7267 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
7268
7269 return CallCapture(gl::EntryPoint::DrawRangeElementsBaseVertexOES, std::move(paramBuffer));
7270 }
7271
CaptureDrawTexfOES(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)7272 CallCapture CaptureDrawTexfOES(const State &glState,
7273 bool isCallValid,
7274 GLfloat x,
7275 GLfloat y,
7276 GLfloat z,
7277 GLfloat width,
7278 GLfloat height)
7279 {
7280 ParamBuffer paramBuffer;
7281
7282 paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
7283 paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
7284 paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
7285 paramBuffer.addValueParam("width", ParamType::TGLfloat, width);
7286 paramBuffer.addValueParam("height", ParamType::TGLfloat, height);
7287
7288 return CallCapture(gl::EntryPoint::DrawTexfOES, std::move(paramBuffer));
7289 }
7290
CaptureDrawTexfvOES(const State & glState,bool isCallValid,const GLfloat * coords)7291 CallCapture CaptureDrawTexfvOES(const State &glState, bool isCallValid, const GLfloat *coords)
7292 {
7293 ParamBuffer paramBuffer;
7294
7295 if (isCallValid)
7296 {
7297 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
7298 InitParamValue(ParamType::TGLfloatConstPointer, coords, &coordsParam.value);
7299 CaptureDrawTexfvOES_coords(glState, isCallValid, coords, &coordsParam);
7300 paramBuffer.addParam(std::move(coordsParam));
7301 }
7302 else
7303 {
7304 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
7305 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
7306 &coordsParam.value);
7307 paramBuffer.addParam(std::move(coordsParam));
7308 }
7309
7310 return CallCapture(gl::EntryPoint::DrawTexfvOES, std::move(paramBuffer));
7311 }
7312
CaptureDrawTexiOES(const State & glState,bool isCallValid,GLint x,GLint y,GLint z,GLint width,GLint height)7313 CallCapture CaptureDrawTexiOES(const State &glState,
7314 bool isCallValid,
7315 GLint x,
7316 GLint y,
7317 GLint z,
7318 GLint width,
7319 GLint height)
7320 {
7321 ParamBuffer paramBuffer;
7322
7323 paramBuffer.addValueParam("x", ParamType::TGLint, x);
7324 paramBuffer.addValueParam("y", ParamType::TGLint, y);
7325 paramBuffer.addValueParam("z", ParamType::TGLint, z);
7326 paramBuffer.addValueParam("width", ParamType::TGLint, width);
7327 paramBuffer.addValueParam("height", ParamType::TGLint, height);
7328
7329 return CallCapture(gl::EntryPoint::DrawTexiOES, std::move(paramBuffer));
7330 }
7331
CaptureDrawTexivOES(const State & glState,bool isCallValid,const GLint * coords)7332 CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords)
7333 {
7334 ParamBuffer paramBuffer;
7335
7336 if (isCallValid)
7337 {
7338 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
7339 InitParamValue(ParamType::TGLintConstPointer, coords, &coordsParam.value);
7340 CaptureDrawTexivOES_coords(glState, isCallValid, coords, &coordsParam);
7341 paramBuffer.addParam(std::move(coordsParam));
7342 }
7343 else
7344 {
7345 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
7346 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
7347 &coordsParam.value);
7348 paramBuffer.addParam(std::move(coordsParam));
7349 }
7350
7351 return CallCapture(gl::EntryPoint::DrawTexivOES, std::move(paramBuffer));
7352 }
7353
CaptureDrawTexsOES(const State & glState,bool isCallValid,GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)7354 CallCapture CaptureDrawTexsOES(const State &glState,
7355 bool isCallValid,
7356 GLshort x,
7357 GLshort y,
7358 GLshort z,
7359 GLshort width,
7360 GLshort height)
7361 {
7362 ParamBuffer paramBuffer;
7363
7364 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
7365 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
7366 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
7367 paramBuffer.addValueParam("width", ParamType::TGLshort, width);
7368 paramBuffer.addValueParam("height", ParamType::TGLshort, height);
7369
7370 return CallCapture(gl::EntryPoint::DrawTexsOES, std::move(paramBuffer));
7371 }
7372
CaptureDrawTexsvOES(const State & glState,bool isCallValid,const GLshort * coords)7373 CallCapture CaptureDrawTexsvOES(const State &glState, bool isCallValid, const GLshort *coords)
7374 {
7375 ParamBuffer paramBuffer;
7376
7377 if (isCallValid)
7378 {
7379 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
7380 InitParamValue(ParamType::TGLshortConstPointer, coords, &coordsParam.value);
7381 CaptureDrawTexsvOES_coords(glState, isCallValid, coords, &coordsParam);
7382 paramBuffer.addParam(std::move(coordsParam));
7383 }
7384 else
7385 {
7386 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
7387 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
7388 &coordsParam.value);
7389 paramBuffer.addParam(std::move(coordsParam));
7390 }
7391
7392 return CallCapture(gl::EntryPoint::DrawTexsvOES, std::move(paramBuffer));
7393 }
7394
CaptureDrawTexxOES(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)7395 CallCapture CaptureDrawTexxOES(const State &glState,
7396 bool isCallValid,
7397 GLfixed x,
7398 GLfixed y,
7399 GLfixed z,
7400 GLfixed width,
7401 GLfixed height)
7402 {
7403 ParamBuffer paramBuffer;
7404
7405 paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
7406 paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
7407 paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
7408 paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
7409 paramBuffer.addValueParam("height", ParamType::TGLfixed, height);
7410
7411 return CallCapture(gl::EntryPoint::DrawTexxOES, std::move(paramBuffer));
7412 }
7413
CaptureDrawTexxvOES(const State & glState,bool isCallValid,const GLfixed * coords)7414 CallCapture CaptureDrawTexxvOES(const State &glState, bool isCallValid, const GLfixed *coords)
7415 {
7416 ParamBuffer paramBuffer;
7417
7418 if (isCallValid)
7419 {
7420 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
7421 InitParamValue(ParamType::TGLfixedConstPointer, coords, &coordsParam.value);
7422 CaptureDrawTexxvOES_coords(glState, isCallValid, coords, &coordsParam);
7423 paramBuffer.addParam(std::move(coordsParam));
7424 }
7425 else
7426 {
7427 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
7428 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
7429 &coordsParam.value);
7430 paramBuffer.addParam(std::move(coordsParam));
7431 }
7432
7433 return CallCapture(gl::EntryPoint::DrawTexxvOES, std::move(paramBuffer));
7434 }
7435
CaptureBindFramebufferOES(const State & glState,bool isCallValid,GLenum target,FramebufferID framebufferPacked)7436 CallCapture CaptureBindFramebufferOES(const State &glState,
7437 bool isCallValid,
7438 GLenum target,
7439 FramebufferID framebufferPacked)
7440 {
7441 ParamBuffer paramBuffer;
7442
7443 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
7444 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
7445
7446 return CallCapture(gl::EntryPoint::BindFramebufferOES, std::move(paramBuffer));
7447 }
7448
CaptureBindRenderbufferOES(const State & glState,bool isCallValid,GLenum target,RenderbufferID renderbufferPacked)7449 CallCapture CaptureBindRenderbufferOES(const State &glState,
7450 bool isCallValid,
7451 GLenum target,
7452 RenderbufferID renderbufferPacked)
7453 {
7454 ParamBuffer paramBuffer;
7455
7456 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
7457 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
7458
7459 return CallCapture(gl::EntryPoint::BindRenderbufferOES, std::move(paramBuffer));
7460 }
7461
CaptureCheckFramebufferStatusOES(const State & glState,bool isCallValid,GLenum target,GLenum returnValue)7462 CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
7463 bool isCallValid,
7464 GLenum target,
7465 GLenum returnValue)
7466 {
7467 ParamBuffer paramBuffer;
7468
7469 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
7470
7471 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
7472 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
7473 paramBuffer.addReturnValue(std::move(returnValueCapture));
7474
7475 return CallCapture(gl::EntryPoint::CheckFramebufferStatusOES, std::move(paramBuffer));
7476 }
7477
CaptureDeleteFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,const FramebufferID * framebuffersPacked)7478 CallCapture CaptureDeleteFramebuffersOES(const State &glState,
7479 bool isCallValid,
7480 GLsizei n,
7481 const FramebufferID *framebuffersPacked)
7482 {
7483 ParamBuffer paramBuffer;
7484
7485 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7486
7487 if (isCallValid)
7488 {
7489 ParamCapture framebuffersPackedParam("framebuffersPacked",
7490 ParamType::TFramebufferIDConstPointer);
7491 InitParamValue(ParamType::TFramebufferIDConstPointer, framebuffersPacked,
7492 &framebuffersPackedParam.value);
7493 CaptureDeleteFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
7494 &framebuffersPackedParam);
7495 paramBuffer.addParam(std::move(framebuffersPackedParam));
7496 }
7497 else
7498 {
7499 ParamCapture framebuffersPackedParam("framebuffersPacked",
7500 ParamType::TFramebufferIDConstPointer);
7501 InitParamValue(ParamType::TFramebufferIDConstPointer,
7502 static_cast<const FramebufferID *>(nullptr), &framebuffersPackedParam.value);
7503 paramBuffer.addParam(std::move(framebuffersPackedParam));
7504 }
7505
7506 return CallCapture(gl::EntryPoint::DeleteFramebuffersOES, std::move(paramBuffer));
7507 }
7508
CaptureDeleteRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,const RenderbufferID * renderbuffersPacked)7509 CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
7510 bool isCallValid,
7511 GLsizei n,
7512 const RenderbufferID *renderbuffersPacked)
7513 {
7514 ParamBuffer paramBuffer;
7515
7516 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7517
7518 if (isCallValid)
7519 {
7520 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
7521 ParamType::TRenderbufferIDConstPointer);
7522 InitParamValue(ParamType::TRenderbufferIDConstPointer, renderbuffersPacked,
7523 &renderbuffersPackedParam.value);
7524 CaptureDeleteRenderbuffersOES_renderbuffersPacked(
7525 glState, isCallValid, n, renderbuffersPacked, &renderbuffersPackedParam);
7526 paramBuffer.addParam(std::move(renderbuffersPackedParam));
7527 }
7528 else
7529 {
7530 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
7531 ParamType::TRenderbufferIDConstPointer);
7532 InitParamValue(ParamType::TRenderbufferIDConstPointer,
7533 static_cast<const RenderbufferID *>(nullptr),
7534 &renderbuffersPackedParam.value);
7535 paramBuffer.addParam(std::move(renderbuffersPackedParam));
7536 }
7537
7538 return CallCapture(gl::EntryPoint::DeleteRenderbuffersOES, std::move(paramBuffer));
7539 }
7540
CaptureFramebufferRenderbufferOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum renderbuffertarget,RenderbufferID renderbufferPacked)7541 CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
7542 bool isCallValid,
7543 GLenum target,
7544 GLenum attachment,
7545 GLenum renderbuffertarget,
7546 RenderbufferID renderbufferPacked)
7547 {
7548 ParamBuffer paramBuffer;
7549
7550 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
7551 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
7552 attachment);
7553 paramBuffer.addEnumParam("renderbuffertarget", GLenumGroup::RenderbufferTarget,
7554 ParamType::TGLenum, renderbuffertarget);
7555 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
7556
7557 return CallCapture(gl::EntryPoint::FramebufferRenderbufferOES, std::move(paramBuffer));
7558 }
7559
CaptureFramebufferTexture2DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level)7560 CallCapture CaptureFramebufferTexture2DOES(const State &glState,
7561 bool isCallValid,
7562 GLenum target,
7563 GLenum attachment,
7564 TextureTarget textargetPacked,
7565 TextureID texturePacked,
7566 GLint level)
7567 {
7568 ParamBuffer paramBuffer;
7569
7570 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
7571 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
7572 attachment);
7573 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
7574 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
7575 paramBuffer.addValueParam("level", ParamType::TGLint, level);
7576
7577 return CallCapture(gl::EntryPoint::FramebufferTexture2DOES, std::move(paramBuffer));
7578 }
7579
CaptureGenFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,FramebufferID * framebuffersPacked)7580 CallCapture CaptureGenFramebuffersOES(const State &glState,
7581 bool isCallValid,
7582 GLsizei n,
7583 FramebufferID *framebuffersPacked)
7584 {
7585 ParamBuffer paramBuffer;
7586
7587 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7588
7589 if (isCallValid)
7590 {
7591 ParamCapture framebuffersPackedParam("framebuffersPacked",
7592 ParamType::TFramebufferIDPointer);
7593 InitParamValue(ParamType::TFramebufferIDPointer, framebuffersPacked,
7594 &framebuffersPackedParam.value);
7595 CaptureGenFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
7596 &framebuffersPackedParam);
7597 paramBuffer.addParam(std::move(framebuffersPackedParam));
7598 }
7599 else
7600 {
7601 ParamCapture framebuffersPackedParam("framebuffersPacked",
7602 ParamType::TFramebufferIDPointer);
7603 InitParamValue(ParamType::TFramebufferIDPointer, static_cast<FramebufferID *>(nullptr),
7604 &framebuffersPackedParam.value);
7605 paramBuffer.addParam(std::move(framebuffersPackedParam));
7606 }
7607
7608 return CallCapture(gl::EntryPoint::GenFramebuffersOES, std::move(paramBuffer));
7609 }
7610
CaptureGenRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,RenderbufferID * renderbuffersPacked)7611 CallCapture CaptureGenRenderbuffersOES(const State &glState,
7612 bool isCallValid,
7613 GLsizei n,
7614 RenderbufferID *renderbuffersPacked)
7615 {
7616 ParamBuffer paramBuffer;
7617
7618 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
7619
7620 if (isCallValid)
7621 {
7622 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
7623 ParamType::TRenderbufferIDPointer);
7624 InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
7625 &renderbuffersPackedParam.value);
7626 CaptureGenRenderbuffersOES_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
7627 &renderbuffersPackedParam);
7628 paramBuffer.addParam(std::move(renderbuffersPackedParam));
7629 }
7630 else
7631 {
7632 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
7633 ParamType::TRenderbufferIDPointer);
7634 InitParamValue(ParamType::TRenderbufferIDPointer, static_cast<RenderbufferID *>(nullptr),
7635 &renderbuffersPackedParam.value);
7636 paramBuffer.addParam(std::move(renderbuffersPackedParam));
7637 }
7638
7639 return CallCapture(gl::EntryPoint::GenRenderbuffersOES, std::move(paramBuffer));
7640 }
7641
CaptureGenerateMipmapOES(const State & glState,bool isCallValid,TextureType targetPacked)7642 CallCapture CaptureGenerateMipmapOES(const State &glState,
7643 bool isCallValid,
7644 TextureType targetPacked)
7645 {
7646 ParamBuffer paramBuffer;
7647
7648 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
7649
7650 return CallCapture(gl::EntryPoint::GenerateMipmapOES, std::move(paramBuffer));
7651 }
7652
CaptureGetFramebufferAttachmentParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLint * params)7653 CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
7654 bool isCallValid,
7655 GLenum target,
7656 GLenum attachment,
7657 GLenum pname,
7658 GLint *params)
7659 {
7660 ParamBuffer paramBuffer;
7661
7662 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
7663 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
7664 attachment);
7665 paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName,
7666 ParamType::TGLenum, pname);
7667
7668 if (isCallValid)
7669 {
7670 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7671 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
7672 CaptureGetFramebufferAttachmentParameterivOES_params(
7673 glState, isCallValid, target, attachment, pname, params, ¶msParam);
7674 paramBuffer.addParam(std::move(paramsParam));
7675 }
7676 else
7677 {
7678 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7679 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
7680 paramBuffer.addParam(std::move(paramsParam));
7681 }
7682
7683 return CallCapture(gl::EntryPoint::GetFramebufferAttachmentParameterivOES,
7684 std::move(paramBuffer));
7685 }
7686
CaptureGetRenderbufferParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)7687 CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
7688 bool isCallValid,
7689 GLenum target,
7690 GLenum pname,
7691 GLint *params)
7692 {
7693 ParamBuffer paramBuffer;
7694
7695 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
7696 paramBuffer.addEnumParam("pname", GLenumGroup::RenderbufferParameterName, ParamType::TGLenum,
7697 pname);
7698
7699 if (isCallValid)
7700 {
7701 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7702 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
7703 CaptureGetRenderbufferParameterivOES_params(glState, isCallValid, target, pname, params,
7704 ¶msParam);
7705 paramBuffer.addParam(std::move(paramsParam));
7706 }
7707 else
7708 {
7709 ParamCapture paramsParam("params", ParamType::TGLintPointer);
7710 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
7711 paramBuffer.addParam(std::move(paramsParam));
7712 }
7713
7714 return CallCapture(gl::EntryPoint::GetRenderbufferParameterivOES, std::move(paramBuffer));
7715 }
7716
CaptureIsFramebufferOES(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLboolean returnValue)7717 CallCapture CaptureIsFramebufferOES(const State &glState,
7718 bool isCallValid,
7719 FramebufferID framebufferPacked,
7720 GLboolean returnValue)
7721 {
7722 ParamBuffer paramBuffer;
7723
7724 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
7725
7726 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7727 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7728 paramBuffer.addReturnValue(std::move(returnValueCapture));
7729
7730 return CallCapture(gl::EntryPoint::IsFramebufferOES, std::move(paramBuffer));
7731 }
7732
CaptureIsRenderbufferOES(const State & glState,bool isCallValid,RenderbufferID renderbufferPacked,GLboolean returnValue)7733 CallCapture CaptureIsRenderbufferOES(const State &glState,
7734 bool isCallValid,
7735 RenderbufferID renderbufferPacked,
7736 GLboolean returnValue)
7737 {
7738 ParamBuffer paramBuffer;
7739
7740 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
7741
7742 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7743 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7744 paramBuffer.addReturnValue(std::move(returnValueCapture));
7745
7746 return CallCapture(gl::EntryPoint::IsRenderbufferOES, std::move(paramBuffer));
7747 }
7748
CaptureRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)7749 CallCapture CaptureRenderbufferStorageOES(const State &glState,
7750 bool isCallValid,
7751 GLenum target,
7752 GLenum internalformat,
7753 GLsizei width,
7754 GLsizei height)
7755 {
7756 ParamBuffer paramBuffer;
7757
7758 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
7759 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
7760 internalformat);
7761 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
7762 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
7763
7764 return CallCapture(gl::EntryPoint::RenderbufferStorageOES, std::move(paramBuffer));
7765 }
7766
CaptureGetProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)7767 CallCapture CaptureGetProgramBinaryOES(const State &glState,
7768 bool isCallValid,
7769 ShaderProgramID programPacked,
7770 GLsizei bufSize,
7771 GLsizei *length,
7772 GLenum *binaryFormat,
7773 void *binary)
7774 {
7775 ParamBuffer paramBuffer;
7776
7777 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7778 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
7779
7780 if (isCallValid)
7781 {
7782 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
7783 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
7784 CaptureGetProgramBinaryOES_length(glState, isCallValid, programPacked, bufSize, length,
7785 binaryFormat, binary, &lengthParam);
7786 paramBuffer.addParam(std::move(lengthParam));
7787 }
7788 else
7789 {
7790 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
7791 InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
7792 &lengthParam.value);
7793 paramBuffer.addParam(std::move(lengthParam));
7794 }
7795
7796 if (isCallValid)
7797 {
7798 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
7799 InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
7800 CaptureGetProgramBinaryOES_binaryFormat(glState, isCallValid, programPacked, bufSize,
7801 length, binaryFormat, binary, &binaryFormatParam);
7802 paramBuffer.addParam(std::move(binaryFormatParam));
7803 }
7804 else
7805 {
7806 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
7807 InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
7808 &binaryFormatParam.value);
7809 paramBuffer.addParam(std::move(binaryFormatParam));
7810 }
7811
7812 if (isCallValid)
7813 {
7814 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
7815 InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
7816 CaptureGetProgramBinaryOES_binary(glState, isCallValid, programPacked, bufSize, length,
7817 binaryFormat, binary, &binaryParam);
7818 paramBuffer.addParam(std::move(binaryParam));
7819 }
7820 else
7821 {
7822 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
7823 InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &binaryParam.value);
7824 paramBuffer.addParam(std::move(binaryParam));
7825 }
7826
7827 return CallCapture(gl::EntryPoint::GetProgramBinaryOES, std::move(paramBuffer));
7828 }
7829
CaptureProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum binaryFormat,const void * binary,GLint length)7830 CallCapture CaptureProgramBinaryOES(const State &glState,
7831 bool isCallValid,
7832 ShaderProgramID programPacked,
7833 GLenum binaryFormat,
7834 const void *binary,
7835 GLint length)
7836 {
7837 ParamBuffer paramBuffer;
7838
7839 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
7840 paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
7841 binaryFormat);
7842
7843 if (isCallValid)
7844 {
7845 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
7846 InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
7847 CaptureProgramBinaryOES_binary(glState, isCallValid, programPacked, binaryFormat, binary,
7848 length, &binaryParam);
7849 paramBuffer.addParam(std::move(binaryParam));
7850 }
7851 else
7852 {
7853 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
7854 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7855 &binaryParam.value);
7856 paramBuffer.addParam(std::move(binaryParam));
7857 }
7858
7859 paramBuffer.addValueParam("length", ParamType::TGLint, length);
7860
7861 return CallCapture(gl::EntryPoint::ProgramBinaryOES, std::move(paramBuffer));
7862 }
7863
CaptureGetBufferPointervOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,void ** params)7864 CallCapture CaptureGetBufferPointervOES(const State &glState,
7865 bool isCallValid,
7866 BufferBinding targetPacked,
7867 GLenum pname,
7868 void **params)
7869 {
7870 ParamBuffer paramBuffer;
7871
7872 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
7873 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
7874
7875 if (isCallValid)
7876 {
7877 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
7878 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
7879 CaptureGetBufferPointervOES_params(glState, isCallValid, targetPacked, pname, params,
7880 ¶msParam);
7881 paramBuffer.addParam(std::move(paramsParam));
7882 }
7883 else
7884 {
7885 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
7886 InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
7887 ¶msParam.value);
7888 paramBuffer.addParam(std::move(paramsParam));
7889 }
7890
7891 return CallCapture(gl::EntryPoint::GetBufferPointervOES, std::move(paramBuffer));
7892 }
7893
CaptureMapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum access,void * returnValue)7894 CallCapture CaptureMapBufferOES(const State &glState,
7895 bool isCallValid,
7896 BufferBinding targetPacked,
7897 GLenum access,
7898 void *returnValue)
7899 {
7900 ParamBuffer paramBuffer;
7901
7902 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
7903 paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access);
7904
7905 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
7906 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
7907 paramBuffer.addReturnValue(std::move(returnValueCapture));
7908
7909 return CallCapture(gl::EntryPoint::MapBufferOES, std::move(paramBuffer));
7910 }
7911
CaptureUnmapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLboolean returnValue)7912 CallCapture CaptureUnmapBufferOES(const State &glState,
7913 bool isCallValid,
7914 BufferBinding targetPacked,
7915 GLboolean returnValue)
7916 {
7917 ParamBuffer paramBuffer;
7918
7919 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
7920
7921 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
7922 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
7923 paramBuffer.addReturnValue(std::move(returnValueCapture));
7924
7925 return CallCapture(gl::EntryPoint::UnmapBufferOES, std::move(paramBuffer));
7926 }
7927
CaptureCurrentPaletteMatrixOES(const State & glState,bool isCallValid,GLuint matrixpaletteindex)7928 CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
7929 bool isCallValid,
7930 GLuint matrixpaletteindex)
7931 {
7932 ParamBuffer paramBuffer;
7933
7934 paramBuffer.addValueParam("matrixpaletteindex", ParamType::TGLuint, matrixpaletteindex);
7935
7936 return CallCapture(gl::EntryPoint::CurrentPaletteMatrixOES, std::move(paramBuffer));
7937 }
7938
CaptureLoadPaletteFromModelViewMatrixOES(const State & glState,bool isCallValid)7939 CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid)
7940 {
7941 ParamBuffer paramBuffer;
7942
7943 return CallCapture(gl::EntryPoint::LoadPaletteFromModelViewMatrixOES, std::move(paramBuffer));
7944 }
7945
CaptureMatrixIndexPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)7946 CallCapture CaptureMatrixIndexPointerOES(const State &glState,
7947 bool isCallValid,
7948 GLint size,
7949 GLenum type,
7950 GLsizei stride,
7951 const void *pointer)
7952 {
7953 ParamBuffer paramBuffer;
7954
7955 paramBuffer.addValueParam("size", ParamType::TGLint, size);
7956 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
7957 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
7958
7959 if (isCallValid)
7960 {
7961 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
7962 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
7963 CaptureMatrixIndexPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
7964 &pointerParam);
7965 paramBuffer.addParam(std::move(pointerParam));
7966 }
7967 else
7968 {
7969 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
7970 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
7971 &pointerParam.value);
7972 paramBuffer.addParam(std::move(pointerParam));
7973 }
7974
7975 return CallCapture(gl::EntryPoint::MatrixIndexPointerOES, std::move(paramBuffer));
7976 }
7977
CaptureWeightPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)7978 CallCapture CaptureWeightPointerOES(const State &glState,
7979 bool isCallValid,
7980 GLint size,
7981 GLenum type,
7982 GLsizei stride,
7983 const void *pointer)
7984 {
7985 ParamBuffer paramBuffer;
7986
7987 paramBuffer.addValueParam("size", ParamType::TGLint, size);
7988 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
7989 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
7990
7991 if (isCallValid)
7992 {
7993 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
7994 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
7995 CaptureWeightPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
7996 &pointerParam);
7997 paramBuffer.addParam(std::move(pointerParam));
7998 }
7999 else
8000 {
8001 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
8002 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
8003 &pointerParam.value);
8004 paramBuffer.addParam(std::move(pointerParam));
8005 }
8006
8007 return CallCapture(gl::EntryPoint::WeightPointerOES, std::move(paramBuffer));
8008 }
8009
CapturePointSizePointerOES(const State & glState,bool isCallValid,VertexAttribType typePacked,GLsizei stride,const void * pointer)8010 CallCapture CapturePointSizePointerOES(const State &glState,
8011 bool isCallValid,
8012 VertexAttribType typePacked,
8013 GLsizei stride,
8014 const void *pointer)
8015 {
8016 ParamBuffer paramBuffer;
8017
8018 paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
8019 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
8020
8021 if (isCallValid)
8022 {
8023 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
8024 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
8025 CapturePointSizePointerOES_pointer(glState, isCallValid, typePacked, stride, pointer,
8026 &pointerParam);
8027 paramBuffer.addParam(std::move(pointerParam));
8028 }
8029 else
8030 {
8031 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
8032 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
8033 &pointerParam.value);
8034 paramBuffer.addParam(std::move(pointerParam));
8035 }
8036
8037 return CallCapture(gl::EntryPoint::PointSizePointerOES, std::move(paramBuffer));
8038 }
8039
CaptureQueryMatrixxOES(const State & glState,bool isCallValid,GLfixed * mantissa,GLint * exponent,GLbitfield returnValue)8040 CallCapture CaptureQueryMatrixxOES(const State &glState,
8041 bool isCallValid,
8042 GLfixed *mantissa,
8043 GLint *exponent,
8044 GLbitfield returnValue)
8045 {
8046 ParamBuffer paramBuffer;
8047
8048 if (isCallValid)
8049 {
8050 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
8051 InitParamValue(ParamType::TGLfixedPointer, mantissa, &mantissaParam.value);
8052 CaptureQueryMatrixxOES_mantissa(glState, isCallValid, mantissa, exponent, &mantissaParam);
8053 paramBuffer.addParam(std::move(mantissaParam));
8054 }
8055 else
8056 {
8057 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
8058 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
8059 &mantissaParam.value);
8060 paramBuffer.addParam(std::move(mantissaParam));
8061 }
8062
8063 if (isCallValid)
8064 {
8065 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
8066 InitParamValue(ParamType::TGLintPointer, exponent, &exponentParam.value);
8067 CaptureQueryMatrixxOES_exponent(glState, isCallValid, mantissa, exponent, &exponentParam);
8068 paramBuffer.addParam(std::move(exponentParam));
8069 }
8070 else
8071 {
8072 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
8073 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
8074 &exponentParam.value);
8075 paramBuffer.addParam(std::move(exponentParam));
8076 }
8077
8078 ParamCapture returnValueCapture("returnValue", ParamType::TGLbitfield);
8079 InitParamValue(ParamType::TGLbitfield, returnValue, &returnValueCapture.value);
8080 paramBuffer.addReturnValue(std::move(returnValueCapture));
8081
8082 return CallCapture(gl::EntryPoint::QueryMatrixxOES, std::move(paramBuffer));
8083 }
8084
CaptureMinSampleShadingOES(const State & glState,bool isCallValid,GLfloat value)8085 CallCapture CaptureMinSampleShadingOES(const State &glState, bool isCallValid, GLfloat value)
8086 {
8087 ParamBuffer paramBuffer;
8088
8089 paramBuffer.addValueParam("value", ParamType::TGLfloat, value);
8090
8091 return CallCapture(gl::EntryPoint::MinSampleShadingOES, std::move(paramBuffer));
8092 }
8093
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)8094 CallCapture CaptureCompressedTexImage3DOES(const State &glState,
8095 bool isCallValid,
8096 TextureTarget targetPacked,
8097 GLint level,
8098 GLenum internalformat,
8099 GLsizei width,
8100 GLsizei height,
8101 GLsizei depth,
8102 GLint border,
8103 GLsizei imageSize,
8104 const void *data)
8105 {
8106 ParamBuffer paramBuffer;
8107
8108 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
8109 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8110 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
8111 internalformat);
8112 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
8113 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
8114 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
8115 paramBuffer.addValueParam("border", ParamType::TGLint, border);
8116 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
8117
8118 if (isCallValid)
8119 {
8120 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
8121 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
8122 CaptureCompressedTexImage3DOES_data(glState, isCallValid, targetPacked, level,
8123 internalformat, width, height, depth, border, imageSize,
8124 data, &dataParam);
8125 paramBuffer.addParam(std::move(dataParam));
8126 }
8127 else
8128 {
8129 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
8130 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
8131 &dataParam.value);
8132 paramBuffer.addParam(std::move(dataParam));
8133 }
8134
8135 return CallCapture(gl::EntryPoint::CompressedTexImage3DOES, std::move(paramBuffer));
8136 }
8137
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)8138 CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
8139 bool isCallValid,
8140 TextureTarget targetPacked,
8141 GLint level,
8142 GLint xoffset,
8143 GLint yoffset,
8144 GLint zoffset,
8145 GLsizei width,
8146 GLsizei height,
8147 GLsizei depth,
8148 GLenum format,
8149 GLsizei imageSize,
8150 const void *data)
8151 {
8152 ParamBuffer paramBuffer;
8153
8154 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
8155 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8156 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
8157 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
8158 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
8159 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
8160 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
8161 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
8162 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
8163 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
8164
8165 if (isCallValid)
8166 {
8167 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
8168 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
8169 CaptureCompressedTexSubImage3DOES_data(glState, isCallValid, targetPacked, level, xoffset,
8170 yoffset, zoffset, width, height, depth, format,
8171 imageSize, data, &dataParam);
8172 paramBuffer.addParam(std::move(dataParam));
8173 }
8174 else
8175 {
8176 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
8177 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
8178 &dataParam.value);
8179 paramBuffer.addParam(std::move(dataParam));
8180 }
8181
8182 return CallCapture(gl::EntryPoint::CompressedTexSubImage3DOES, std::move(paramBuffer));
8183 }
8184
CaptureCopyTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)8185 CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
8186 bool isCallValid,
8187 TextureTarget targetPacked,
8188 GLint level,
8189 GLint xoffset,
8190 GLint yoffset,
8191 GLint zoffset,
8192 GLint x,
8193 GLint y,
8194 GLsizei width,
8195 GLsizei height)
8196 {
8197 ParamBuffer paramBuffer;
8198
8199 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
8200 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8201 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
8202 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
8203 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
8204 paramBuffer.addValueParam("x", ParamType::TGLint, x);
8205 paramBuffer.addValueParam("y", ParamType::TGLint, y);
8206 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
8207 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
8208
8209 return CallCapture(gl::EntryPoint::CopyTexSubImage3DOES, std::move(paramBuffer));
8210 }
8211
CaptureFramebufferTexture3DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLint zoffset)8212 CallCapture CaptureFramebufferTexture3DOES(const State &glState,
8213 bool isCallValid,
8214 GLenum target,
8215 GLenum attachment,
8216 TextureTarget textargetPacked,
8217 TextureID texturePacked,
8218 GLint level,
8219 GLint zoffset)
8220 {
8221 ParamBuffer paramBuffer;
8222
8223 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
8224 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
8225 attachment);
8226 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
8227 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
8228 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8229 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
8230
8231 return CallCapture(gl::EntryPoint::FramebufferTexture3DOES, std::move(paramBuffer));
8232 }
8233
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)8234 CallCapture CaptureTexImage3DOES(const State &glState,
8235 bool isCallValid,
8236 TextureTarget targetPacked,
8237 GLint level,
8238 GLenum internalformat,
8239 GLsizei width,
8240 GLsizei height,
8241 GLsizei depth,
8242 GLint border,
8243 GLenum format,
8244 GLenum type,
8245 const void *pixels)
8246 {
8247 ParamBuffer paramBuffer;
8248
8249 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
8250 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8251 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
8252 internalformat);
8253 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
8254 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
8255 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
8256 paramBuffer.addValueParam("border", ParamType::TGLint, border);
8257 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
8258 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
8259
8260 if (isCallValid)
8261 {
8262 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
8263 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
8264 CaptureTexImage3DOES_pixels(glState, isCallValid, targetPacked, level, internalformat,
8265 width, height, depth, border, format, type, pixels,
8266 &pixelsParam);
8267 paramBuffer.addParam(std::move(pixelsParam));
8268 }
8269 else
8270 {
8271 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
8272 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
8273 &pixelsParam.value);
8274 paramBuffer.addParam(std::move(pixelsParam));
8275 }
8276
8277 return CallCapture(gl::EntryPoint::TexImage3DOES, std::move(paramBuffer));
8278 }
8279
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)8280 CallCapture CaptureTexSubImage3DOES(const State &glState,
8281 bool isCallValid,
8282 TextureTarget targetPacked,
8283 GLint level,
8284 GLint xoffset,
8285 GLint yoffset,
8286 GLint zoffset,
8287 GLsizei width,
8288 GLsizei height,
8289 GLsizei depth,
8290 GLenum format,
8291 GLenum type,
8292 const void *pixels)
8293 {
8294 ParamBuffer paramBuffer;
8295
8296 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
8297 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8298 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
8299 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
8300 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
8301 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
8302 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
8303 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
8304 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
8305 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
8306
8307 if (isCallValid)
8308 {
8309 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
8310 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
8311 CaptureTexSubImage3DOES_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
8312 zoffset, width, height, depth, format, type, pixels,
8313 &pixelsParam);
8314 paramBuffer.addParam(std::move(pixelsParam));
8315 }
8316 else
8317 {
8318 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
8319 InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
8320 &pixelsParam.value);
8321 paramBuffer.addParam(std::move(pixelsParam));
8322 }
8323
8324 return CallCapture(gl::EntryPoint::TexSubImage3DOES, std::move(paramBuffer));
8325 }
8326
CaptureGetSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)8327 CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
8328 bool isCallValid,
8329 SamplerID samplerPacked,
8330 GLenum pname,
8331 GLint *params)
8332 {
8333 ParamBuffer paramBuffer;
8334
8335 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8336 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
8337
8338 if (isCallValid)
8339 {
8340 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8341 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
8342 CaptureGetSamplerParameterIivOES_params(glState, isCallValid, samplerPacked, pname, params,
8343 ¶msParam);
8344 paramBuffer.addParam(std::move(paramsParam));
8345 }
8346 else
8347 {
8348 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8349 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
8350 paramBuffer.addParam(std::move(paramsParam));
8351 }
8352
8353 return CallCapture(gl::EntryPoint::GetSamplerParameterIivOES, std::move(paramBuffer));
8354 }
8355
CaptureGetSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)8356 CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
8357 bool isCallValid,
8358 SamplerID samplerPacked,
8359 GLenum pname,
8360 GLuint *params)
8361 {
8362 ParamBuffer paramBuffer;
8363
8364 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8365 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
8366
8367 if (isCallValid)
8368 {
8369 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8370 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
8371 CaptureGetSamplerParameterIuivOES_params(glState, isCallValid, samplerPacked, pname, params,
8372 ¶msParam);
8373 paramBuffer.addParam(std::move(paramsParam));
8374 }
8375 else
8376 {
8377 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8378 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
8379 ¶msParam.value);
8380 paramBuffer.addParam(std::move(paramsParam));
8381 }
8382
8383 return CallCapture(gl::EntryPoint::GetSamplerParameterIuivOES, std::move(paramBuffer));
8384 }
8385
CaptureGetTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)8386 CallCapture CaptureGetTexParameterIivOES(const State &glState,
8387 bool isCallValid,
8388 TextureType targetPacked,
8389 GLenum pname,
8390 GLint *params)
8391 {
8392 ParamBuffer paramBuffer;
8393
8394 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8395 paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
8396
8397 if (isCallValid)
8398 {
8399 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8400 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
8401 CaptureGetTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
8402 ¶msParam);
8403 paramBuffer.addParam(std::move(paramsParam));
8404 }
8405 else
8406 {
8407 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8408 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
8409 paramBuffer.addParam(std::move(paramsParam));
8410 }
8411
8412 return CallCapture(gl::EntryPoint::GetTexParameterIivOES, std::move(paramBuffer));
8413 }
8414
CaptureGetTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)8415 CallCapture CaptureGetTexParameterIuivOES(const State &glState,
8416 bool isCallValid,
8417 TextureType targetPacked,
8418 GLenum pname,
8419 GLuint *params)
8420 {
8421 ParamBuffer paramBuffer;
8422
8423 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8424 paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
8425
8426 if (isCallValid)
8427 {
8428 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8429 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
8430 CaptureGetTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
8431 ¶msParam);
8432 paramBuffer.addParam(std::move(paramsParam));
8433 }
8434 else
8435 {
8436 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
8437 InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
8438 ¶msParam.value);
8439 paramBuffer.addParam(std::move(paramsParam));
8440 }
8441
8442 return CallCapture(gl::EntryPoint::GetTexParameterIuivOES, std::move(paramBuffer));
8443 }
8444
CaptureSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)8445 CallCapture CaptureSamplerParameterIivOES(const State &glState,
8446 bool isCallValid,
8447 SamplerID samplerPacked,
8448 GLenum pname,
8449 const GLint *param)
8450 {
8451 ParamBuffer paramBuffer;
8452
8453 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8454 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
8455
8456 if (isCallValid)
8457 {
8458 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
8459 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
8460 CaptureSamplerParameterIivOES_param(glState, isCallValid, samplerPacked, pname, param,
8461 ¶mParam);
8462 paramBuffer.addParam(std::move(paramParam));
8463 }
8464 else
8465 {
8466 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
8467 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8468 ¶mParam.value);
8469 paramBuffer.addParam(std::move(paramParam));
8470 }
8471
8472 return CallCapture(gl::EntryPoint::SamplerParameterIivOES, std::move(paramBuffer));
8473 }
8474
CaptureSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)8475 CallCapture CaptureSamplerParameterIuivOES(const State &glState,
8476 bool isCallValid,
8477 SamplerID samplerPacked,
8478 GLenum pname,
8479 const GLuint *param)
8480 {
8481 ParamBuffer paramBuffer;
8482
8483 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
8484 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
8485
8486 if (isCallValid)
8487 {
8488 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
8489 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
8490 CaptureSamplerParameterIuivOES_param(glState, isCallValid, samplerPacked, pname, param,
8491 ¶mParam);
8492 paramBuffer.addParam(std::move(paramParam));
8493 }
8494 else
8495 {
8496 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
8497 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8498 ¶mParam.value);
8499 paramBuffer.addParam(std::move(paramParam));
8500 }
8501
8502 return CallCapture(gl::EntryPoint::SamplerParameterIuivOES, std::move(paramBuffer));
8503 }
8504
CaptureTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)8505 CallCapture CaptureTexParameterIivOES(const State &glState,
8506 bool isCallValid,
8507 TextureType targetPacked,
8508 GLenum pname,
8509 const GLint *params)
8510 {
8511 ParamBuffer paramBuffer;
8512
8513 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8514 paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
8515
8516 if (isCallValid)
8517 {
8518 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
8519 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
8520 CaptureTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
8521 ¶msParam);
8522 paramBuffer.addParam(std::move(paramsParam));
8523 }
8524 else
8525 {
8526 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
8527 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8528 ¶msParam.value);
8529 paramBuffer.addParam(std::move(paramsParam));
8530 }
8531
8532 return CallCapture(gl::EntryPoint::TexParameterIivOES, std::move(paramBuffer));
8533 }
8534
CaptureTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)8535 CallCapture CaptureTexParameterIuivOES(const State &glState,
8536 bool isCallValid,
8537 TextureType targetPacked,
8538 GLenum pname,
8539 const GLuint *params)
8540 {
8541 ParamBuffer paramBuffer;
8542
8543 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8544 paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
8545
8546 if (isCallValid)
8547 {
8548 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
8549 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
8550 CaptureTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
8551 ¶msParam);
8552 paramBuffer.addParam(std::move(paramsParam));
8553 }
8554 else
8555 {
8556 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
8557 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
8558 ¶msParam.value);
8559 paramBuffer.addParam(std::move(paramsParam));
8560 }
8561
8562 return CallCapture(gl::EntryPoint::TexParameterIuivOES, std::move(paramBuffer));
8563 }
8564
CaptureTexBufferOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked)8565 CallCapture CaptureTexBufferOES(const State &glState,
8566 bool isCallValid,
8567 TextureType targetPacked,
8568 GLenum internalformat,
8569 BufferID bufferPacked)
8570 {
8571 ParamBuffer paramBuffer;
8572
8573 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8574 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
8575 internalformat);
8576 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
8577
8578 return CallCapture(gl::EntryPoint::TexBufferOES, std::move(paramBuffer));
8579 }
8580
CaptureTexBufferRangeOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)8581 CallCapture CaptureTexBufferRangeOES(const State &glState,
8582 bool isCallValid,
8583 TextureType targetPacked,
8584 GLenum internalformat,
8585 BufferID bufferPacked,
8586 GLintptr offset,
8587 GLsizeiptr size)
8588 {
8589 ParamBuffer paramBuffer;
8590
8591 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8592 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
8593 internalformat);
8594 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
8595 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
8596 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
8597
8598 return CallCapture(gl::EntryPoint::TexBufferRangeOES, std::move(paramBuffer));
8599 }
8600
CaptureGetTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat * params)8601 CallCapture CaptureGetTexGenfvOES(const State &glState,
8602 bool isCallValid,
8603 GLenum coord,
8604 GLenum pname,
8605 GLfloat *params)
8606 {
8607 ParamBuffer paramBuffer;
8608
8609 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8610 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8611
8612 if (isCallValid)
8613 {
8614 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
8615 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
8616 CaptureGetTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
8617 paramBuffer.addParam(std::move(paramsParam));
8618 }
8619 else
8620 {
8621 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
8622 InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
8623 ¶msParam.value);
8624 paramBuffer.addParam(std::move(paramsParam));
8625 }
8626
8627 return CallCapture(gl::EntryPoint::GetTexGenfvOES, std::move(paramBuffer));
8628 }
8629
CaptureGetTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint * params)8630 CallCapture CaptureGetTexGenivOES(const State &glState,
8631 bool isCallValid,
8632 GLenum coord,
8633 GLenum pname,
8634 GLint *params)
8635 {
8636 ParamBuffer paramBuffer;
8637
8638 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8639 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8640
8641 if (isCallValid)
8642 {
8643 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8644 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
8645 CaptureGetTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
8646 paramBuffer.addParam(std::move(paramsParam));
8647 }
8648 else
8649 {
8650 ParamCapture paramsParam("params", ParamType::TGLintPointer);
8651 InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value);
8652 paramBuffer.addParam(std::move(paramsParam));
8653 }
8654
8655 return CallCapture(gl::EntryPoint::GetTexGenivOES, std::move(paramBuffer));
8656 }
8657
CaptureGetTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed * params)8658 CallCapture CaptureGetTexGenxvOES(const State &glState,
8659 bool isCallValid,
8660 GLenum coord,
8661 GLenum pname,
8662 GLfixed *params)
8663 {
8664 ParamBuffer paramBuffer;
8665
8666 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8667 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8668
8669 if (isCallValid)
8670 {
8671 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
8672 InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value);
8673 CaptureGetTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
8674 paramBuffer.addParam(std::move(paramsParam));
8675 }
8676 else
8677 {
8678 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
8679 InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
8680 ¶msParam.value);
8681 paramBuffer.addParam(std::move(paramsParam));
8682 }
8683
8684 return CallCapture(gl::EntryPoint::GetTexGenxvOES, std::move(paramBuffer));
8685 }
8686
CaptureTexGenfOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat param)8687 CallCapture CaptureTexGenfOES(const State &glState,
8688 bool isCallValid,
8689 GLenum coord,
8690 GLenum pname,
8691 GLfloat param)
8692 {
8693 ParamBuffer paramBuffer;
8694
8695 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8696 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8697 paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
8698
8699 return CallCapture(gl::EntryPoint::TexGenfOES, std::move(paramBuffer));
8700 }
8701
CaptureTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfloat * params)8702 CallCapture CaptureTexGenfvOES(const State &glState,
8703 bool isCallValid,
8704 GLenum coord,
8705 GLenum pname,
8706 const GLfloat *params)
8707 {
8708 ParamBuffer paramBuffer;
8709
8710 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8711 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8712
8713 if (isCallValid)
8714 {
8715 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
8716 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
8717 CaptureTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
8718 paramBuffer.addParam(std::move(paramsParam));
8719 }
8720 else
8721 {
8722 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
8723 InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
8724 ¶msParam.value);
8725 paramBuffer.addParam(std::move(paramsParam));
8726 }
8727
8728 return CallCapture(gl::EntryPoint::TexGenfvOES, std::move(paramBuffer));
8729 }
8730
CaptureTexGeniOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint param)8731 CallCapture CaptureTexGeniOES(const State &glState,
8732 bool isCallValid,
8733 GLenum coord,
8734 GLenum pname,
8735 GLint param)
8736 {
8737 ParamBuffer paramBuffer;
8738
8739 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8740 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8741 paramBuffer.addValueParam("param", ParamType::TGLint, param);
8742
8743 return CallCapture(gl::EntryPoint::TexGeniOES, std::move(paramBuffer));
8744 }
8745
CaptureTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLint * params)8746 CallCapture CaptureTexGenivOES(const State &glState,
8747 bool isCallValid,
8748 GLenum coord,
8749 GLenum pname,
8750 const GLint *params)
8751 {
8752 ParamBuffer paramBuffer;
8753
8754 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8755 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8756
8757 if (isCallValid)
8758 {
8759 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
8760 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
8761 CaptureTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
8762 paramBuffer.addParam(std::move(paramsParam));
8763 }
8764 else
8765 {
8766 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
8767 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
8768 ¶msParam.value);
8769 paramBuffer.addParam(std::move(paramsParam));
8770 }
8771
8772 return CallCapture(gl::EntryPoint::TexGenivOES, std::move(paramBuffer));
8773 }
8774
CaptureTexGenxOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed param)8775 CallCapture CaptureTexGenxOES(const State &glState,
8776 bool isCallValid,
8777 GLenum coord,
8778 GLenum pname,
8779 GLfixed param)
8780 {
8781 ParamBuffer paramBuffer;
8782
8783 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8784 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8785 paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
8786
8787 return CallCapture(gl::EntryPoint::TexGenxOES, std::move(paramBuffer));
8788 }
8789
CaptureTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfixed * params)8790 CallCapture CaptureTexGenxvOES(const State &glState,
8791 bool isCallValid,
8792 GLenum coord,
8793 GLenum pname,
8794 const GLfixed *params)
8795 {
8796 ParamBuffer paramBuffer;
8797
8798 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
8799 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
8800
8801 if (isCallValid)
8802 {
8803 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
8804 InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value);
8805 CaptureTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
8806 paramBuffer.addParam(std::move(paramsParam));
8807 }
8808 else
8809 {
8810 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
8811 InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
8812 ¶msParam.value);
8813 paramBuffer.addParam(std::move(paramsParam));
8814 }
8815
8816 return CallCapture(gl::EntryPoint::TexGenxvOES, std::move(paramBuffer));
8817 }
8818
CaptureTexStorage3DMultisampleOES(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)8819 CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
8820 bool isCallValid,
8821 TextureType targetPacked,
8822 GLsizei samples,
8823 GLenum internalformat,
8824 GLsizei width,
8825 GLsizei height,
8826 GLsizei depth,
8827 GLboolean fixedsamplelocations)
8828 {
8829 ParamBuffer paramBuffer;
8830
8831 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
8832 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
8833 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
8834 internalformat);
8835 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
8836 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
8837 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
8838 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
8839
8840 return CallCapture(gl::EntryPoint::TexStorage3DMultisampleOES, std::move(paramBuffer));
8841 }
8842
CaptureBindVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked)8843 CallCapture CaptureBindVertexArrayOES(const State &glState,
8844 bool isCallValid,
8845 VertexArrayID arrayPacked)
8846 {
8847 ParamBuffer paramBuffer;
8848
8849 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
8850
8851 return CallCapture(gl::EntryPoint::BindVertexArrayOES, std::move(paramBuffer));
8852 }
8853
CaptureDeleteVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,const VertexArrayID * arraysPacked)8854 CallCapture CaptureDeleteVertexArraysOES(const State &glState,
8855 bool isCallValid,
8856 GLsizei n,
8857 const VertexArrayID *arraysPacked)
8858 {
8859 ParamBuffer paramBuffer;
8860
8861 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
8862
8863 if (isCallValid)
8864 {
8865 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
8866 InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked,
8867 &arraysPackedParam.value);
8868 CaptureDeleteVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
8869 &arraysPackedParam);
8870 paramBuffer.addParam(std::move(arraysPackedParam));
8871 }
8872 else
8873 {
8874 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
8875 InitParamValue(ParamType::TVertexArrayIDConstPointer,
8876 static_cast<const VertexArrayID *>(nullptr), &arraysPackedParam.value);
8877 paramBuffer.addParam(std::move(arraysPackedParam));
8878 }
8879
8880 return CallCapture(gl::EntryPoint::DeleteVertexArraysOES, std::move(paramBuffer));
8881 }
8882
CaptureGenVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,VertexArrayID * arraysPacked)8883 CallCapture CaptureGenVertexArraysOES(const State &glState,
8884 bool isCallValid,
8885 GLsizei n,
8886 VertexArrayID *arraysPacked)
8887 {
8888 ParamBuffer paramBuffer;
8889
8890 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
8891
8892 if (isCallValid)
8893 {
8894 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
8895 InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
8896 CaptureGenVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
8897 &arraysPackedParam);
8898 paramBuffer.addParam(std::move(arraysPackedParam));
8899 }
8900 else
8901 {
8902 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
8903 InitParamValue(ParamType::TVertexArrayIDPointer, static_cast<VertexArrayID *>(nullptr),
8904 &arraysPackedParam.value);
8905 paramBuffer.addParam(std::move(arraysPackedParam));
8906 }
8907
8908 return CallCapture(gl::EntryPoint::GenVertexArraysOES, std::move(paramBuffer));
8909 }
8910
CaptureIsVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked,GLboolean returnValue)8911 CallCapture CaptureIsVertexArrayOES(const State &glState,
8912 bool isCallValid,
8913 VertexArrayID arrayPacked,
8914 GLboolean returnValue)
8915 {
8916 ParamBuffer paramBuffer;
8917
8918 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
8919
8920 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
8921 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
8922 paramBuffer.addReturnValue(std::move(returnValueCapture));
8923
8924 return CallCapture(gl::EntryPoint::IsVertexArrayOES, std::move(paramBuffer));
8925 }
8926
CaptureFramebufferTextureMultiviewOVR(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level,GLint baseViewIndex,GLsizei numViews)8927 CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
8928 bool isCallValid,
8929 GLenum target,
8930 GLenum attachment,
8931 TextureID texturePacked,
8932 GLint level,
8933 GLint baseViewIndex,
8934 GLsizei numViews)
8935 {
8936 ParamBuffer paramBuffer;
8937
8938 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
8939 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
8940 attachment);
8941 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
8942 paramBuffer.addValueParam("level", ParamType::TGLint, level);
8943 paramBuffer.addValueParam("baseViewIndex", ParamType::TGLint, baseViewIndex);
8944 paramBuffer.addValueParam("numViews", ParamType::TGLsizei, numViews);
8945
8946 return CallCapture(gl::EntryPoint::FramebufferTextureMultiviewOVR, std::move(paramBuffer));
8947 }
8948
8949 } // namespace gl
8950