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 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointer);
60 InitParamValue(ParamType::TGLvoidConstPointer, indices, &indicesParam.value);
61 CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
62 glState, isCallValid, modePacked, count, typePacked, indices, instanceCounts, baseVertex,
63 baseInstance, &indicesParam);
64 paramBuffer.addParam(std::move(indicesParam));
65
66 paramBuffer.addValueParam("instanceCounts", ParamType::TGLsizei, instanceCounts);
67 paramBuffer.addValueParam("baseVertex", ParamType::TGLint, baseVertex);
68 paramBuffer.addValueParam("baseInstance", ParamType::TGLuint, baseInstance);
69
70 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertexBaseInstanceANGLE,
71 std::move(paramBuffer));
72 }
73
CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)74 CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState,
75 bool isCallValid,
76 PrimitiveMode modePacked,
77 const GLint *firsts,
78 const GLsizei *counts,
79 const GLsizei *instanceCounts,
80 const GLuint *baseInstances,
81 GLsizei drawcount)
82 {
83 ParamBuffer paramBuffer;
84
85 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
86
87 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
88 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
89 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(glState, isCallValid, modePacked,
90 firsts, counts, instanceCounts,
91 baseInstances, drawcount, &firstsParam);
92 paramBuffer.addParam(std::move(firstsParam));
93
94 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
95 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
96 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(glState, isCallValid, modePacked,
97 firsts, counts, instanceCounts,
98 baseInstances, drawcount, &countsParam);
99 paramBuffer.addParam(std::move(countsParam));
100
101 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
102 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
103 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
104 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances, drawcount,
105 &instanceCountsParam);
106 paramBuffer.addParam(std::move(instanceCountsParam));
107
108 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
109 InitParamValue(ParamType::TGLuintConstPointer, baseInstances, &baseInstancesParam.value);
110 CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
111 glState, isCallValid, modePacked, firsts, counts, instanceCounts, baseInstances, drawcount,
112 &baseInstancesParam);
113 paramBuffer.addParam(std::move(baseInstancesParam));
114
115 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
116
117 return CallCapture(gl::EntryPoint::MultiDrawArraysInstancedBaseInstanceANGLE,
118 std::move(paramBuffer));
119 }
120
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)121 CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
122 const State &glState,
123 bool isCallValid,
124 PrimitiveMode modePacked,
125 const GLsizei *counts,
126 DrawElementsType typePacked,
127 const GLvoid *const *indices,
128 const GLsizei *instanceCounts,
129 const GLint *baseVertices,
130 const GLuint *baseInstances,
131 GLsizei drawcount)
132 {
133 ParamBuffer paramBuffer;
134
135 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
136
137 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
138 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
139 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
140 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
141 baseInstances, drawcount, &countsParam);
142 paramBuffer.addParam(std::move(countsParam));
143
144 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
145
146 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
147 InitParamValue(ParamType::TGLvoidConstPointerPointer, indices, &indicesParam.value);
148 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
149 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
150 baseInstances, drawcount, &indicesParam);
151 paramBuffer.addParam(std::move(indicesParam));
152
153 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
154 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
155 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
156 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
157 baseInstances, drawcount, &instanceCountsParam);
158 paramBuffer.addParam(std::move(instanceCountsParam));
159
160 ParamCapture baseVerticesParam("baseVertices", ParamType::TGLintConstPointer);
161 InitParamValue(ParamType::TGLintConstPointer, baseVertices, &baseVerticesParam.value);
162 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
163 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
164 baseInstances, drawcount, &baseVerticesParam);
165 paramBuffer.addParam(std::move(baseVerticesParam));
166
167 ParamCapture baseInstancesParam("baseInstances", ParamType::TGLuintConstPointer);
168 InitParamValue(ParamType::TGLuintConstPointer, baseInstances, &baseInstancesParam.value);
169 CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
170 glState, isCallValid, modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
171 baseInstances, drawcount, &baseInstancesParam);
172 paramBuffer.addParam(std::move(baseInstancesParam));
173
174 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
175
176 return CallCapture(gl::EntryPoint::MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
177 std::move(paramBuffer));
178 }
179
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)180 CallCapture CaptureCopyTexture3DANGLE(const State &glState,
181 bool isCallValid,
182 TextureID sourceIdPacked,
183 GLint sourceLevel,
184 TextureTarget destTargetPacked,
185 TextureID destIdPacked,
186 GLint destLevel,
187 GLint internalFormat,
188 GLenum destType,
189 GLboolean unpackFlipY,
190 GLboolean unpackPremultiplyAlpha,
191 GLboolean unpackUnmultiplyAlpha)
192 {
193 ParamBuffer paramBuffer;
194
195 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
196 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
197 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
198 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
199 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
200 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
201 paramBuffer.addEnumParam("destType", GLenumGroup::DefaultGroup, ParamType::TGLenum, destType);
202 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
203 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
204 unpackPremultiplyAlpha);
205 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
206 unpackUnmultiplyAlpha);
207
208 return CallCapture(gl::EntryPoint::CopyTexture3DANGLE, std::move(paramBuffer));
209 }
210
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)211 CallCapture CaptureCopySubTexture3DANGLE(const State &glState,
212 bool isCallValid,
213 TextureID sourceIdPacked,
214 GLint sourceLevel,
215 TextureTarget destTargetPacked,
216 TextureID destIdPacked,
217 GLint destLevel,
218 GLint xoffset,
219 GLint yoffset,
220 GLint zoffset,
221 GLint x,
222 GLint y,
223 GLint z,
224 GLint width,
225 GLint height,
226 GLint depth,
227 GLboolean unpackFlipY,
228 GLboolean unpackPremultiplyAlpha,
229 GLboolean unpackUnmultiplyAlpha)
230 {
231 ParamBuffer paramBuffer;
232
233 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
234 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
235 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
236 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
237 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
238 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
239 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
240 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
241 paramBuffer.addValueParam("x", ParamType::TGLint, x);
242 paramBuffer.addValueParam("y", ParamType::TGLint, y);
243 paramBuffer.addValueParam("z", ParamType::TGLint, z);
244 paramBuffer.addValueParam("width", ParamType::TGLint, width);
245 paramBuffer.addValueParam("height", ParamType::TGLint, height);
246 paramBuffer.addValueParam("depth", ParamType::TGLint, depth);
247 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
248 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
249 unpackPremultiplyAlpha);
250 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
251 unpackUnmultiplyAlpha);
252
253 return CallCapture(gl::EntryPoint::CopySubTexture3DANGLE, std::move(paramBuffer));
254 }
255
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)256 CallCapture CaptureBlitFramebufferANGLE(const State &glState,
257 bool isCallValid,
258 GLint srcX0,
259 GLint srcY0,
260 GLint srcX1,
261 GLint srcY1,
262 GLint dstX0,
263 GLint dstY0,
264 GLint dstX1,
265 GLint dstY1,
266 GLbitfield mask,
267 GLenum filter)
268 {
269 ParamBuffer paramBuffer;
270
271 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
272 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
273 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
274 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
275 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
276 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
277 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
278 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
279 paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask);
280 paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum,
281 filter);
282
283 return CallCapture(gl::EntryPoint::BlitFramebufferANGLE, std::move(paramBuffer));
284 }
285
CaptureRenderbufferStorageMultisampleANGLE(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)286 CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
287 bool isCallValid,
288 GLenum target,
289 GLsizei samples,
290 GLenum internalformat,
291 GLsizei width,
292 GLsizei height)
293 {
294 ParamBuffer paramBuffer;
295
296 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
297 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
298 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
299 internalformat);
300 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
301 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
302
303 return CallCapture(gl::EntryPoint::RenderbufferStorageMultisampleANGLE, std::move(paramBuffer));
304 }
305
CaptureGetTexImageANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum format,GLenum type,void * pixels)306 CallCapture CaptureGetTexImageANGLE(const State &glState,
307 bool isCallValid,
308 TextureTarget targetPacked,
309 GLint level,
310 GLenum format,
311 GLenum type,
312 void *pixels)
313 {
314 ParamBuffer paramBuffer;
315
316 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
317 paramBuffer.addValueParam("level", ParamType::TGLint, level);
318 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
319 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
320
321 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
322 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
323 CaptureGetTexImageANGLE_pixels(glState, isCallValid, targetPacked, level, format, type, pixels,
324 &pixelsParam);
325 paramBuffer.addParam(std::move(pixelsParam));
326
327 return CallCapture(gl::EntryPoint::GetTexImageANGLE, std::move(paramBuffer));
328 }
329
CaptureGetRenderbufferImageANGLE(const State & glState,bool isCallValid,GLenum target,GLenum format,GLenum type,void * pixels)330 CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
331 bool isCallValid,
332 GLenum target,
333 GLenum format,
334 GLenum type,
335 void *pixels)
336 {
337 ParamBuffer paramBuffer;
338
339 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
340 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
341 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
342
343 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
344 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
345 CaptureGetRenderbufferImageANGLE_pixels(glState, isCallValid, target, format, type, pixels,
346 &pixelsParam);
347 paramBuffer.addParam(std::move(pixelsParam));
348
349 return CallCapture(gl::EntryPoint::GetRenderbufferImageANGLE, std::move(paramBuffer));
350 }
351
CaptureDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei primcount)352 CallCapture CaptureDrawArraysInstancedANGLE(const State &glState,
353 bool isCallValid,
354 PrimitiveMode modePacked,
355 GLint first,
356 GLsizei count,
357 GLsizei primcount)
358 {
359 ParamBuffer paramBuffer;
360
361 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
362 paramBuffer.addValueParam("first", ParamType::TGLint, first);
363 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
364 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
365
366 return CallCapture(gl::EntryPoint::DrawArraysInstancedANGLE, std::move(paramBuffer));
367 }
368
CaptureDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)369 CallCapture CaptureDrawElementsInstancedANGLE(const State &glState,
370 bool isCallValid,
371 PrimitiveMode modePacked,
372 GLsizei count,
373 DrawElementsType typePacked,
374 const void *indices,
375 GLsizei primcount)
376 {
377 ParamBuffer paramBuffer;
378
379 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
380 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
381 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
382
383 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
384 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
385 CaptureDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, count, typePacked,
386 indices, primcount, &indicesParam);
387 paramBuffer.addParam(std::move(indicesParam));
388
389 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
390
391 return CallCapture(gl::EntryPoint::DrawElementsInstancedANGLE, std::move(paramBuffer));
392 }
393
CaptureVertexAttribDivisorANGLE(const State & glState,bool isCallValid,GLuint index,GLuint divisor)394 CallCapture CaptureVertexAttribDivisorANGLE(const State &glState,
395 bool isCallValid,
396 GLuint index,
397 GLuint divisor)
398 {
399 ParamBuffer paramBuffer;
400
401 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
402 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
403
404 return CallCapture(gl::EntryPoint::VertexAttribDivisorANGLE, std::move(paramBuffer));
405 }
406
CaptureImportMemoryZirconHandleANGLE(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLuint handle)407 CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
408 bool isCallValid,
409 MemoryObjectID memoryPacked,
410 GLuint64 size,
411 HandleType handleTypePacked,
412 GLuint handle)
413 {
414 ParamBuffer paramBuffer;
415
416 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
417 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
418 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
419 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
420
421 return CallCapture(gl::EntryPoint::ImportMemoryZirconHandleANGLE, std::move(paramBuffer));
422 }
423
CaptureMultiDrawArraysANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)424 CallCapture CaptureMultiDrawArraysANGLE(const State &glState,
425 bool isCallValid,
426 PrimitiveMode modePacked,
427 const GLint *firsts,
428 const GLsizei *counts,
429 GLsizei drawcount)
430 {
431 ParamBuffer paramBuffer;
432
433 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
434
435 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
436 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
437 CaptureMultiDrawArraysANGLE_firsts(glState, isCallValid, modePacked, firsts, counts, drawcount,
438 &firstsParam);
439 paramBuffer.addParam(std::move(firstsParam));
440
441 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
442 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
443 CaptureMultiDrawArraysANGLE_counts(glState, isCallValid, modePacked, firsts, counts, drawcount,
444 &countsParam);
445 paramBuffer.addParam(std::move(countsParam));
446
447 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
448
449 return CallCapture(gl::EntryPoint::MultiDrawArraysANGLE, std::move(paramBuffer));
450 }
451
CaptureMultiDrawArraysInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)452 CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState,
453 bool isCallValid,
454 PrimitiveMode modePacked,
455 const GLint *firsts,
456 const GLsizei *counts,
457 const GLsizei *instanceCounts,
458 GLsizei drawcount)
459 {
460 ParamBuffer paramBuffer;
461
462 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
463
464 ParamCapture firstsParam("firsts", ParamType::TGLintConstPointer);
465 InitParamValue(ParamType::TGLintConstPointer, firsts, &firstsParam.value);
466 CaptureMultiDrawArraysInstancedANGLE_firsts(glState, isCallValid, modePacked, firsts, counts,
467 instanceCounts, drawcount, &firstsParam);
468 paramBuffer.addParam(std::move(firstsParam));
469
470 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
471 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
472 CaptureMultiDrawArraysInstancedANGLE_counts(glState, isCallValid, modePacked, firsts, counts,
473 instanceCounts, drawcount, &countsParam);
474 paramBuffer.addParam(std::move(countsParam));
475
476 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
477 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
478 CaptureMultiDrawArraysInstancedANGLE_instanceCounts(glState, isCallValid, modePacked, firsts,
479 counts, instanceCounts, drawcount,
480 &instanceCountsParam);
481 paramBuffer.addParam(std::move(instanceCountsParam));
482
483 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
484
485 return CallCapture(gl::EntryPoint::MultiDrawArraysInstancedANGLE, std::move(paramBuffer));
486 }
487
CaptureMultiDrawElementsANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const GLvoid * const * indices,GLsizei drawcount)488 CallCapture CaptureMultiDrawElementsANGLE(const State &glState,
489 bool isCallValid,
490 PrimitiveMode modePacked,
491 const GLsizei *counts,
492 DrawElementsType typePacked,
493 const GLvoid *const *indices,
494 GLsizei drawcount)
495 {
496 ParamBuffer paramBuffer;
497
498 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
499
500 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
501 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
502 CaptureMultiDrawElementsANGLE_counts(glState, isCallValid, modePacked, counts, typePacked,
503 indices, drawcount, &countsParam);
504 paramBuffer.addParam(std::move(countsParam));
505
506 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
507
508 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
509 InitParamValue(ParamType::TGLvoidConstPointerPointer, indices, &indicesParam.value);
510 CaptureMultiDrawElementsANGLE_indices(glState, isCallValid, modePacked, counts, typePacked,
511 indices, drawcount, &indicesParam);
512 paramBuffer.addParam(std::move(indicesParam));
513
514 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
515
516 return CallCapture(gl::EntryPoint::MultiDrawElementsANGLE, std::move(paramBuffer));
517 }
518
CaptureMultiDrawElementsInstancedANGLE(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * counts,DrawElementsType typePacked,const GLvoid * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)519 CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
520 bool isCallValid,
521 PrimitiveMode modePacked,
522 const GLsizei *counts,
523 DrawElementsType typePacked,
524 const GLvoid *const *indices,
525 const GLsizei *instanceCounts,
526 GLsizei drawcount)
527 {
528 ParamBuffer paramBuffer;
529
530 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
531
532 ParamCapture countsParam("counts", ParamType::TGLsizeiConstPointer);
533 InitParamValue(ParamType::TGLsizeiConstPointer, counts, &countsParam.value);
534 CaptureMultiDrawElementsInstancedANGLE_counts(glState, isCallValid, modePacked, counts,
535 typePacked, indices, instanceCounts, drawcount,
536 &countsParam);
537 paramBuffer.addParam(std::move(countsParam));
538
539 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
540
541 ParamCapture indicesParam("indices", ParamType::TGLvoidConstPointerPointer);
542 InitParamValue(ParamType::TGLvoidConstPointerPointer, indices, &indicesParam.value);
543 CaptureMultiDrawElementsInstancedANGLE_indices(glState, isCallValid, modePacked, counts,
544 typePacked, indices, instanceCounts, drawcount,
545 &indicesParam);
546 paramBuffer.addParam(std::move(indicesParam));
547
548 ParamCapture instanceCountsParam("instanceCounts", ParamType::TGLsizeiConstPointer);
549 InitParamValue(ParamType::TGLsizeiConstPointer, instanceCounts, &instanceCountsParam.value);
550 CaptureMultiDrawElementsInstancedANGLE_instanceCounts(glState, isCallValid, modePacked, counts,
551 typePacked, indices, instanceCounts,
552 drawcount, &instanceCountsParam);
553 paramBuffer.addParam(std::move(instanceCountsParam));
554
555 paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
556
557 return CallCapture(gl::EntryPoint::MultiDrawElementsInstancedANGLE, std::move(paramBuffer));
558 }
559
CaptureProvokingVertexANGLE(const State & glState,bool isCallValid,ProvokingVertexConvention modePacked)560 CallCapture CaptureProvokingVertexANGLE(const State &glState,
561 bool isCallValid,
562 ProvokingVertexConvention modePacked)
563 {
564 ParamBuffer paramBuffer;
565
566 paramBuffer.addValueParam("modePacked", ParamType::TProvokingVertexConvention, modePacked);
567
568 return CallCapture(gl::EntryPoint::ProvokingVertexANGLE, std::move(paramBuffer));
569 }
570
CaptureRequestExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)571 CallCapture CaptureRequestExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
572 {
573 ParamBuffer paramBuffer;
574
575 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
576 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
577 CaptureRequestExtensionANGLE_name(glState, isCallValid, name, &nameParam);
578 paramBuffer.addParam(std::move(nameParam));
579
580 return CallCapture(gl::EntryPoint::RequestExtensionANGLE, std::move(paramBuffer));
581 }
582
CaptureDisableExtensionANGLE(const State & glState,bool isCallValid,const GLchar * name)583 CallCapture CaptureDisableExtensionANGLE(const State &glState, bool isCallValid, const GLchar *name)
584 {
585 ParamBuffer paramBuffer;
586
587 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
588 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
589 CaptureDisableExtensionANGLE_name(glState, isCallValid, name, &nameParam);
590 paramBuffer.addParam(std::move(nameParam));
591
592 return CallCapture(gl::EntryPoint::DisableExtensionANGLE, std::move(paramBuffer));
593 }
594
CaptureGetBooleanvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)595 CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
596 bool isCallValid,
597 GLenum pname,
598 GLsizei bufSize,
599 GLsizei *length,
600 GLboolean *params)
601 {
602 ParamBuffer paramBuffer;
603
604 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
605 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
606
607 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
608 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
609 CaptureGetBooleanvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
610 &lengthParam);
611 paramBuffer.addParam(std::move(lengthParam));
612
613 ParamCapture paramsParam("params", ParamType::TGLbooleanPointer);
614 InitParamValue(ParamType::TGLbooleanPointer, params, ¶msParam.value);
615 CaptureGetBooleanvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
616 ¶msParam);
617 paramBuffer.addParam(std::move(paramsParam));
618
619 return CallCapture(gl::EntryPoint::GetBooleanvRobustANGLE, std::move(paramBuffer));
620 }
621
CaptureGetBufferParameterivRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)622 CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
623 bool isCallValid,
624 BufferBinding targetPacked,
625 GLenum pname,
626 GLsizei bufSize,
627 GLsizei *length,
628 GLint *params)
629 {
630 ParamBuffer paramBuffer;
631
632 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
633 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
634 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
635
636 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
637 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
638 CaptureGetBufferParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname,
639 bufSize, length, params, &lengthParam);
640 paramBuffer.addParam(std::move(lengthParam));
641
642 ParamCapture paramsParam("params", ParamType::TGLintPointer);
643 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
644 CaptureGetBufferParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname,
645 bufSize, length, params, ¶msParam);
646 paramBuffer.addParam(std::move(paramsParam));
647
648 return CallCapture(gl::EntryPoint::GetBufferParameterivRobustANGLE, std::move(paramBuffer));
649 }
650
CaptureGetFloatvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)651 CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
652 bool isCallValid,
653 GLenum pname,
654 GLsizei bufSize,
655 GLsizei *length,
656 GLfloat *params)
657 {
658 ParamBuffer paramBuffer;
659
660 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
661 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
662
663 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
664 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
665 CaptureGetFloatvRobustANGLE_length(glState, isCallValid, pname, bufSize, length, params,
666 &lengthParam);
667 paramBuffer.addParam(std::move(lengthParam));
668
669 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
670 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
671 CaptureGetFloatvRobustANGLE_params(glState, isCallValid, pname, bufSize, length, params,
672 ¶msParam);
673 paramBuffer.addParam(std::move(paramsParam));
674
675 return CallCapture(gl::EntryPoint::GetFloatvRobustANGLE, std::move(paramBuffer));
676 }
677
CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)678 CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
679 bool isCallValid,
680 GLenum target,
681 GLenum attachment,
682 GLenum pname,
683 GLsizei bufSize,
684 GLsizei *length,
685 GLint *params)
686 {
687 ParamBuffer paramBuffer;
688
689 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
690 paramBuffer.addEnumParam("attachment", GLenumGroup::DefaultGroup, ParamType::TGLenum,
691 attachment);
692 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
693 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
694
695 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
696 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
697 CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
698 glState, isCallValid, target, attachment, pname, bufSize, length, params, &lengthParam);
699 paramBuffer.addParam(std::move(lengthParam));
700
701 ParamCapture paramsParam("params", ParamType::TGLintPointer);
702 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
703 CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
704 glState, isCallValid, target, attachment, pname, bufSize, length, params, ¶msParam);
705 paramBuffer.addParam(std::move(paramsParam));
706
707 return CallCapture(gl::EntryPoint::GetFramebufferAttachmentParameterivRobustANGLE,
708 std::move(paramBuffer));
709 }
710
CaptureGetIntegervRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)711 CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
712 bool isCallValid,
713 GLenum pname,
714 GLsizei bufSize,
715 GLsizei *length,
716 GLint *data)
717 {
718 ParamBuffer paramBuffer;
719
720 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
721 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
722
723 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
724 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
725 CaptureGetIntegervRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
726 &lengthParam);
727 paramBuffer.addParam(std::move(lengthParam));
728
729 ParamCapture dataParam("data", ParamType::TGLintPointer);
730 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
731 CaptureGetIntegervRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
732 &dataParam);
733 paramBuffer.addParam(std::move(dataParam));
734
735 return CallCapture(gl::EntryPoint::GetIntegervRobustANGLE, std::move(paramBuffer));
736 }
737
CaptureGetProgramivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)738 CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
739 bool isCallValid,
740 ShaderProgramID programPacked,
741 GLenum pname,
742 GLsizei bufSize,
743 GLsizei *length,
744 GLint *params)
745 {
746 ParamBuffer paramBuffer;
747
748 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
749 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
750 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
751
752 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
753 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
754 CaptureGetProgramivRobustANGLE_length(glState, isCallValid, programPacked, pname, bufSize,
755 length, params, &lengthParam);
756 paramBuffer.addParam(std::move(lengthParam));
757
758 ParamCapture paramsParam("params", ParamType::TGLintPointer);
759 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
760 CaptureGetProgramivRobustANGLE_params(glState, isCallValid, programPacked, pname, bufSize,
761 length, params, ¶msParam);
762 paramBuffer.addParam(std::move(paramsParam));
763
764 return CallCapture(gl::EntryPoint::GetProgramivRobustANGLE, std::move(paramBuffer));
765 }
766
CaptureGetRenderbufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)767 CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
768 bool isCallValid,
769 GLenum target,
770 GLenum pname,
771 GLsizei bufSize,
772 GLsizei *length,
773 GLint *params)
774 {
775 ParamBuffer paramBuffer;
776
777 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
778 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
779 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
780
781 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
782 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
783 CaptureGetRenderbufferParameterivRobustANGLE_length(glState, isCallValid, target, pname,
784 bufSize, length, params, &lengthParam);
785 paramBuffer.addParam(std::move(lengthParam));
786
787 ParamCapture paramsParam("params", ParamType::TGLintPointer);
788 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
789 CaptureGetRenderbufferParameterivRobustANGLE_params(glState, isCallValid, target, pname,
790 bufSize, length, params, ¶msParam);
791 paramBuffer.addParam(std::move(paramsParam));
792
793 return CallCapture(gl::EntryPoint::GetRenderbufferParameterivRobustANGLE,
794 std::move(paramBuffer));
795 }
796
CaptureGetShaderivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)797 CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
798 bool isCallValid,
799 ShaderProgramID shaderPacked,
800 GLenum pname,
801 GLsizei bufSize,
802 GLsizei *length,
803 GLint *params)
804 {
805 ParamBuffer paramBuffer;
806
807 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
808 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
809 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
810
811 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
812 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
813 CaptureGetShaderivRobustANGLE_length(glState, isCallValid, shaderPacked, pname, bufSize, length,
814 params, &lengthParam);
815 paramBuffer.addParam(std::move(lengthParam));
816
817 ParamCapture paramsParam("params", ParamType::TGLintPointer);
818 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
819 CaptureGetShaderivRobustANGLE_params(glState, isCallValid, shaderPacked, pname, bufSize, length,
820 params, ¶msParam);
821 paramBuffer.addParam(std::move(paramsParam));
822
823 return CallCapture(gl::EntryPoint::GetShaderivRobustANGLE, std::move(paramBuffer));
824 }
825
CaptureGetTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)826 CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
827 bool isCallValid,
828 TextureType targetPacked,
829 GLenum pname,
830 GLsizei bufSize,
831 GLsizei *length,
832 GLfloat *params)
833 {
834 ParamBuffer paramBuffer;
835
836 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
837 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
838 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
839
840 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
841 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
842 CaptureGetTexParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
843 length, params, &lengthParam);
844 paramBuffer.addParam(std::move(lengthParam));
845
846 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
847 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
848 CaptureGetTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
849 length, params, ¶msParam);
850 paramBuffer.addParam(std::move(paramsParam));
851
852 return CallCapture(gl::EntryPoint::GetTexParameterfvRobustANGLE, std::move(paramBuffer));
853 }
854
CaptureGetTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)855 CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
856 bool isCallValid,
857 TextureType targetPacked,
858 GLenum pname,
859 GLsizei bufSize,
860 GLsizei *length,
861 GLint *params)
862 {
863 ParamBuffer paramBuffer;
864
865 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
866 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
867 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
868
869 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
870 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
871 CaptureGetTexParameterivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
872 length, params, &lengthParam);
873 paramBuffer.addParam(std::move(lengthParam));
874
875 ParamCapture paramsParam("params", ParamType::TGLintPointer);
876 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
877 CaptureGetTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
878 length, params, ¶msParam);
879 paramBuffer.addParam(std::move(paramsParam));
880
881 return CallCapture(gl::EntryPoint::GetTexParameterivRobustANGLE, std::move(paramBuffer));
882 }
883
CaptureGetUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)884 CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
885 bool isCallValid,
886 ShaderProgramID programPacked,
887 UniformLocation locationPacked,
888 GLsizei bufSize,
889 GLsizei *length,
890 GLfloat *params)
891 {
892 ParamBuffer paramBuffer;
893
894 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
895 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
896 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
897
898 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
899 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
900 CaptureGetUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
901 bufSize, length, params, &lengthParam);
902 paramBuffer.addParam(std::move(lengthParam));
903
904 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
905 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
906 CaptureGetUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
907 bufSize, length, params, ¶msParam);
908 paramBuffer.addParam(std::move(paramsParam));
909
910 return CallCapture(gl::EntryPoint::GetUniformfvRobustANGLE, std::move(paramBuffer));
911 }
912
CaptureGetUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)913 CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
914 bool isCallValid,
915 ShaderProgramID programPacked,
916 UniformLocation locationPacked,
917 GLsizei bufSize,
918 GLsizei *length,
919 GLint *params)
920 {
921 ParamBuffer paramBuffer;
922
923 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
924 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
925 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
926
927 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
928 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
929 CaptureGetUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
930 bufSize, length, params, &lengthParam);
931 paramBuffer.addParam(std::move(lengthParam));
932
933 ParamCapture paramsParam("params", ParamType::TGLintPointer);
934 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
935 CaptureGetUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
936 bufSize, length, params, ¶msParam);
937 paramBuffer.addParam(std::move(paramsParam));
938
939 return CallCapture(gl::EntryPoint::GetUniformivRobustANGLE, std::move(paramBuffer));
940 }
941
CaptureGetVertexAttribfvRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)942 CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
943 bool isCallValid,
944 GLuint index,
945 GLenum pname,
946 GLsizei bufSize,
947 GLsizei *length,
948 GLfloat *params)
949 {
950 ParamBuffer paramBuffer;
951
952 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
953 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
954 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
955
956 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
957 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
958 CaptureGetVertexAttribfvRobustANGLE_length(glState, isCallValid, index, pname, bufSize, length,
959 params, &lengthParam);
960 paramBuffer.addParam(std::move(lengthParam));
961
962 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
963 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
964 CaptureGetVertexAttribfvRobustANGLE_params(glState, isCallValid, index, pname, bufSize, length,
965 params, ¶msParam);
966 paramBuffer.addParam(std::move(paramsParam));
967
968 return CallCapture(gl::EntryPoint::GetVertexAttribfvRobustANGLE, std::move(paramBuffer));
969 }
970
CaptureGetVertexAttribivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)971 CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
972 bool isCallValid,
973 GLuint index,
974 GLenum pname,
975 GLsizei bufSize,
976 GLsizei *length,
977 GLint *params)
978 {
979 ParamBuffer paramBuffer;
980
981 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
982 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
983 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
984
985 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
986 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
987 CaptureGetVertexAttribivRobustANGLE_length(glState, isCallValid, index, pname, bufSize, length,
988 params, &lengthParam);
989 paramBuffer.addParam(std::move(lengthParam));
990
991 ParamCapture paramsParam("params", ParamType::TGLintPointer);
992 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
993 CaptureGetVertexAttribivRobustANGLE_params(glState, isCallValid, index, pname, bufSize, length,
994 params, ¶msParam);
995 paramBuffer.addParam(std::move(paramsParam));
996
997 return CallCapture(gl::EntryPoint::GetVertexAttribivRobustANGLE, std::move(paramBuffer));
998 }
999
CaptureGetVertexAttribPointervRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)1000 CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
1001 bool isCallValid,
1002 GLuint index,
1003 GLenum pname,
1004 GLsizei bufSize,
1005 GLsizei *length,
1006 void **pointer)
1007 {
1008 ParamBuffer paramBuffer;
1009
1010 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1011 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1012 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1013
1014 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1015 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1016 CaptureGetVertexAttribPointervRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
1017 length, pointer, &lengthParam);
1018 paramBuffer.addParam(std::move(lengthParam));
1019
1020 ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
1021 InitParamValue(ParamType::TvoidPointerPointer, pointer, &pointerParam.value);
1022 CaptureGetVertexAttribPointervRobustANGLE_pointer(glState, isCallValid, index, pname, bufSize,
1023 length, pointer, &pointerParam);
1024 paramBuffer.addParam(std::move(pointerParam));
1025
1026 return CallCapture(gl::EntryPoint::GetVertexAttribPointervRobustANGLE, std::move(paramBuffer));
1027 }
1028
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)1029 CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
1030 bool isCallValid,
1031 GLint x,
1032 GLint y,
1033 GLsizei width,
1034 GLsizei height,
1035 GLenum format,
1036 GLenum type,
1037 GLsizei bufSize,
1038 GLsizei *length,
1039 GLsizei *columns,
1040 GLsizei *rows,
1041 void *pixels)
1042 {
1043 ParamBuffer paramBuffer;
1044
1045 paramBuffer.addValueParam("x", ParamType::TGLint, x);
1046 paramBuffer.addValueParam("y", ParamType::TGLint, y);
1047 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1048 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1049 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1050 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1051 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1052
1053 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1054 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1055 CaptureReadPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format, type,
1056 bufSize, length, columns, rows, pixels, &lengthParam);
1057 paramBuffer.addParam(std::move(lengthParam));
1058
1059 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
1060 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
1061 CaptureReadPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format, type,
1062 bufSize, length, columns, rows, pixels, &columnsParam);
1063 paramBuffer.addParam(std::move(columnsParam));
1064
1065 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
1066 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
1067 CaptureReadPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
1068 bufSize, length, columns, rows, pixels, &rowsParam);
1069 paramBuffer.addParam(std::move(rowsParam));
1070
1071 ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
1072 InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
1073 CaptureReadPixelsRobustANGLE_pixels(glState, isCallValid, x, y, width, height, format, type,
1074 bufSize, length, columns, rows, pixels, &pixelsParam);
1075 paramBuffer.addParam(std::move(pixelsParam));
1076
1077 return CallCapture(gl::EntryPoint::ReadPixelsRobustANGLE, std::move(paramBuffer));
1078 }
1079
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)1080 CallCapture CaptureTexImage2DRobustANGLE(const State &glState,
1081 bool isCallValid,
1082 TextureTarget targetPacked,
1083 GLint level,
1084 GLint internalformat,
1085 GLsizei width,
1086 GLsizei height,
1087 GLint border,
1088 GLenum format,
1089 GLenum type,
1090 GLsizei bufSize,
1091 const void *pixels)
1092 {
1093 ParamBuffer paramBuffer;
1094
1095 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1096 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1097 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
1098 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1099 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1100 paramBuffer.addValueParam("border", ParamType::TGLint, border);
1101 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1102 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1103 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1104
1105 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1106 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1107 CaptureTexImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, internalformat,
1108 width, height, border, format, type, bufSize, pixels,
1109 &pixelsParam);
1110 paramBuffer.addParam(std::move(pixelsParam));
1111
1112 return CallCapture(gl::EntryPoint::TexImage2DRobustANGLE, std::move(paramBuffer));
1113 }
1114
CaptureTexParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLfloat * params)1115 CallCapture CaptureTexParameterfvRobustANGLE(const State &glState,
1116 bool isCallValid,
1117 TextureType targetPacked,
1118 GLenum pname,
1119 GLsizei bufSize,
1120 const GLfloat *params)
1121 {
1122 ParamBuffer paramBuffer;
1123
1124 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1125 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1126 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1127
1128 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
1129 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
1130 CaptureTexParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
1131 params, ¶msParam);
1132 paramBuffer.addParam(std::move(paramsParam));
1133
1134 return CallCapture(gl::EntryPoint::TexParameterfvRobustANGLE, std::move(paramBuffer));
1135 }
1136
CaptureTexParameterivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)1137 CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
1138 bool isCallValid,
1139 TextureType targetPacked,
1140 GLenum pname,
1141 GLsizei bufSize,
1142 const GLint *params)
1143 {
1144 ParamBuffer paramBuffer;
1145
1146 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1147 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1148 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1149
1150 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
1151 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
1152 CaptureTexParameterivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
1153 params, ¶msParam);
1154 paramBuffer.addParam(std::move(paramsParam));
1155
1156 return CallCapture(gl::EntryPoint::TexParameterivRobustANGLE, std::move(paramBuffer));
1157 }
1158
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)1159 CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
1160 bool isCallValid,
1161 TextureTarget targetPacked,
1162 GLint level,
1163 GLint xoffset,
1164 GLint yoffset,
1165 GLsizei width,
1166 GLsizei height,
1167 GLenum format,
1168 GLenum type,
1169 GLsizei bufSize,
1170 const void *pixels)
1171 {
1172 ParamBuffer paramBuffer;
1173
1174 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1175 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1176 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
1177 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
1178 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1179 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1180 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1181 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1182 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1183
1184 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1185 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1186 CaptureTexSubImage2DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
1187 yoffset, width, height, format, type, bufSize, pixels,
1188 &pixelsParam);
1189 paramBuffer.addParam(std::move(pixelsParam));
1190
1191 return CallCapture(gl::EntryPoint::TexSubImage2DRobustANGLE, std::move(paramBuffer));
1192 }
1193
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)1194 CallCapture CaptureTexImage3DRobustANGLE(const State &glState,
1195 bool isCallValid,
1196 TextureTarget targetPacked,
1197 GLint level,
1198 GLint internalformat,
1199 GLsizei width,
1200 GLsizei height,
1201 GLsizei depth,
1202 GLint border,
1203 GLenum format,
1204 GLenum type,
1205 GLsizei bufSize,
1206 const void *pixels)
1207 {
1208 ParamBuffer paramBuffer;
1209
1210 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1211 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1212 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
1213 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1214 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1215 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1216 paramBuffer.addValueParam("border", ParamType::TGLint, border);
1217 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1218 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1219 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1220
1221 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1222 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1223 CaptureTexImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, internalformat,
1224 width, height, depth, border, format, type, bufSize, pixels,
1225 &pixelsParam);
1226 paramBuffer.addParam(std::move(pixelsParam));
1227
1228 return CallCapture(gl::EntryPoint::TexImage3DRobustANGLE, std::move(paramBuffer));
1229 }
1230
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)1231 CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState,
1232 bool isCallValid,
1233 TextureTarget targetPacked,
1234 GLint level,
1235 GLint xoffset,
1236 GLint yoffset,
1237 GLint zoffset,
1238 GLsizei width,
1239 GLsizei height,
1240 GLsizei depth,
1241 GLenum format,
1242 GLenum type,
1243 GLsizei bufSize,
1244 const void *pixels)
1245 {
1246 ParamBuffer paramBuffer;
1247
1248 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1249 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1250 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
1251 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
1252 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
1253 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1254 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1255 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1256 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1257 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
1258 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1259
1260 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1261 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1262 CaptureTexSubImage3DRobustANGLE_pixels(glState, isCallValid, targetPacked, level, xoffset,
1263 yoffset, zoffset, width, height, depth, format, type,
1264 bufSize, pixels, &pixelsParam);
1265 paramBuffer.addParam(std::move(pixelsParam));
1266
1267 return CallCapture(gl::EntryPoint::TexSubImage3DRobustANGLE, std::move(paramBuffer));
1268 }
1269
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)1270 CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState,
1271 bool isCallValid,
1272 TextureTarget targetPacked,
1273 GLint level,
1274 GLenum internalformat,
1275 GLsizei width,
1276 GLsizei height,
1277 GLint border,
1278 GLsizei imageSize,
1279 GLsizei dataSize,
1280 const GLvoid *data)
1281 {
1282 ParamBuffer paramBuffer;
1283
1284 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1285 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1286 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1287 internalformat);
1288 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1289 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1290 paramBuffer.addValueParam("border", ParamType::TGLint, border);
1291 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
1292 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
1293
1294 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
1295 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
1296 CaptureCompressedTexImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
1297 internalformat, width, height, border, imageSize,
1298 dataSize, data, &dataParam);
1299 paramBuffer.addParam(std::move(dataParam));
1300
1301 return CallCapture(gl::EntryPoint::CompressedTexImage2DRobustANGLE, std::move(paramBuffer));
1302 }
1303
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)1304 CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState,
1305 bool isCallValid,
1306 TextureTarget targetPacked,
1307 GLint level,
1308 GLsizei xoffset,
1309 GLsizei yoffset,
1310 GLsizei width,
1311 GLsizei height,
1312 GLenum format,
1313 GLsizei imageSize,
1314 GLsizei dataSize,
1315 const GLvoid *data)
1316 {
1317 ParamBuffer paramBuffer;
1318
1319 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1320 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1321 paramBuffer.addValueParam("xoffset", ParamType::TGLsizei, xoffset);
1322 paramBuffer.addValueParam("yoffset", ParamType::TGLsizei, yoffset);
1323 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1324 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1325 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1326 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
1327 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
1328
1329 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
1330 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
1331 CaptureCompressedTexSubImage2DRobustANGLE_data(glState, isCallValid, targetPacked, level,
1332 xoffset, yoffset, width, height, format,
1333 imageSize, dataSize, data, &dataParam);
1334 paramBuffer.addParam(std::move(dataParam));
1335
1336 return CallCapture(gl::EntryPoint::CompressedTexSubImage2DRobustANGLE, std::move(paramBuffer));
1337 }
1338
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)1339 CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState,
1340 bool isCallValid,
1341 TextureTarget targetPacked,
1342 GLint level,
1343 GLenum internalformat,
1344 GLsizei width,
1345 GLsizei height,
1346 GLsizei depth,
1347 GLint border,
1348 GLsizei imageSize,
1349 GLsizei dataSize,
1350 const GLvoid *data)
1351 {
1352 ParamBuffer paramBuffer;
1353
1354 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1355 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1356 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1357 internalformat);
1358 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1359 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1360 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1361 paramBuffer.addValueParam("border", ParamType::TGLint, border);
1362 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
1363 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
1364
1365 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
1366 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
1367 CaptureCompressedTexImage3DRobustANGLE_data(glState, isCallValid, targetPacked, level,
1368 internalformat, width, height, depth, border,
1369 imageSize, dataSize, data, &dataParam);
1370 paramBuffer.addParam(std::move(dataParam));
1371
1372 return CallCapture(gl::EntryPoint::CompressedTexImage3DRobustANGLE, std::move(paramBuffer));
1373 }
1374
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)1375 CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState,
1376 bool isCallValid,
1377 TextureTarget targetPacked,
1378 GLint level,
1379 GLint xoffset,
1380 GLint yoffset,
1381 GLint zoffset,
1382 GLsizei width,
1383 GLsizei height,
1384 GLsizei depth,
1385 GLenum format,
1386 GLsizei imageSize,
1387 GLsizei dataSize,
1388 const GLvoid *data)
1389 {
1390 ParamBuffer paramBuffer;
1391
1392 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1393 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1394 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
1395 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
1396 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
1397 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1398 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1399 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1400 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
1401 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
1402 paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize);
1403
1404 ParamCapture dataParam("data", ParamType::TGLvoidConstPointer);
1405 InitParamValue(ParamType::TGLvoidConstPointer, data, &dataParam.value);
1406 CaptureCompressedTexSubImage3DRobustANGLE_data(glState, isCallValid, targetPacked, level,
1407 xoffset, yoffset, zoffset, width, height, depth,
1408 format, imageSize, dataSize, data, &dataParam);
1409 paramBuffer.addParam(std::move(dataParam));
1410
1411 return CallCapture(gl::EntryPoint::CompressedTexSubImage3DRobustANGLE, std::move(paramBuffer));
1412 }
1413
CaptureGetQueryivRobustANGLE(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1414 CallCapture CaptureGetQueryivRobustANGLE(const State &glState,
1415 bool isCallValid,
1416 QueryType targetPacked,
1417 GLenum pname,
1418 GLsizei bufSize,
1419 GLsizei *length,
1420 GLint *params)
1421 {
1422 ParamBuffer paramBuffer;
1423
1424 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
1425 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1426 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1427
1428 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1429 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1430 CaptureGetQueryivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize, length,
1431 params, &lengthParam);
1432 paramBuffer.addParam(std::move(lengthParam));
1433
1434 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1435 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1436 CaptureGetQueryivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize, length,
1437 params, ¶msParam);
1438 paramBuffer.addParam(std::move(paramsParam));
1439
1440 return CallCapture(gl::EntryPoint::GetQueryivRobustANGLE, std::move(paramBuffer));
1441 }
1442
CaptureGetQueryObjectuivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)1443 CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
1444 bool isCallValid,
1445 QueryID idPacked,
1446 GLenum pname,
1447 GLsizei bufSize,
1448 GLsizei *length,
1449 GLuint *params)
1450 {
1451 ParamBuffer paramBuffer;
1452
1453 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
1454 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1455 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1456
1457 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1458 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1459 CaptureGetQueryObjectuivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
1460 length, params, &lengthParam);
1461 paramBuffer.addParam(std::move(lengthParam));
1462
1463 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
1464 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
1465 CaptureGetQueryObjectuivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
1466 length, params, ¶msParam);
1467 paramBuffer.addParam(std::move(paramsParam));
1468
1469 return CallCapture(gl::EntryPoint::GetQueryObjectuivRobustANGLE, std::move(paramBuffer));
1470 }
1471
CaptureGetBufferPointervRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)1472 CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
1473 bool isCallValid,
1474 BufferBinding targetPacked,
1475 GLenum pname,
1476 GLsizei bufSize,
1477 GLsizei *length,
1478 void **params)
1479 {
1480 ParamBuffer paramBuffer;
1481
1482 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1483 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1484 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1485
1486 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1487 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1488 CaptureGetBufferPointervRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
1489 length, params, &lengthParam);
1490 paramBuffer.addParam(std::move(lengthParam));
1491
1492 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
1493 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
1494 CaptureGetBufferPointervRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
1495 length, params, ¶msParam);
1496 paramBuffer.addParam(std::move(paramsParam));
1497
1498 return CallCapture(gl::EntryPoint::GetBufferPointervRobustANGLE, std::move(paramBuffer));
1499 }
1500
CaptureGetIntegeri_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)1501 CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
1502 bool isCallValid,
1503 GLenum target,
1504 GLuint index,
1505 GLsizei bufSize,
1506 GLsizei *length,
1507 GLint *data)
1508 {
1509 ParamBuffer paramBuffer;
1510
1511 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1512 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1513 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1514
1515 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1516 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1517 CaptureGetIntegeri_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
1518 data, &lengthParam);
1519 paramBuffer.addParam(std::move(lengthParam));
1520
1521 ParamCapture dataParam("data", ParamType::TGLintPointer);
1522 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
1523 CaptureGetIntegeri_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length, data,
1524 &dataParam);
1525 paramBuffer.addParam(std::move(dataParam));
1526
1527 return CallCapture(gl::EntryPoint::GetIntegeri_vRobustANGLE, std::move(paramBuffer));
1528 }
1529
CaptureGetInternalformativRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1530 CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
1531 bool isCallValid,
1532 GLenum target,
1533 GLenum internalformat,
1534 GLenum pname,
1535 GLsizei bufSize,
1536 GLsizei *length,
1537 GLint *params)
1538 {
1539 ParamBuffer paramBuffer;
1540
1541 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1542 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1543 internalformat);
1544 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1545 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1546
1547 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1548 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1549 CaptureGetInternalformativRobustANGLE_length(glState, isCallValid, target, internalformat,
1550 pname, bufSize, length, params, &lengthParam);
1551 paramBuffer.addParam(std::move(lengthParam));
1552
1553 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1554 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1555 CaptureGetInternalformativRobustANGLE_params(glState, isCallValid, target, internalformat,
1556 pname, bufSize, length, params, ¶msParam);
1557 paramBuffer.addParam(std::move(paramsParam));
1558
1559 return CallCapture(gl::EntryPoint::GetInternalformativRobustANGLE, std::move(paramBuffer));
1560 }
1561
CaptureGetVertexAttribIivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1562 CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
1563 bool isCallValid,
1564 GLuint index,
1565 GLenum pname,
1566 GLsizei bufSize,
1567 GLsizei *length,
1568 GLint *params)
1569 {
1570 ParamBuffer paramBuffer;
1571
1572 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1573 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1574 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1575
1576 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1577 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1578 CaptureGetVertexAttribIivRobustANGLE_length(glState, isCallValid, index, pname, bufSize, length,
1579 params, &lengthParam);
1580 paramBuffer.addParam(std::move(lengthParam));
1581
1582 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1583 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1584 CaptureGetVertexAttribIivRobustANGLE_params(glState, isCallValid, index, pname, bufSize, length,
1585 params, ¶msParam);
1586 paramBuffer.addParam(std::move(paramsParam));
1587
1588 return CallCapture(gl::EntryPoint::GetVertexAttribIivRobustANGLE, std::move(paramBuffer));
1589 }
1590
CaptureGetVertexAttribIuivRobustANGLE(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)1591 CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
1592 bool isCallValid,
1593 GLuint index,
1594 GLenum pname,
1595 GLsizei bufSize,
1596 GLsizei *length,
1597 GLuint *params)
1598 {
1599 ParamBuffer paramBuffer;
1600
1601 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1602 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1603 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1604
1605 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1606 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1607 CaptureGetVertexAttribIuivRobustANGLE_length(glState, isCallValid, index, pname, bufSize,
1608 length, params, &lengthParam);
1609 paramBuffer.addParam(std::move(lengthParam));
1610
1611 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
1612 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
1613 CaptureGetVertexAttribIuivRobustANGLE_params(glState, isCallValid, index, pname, bufSize,
1614 length, params, ¶msParam);
1615 paramBuffer.addParam(std::move(paramsParam));
1616
1617 return CallCapture(gl::EntryPoint::GetVertexAttribIuivRobustANGLE, std::move(paramBuffer));
1618 }
1619
CaptureGetUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)1620 CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
1621 bool isCallValid,
1622 ShaderProgramID programPacked,
1623 UniformLocation locationPacked,
1624 GLsizei bufSize,
1625 GLsizei *length,
1626 GLuint *params)
1627 {
1628 ParamBuffer paramBuffer;
1629
1630 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1631 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
1632 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1633
1634 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1635 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1636 CaptureGetUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
1637 bufSize, length, params, &lengthParam);
1638 paramBuffer.addParam(std::move(lengthParam));
1639
1640 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
1641 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
1642 CaptureGetUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
1643 bufSize, length, params, ¶msParam);
1644 paramBuffer.addParam(std::move(paramsParam));
1645
1646 return CallCapture(gl::EntryPoint::GetUniformuivRobustANGLE, std::move(paramBuffer));
1647 }
1648
CaptureGetActiveUniformBlockivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1649 CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState,
1650 bool isCallValid,
1651 ShaderProgramID programPacked,
1652 GLuint uniformBlockIndex,
1653 GLenum pname,
1654 GLsizei bufSize,
1655 GLsizei *length,
1656 GLint *params)
1657 {
1658 ParamBuffer paramBuffer;
1659
1660 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1661 paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
1662 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1663 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1664
1665 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1666 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1667 CaptureGetActiveUniformBlockivRobustANGLE_length(glState, isCallValid, programPacked,
1668 uniformBlockIndex, pname, bufSize, length,
1669 params, &lengthParam);
1670 paramBuffer.addParam(std::move(lengthParam));
1671
1672 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1673 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1674 CaptureGetActiveUniformBlockivRobustANGLE_params(glState, isCallValid, programPacked,
1675 uniformBlockIndex, pname, bufSize, length,
1676 params, ¶msParam);
1677 paramBuffer.addParam(std::move(paramsParam));
1678
1679 return CallCapture(gl::EntryPoint::GetActiveUniformBlockivRobustANGLE, std::move(paramBuffer));
1680 }
1681
CaptureGetInteger64vRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)1682 CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
1683 bool isCallValid,
1684 GLenum pname,
1685 GLsizei bufSize,
1686 GLsizei *length,
1687 GLint64 *data)
1688 {
1689 ParamBuffer paramBuffer;
1690
1691 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1692 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1693
1694 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1695 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1696 CaptureGetInteger64vRobustANGLE_length(glState, isCallValid, pname, bufSize, length, data,
1697 &lengthParam);
1698 paramBuffer.addParam(std::move(lengthParam));
1699
1700 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
1701 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
1702 CaptureGetInteger64vRobustANGLE_data(glState, isCallValid, pname, bufSize, length, data,
1703 &dataParam);
1704 paramBuffer.addParam(std::move(dataParam));
1705
1706 return CallCapture(gl::EntryPoint::GetInteger64vRobustANGLE, std::move(paramBuffer));
1707 }
1708
CaptureGetInteger64i_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)1709 CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
1710 bool isCallValid,
1711 GLenum target,
1712 GLuint index,
1713 GLsizei bufSize,
1714 GLsizei *length,
1715 GLint64 *data)
1716 {
1717 ParamBuffer paramBuffer;
1718
1719 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1720 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1721 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1722
1723 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1724 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1725 CaptureGetInteger64i_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
1726 data, &lengthParam);
1727 paramBuffer.addParam(std::move(lengthParam));
1728
1729 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
1730 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
1731 CaptureGetInteger64i_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length,
1732 data, &dataParam);
1733 paramBuffer.addParam(std::move(dataParam));
1734
1735 return CallCapture(gl::EntryPoint::GetInteger64i_vRobustANGLE, std::move(paramBuffer));
1736 }
1737
CaptureGetBufferParameteri64vRobustANGLE(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)1738 CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
1739 bool isCallValid,
1740 BufferBinding targetPacked,
1741 GLenum pname,
1742 GLsizei bufSize,
1743 GLsizei *length,
1744 GLint64 *params)
1745 {
1746 ParamBuffer paramBuffer;
1747
1748 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1749 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1750 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1751
1752 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1753 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1754 CaptureGetBufferParameteri64vRobustANGLE_length(glState, isCallValid, targetPacked, pname,
1755 bufSize, length, params, &lengthParam);
1756 paramBuffer.addParam(std::move(lengthParam));
1757
1758 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
1759 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
1760 CaptureGetBufferParameteri64vRobustANGLE_params(glState, isCallValid, targetPacked, pname,
1761 bufSize, length, params, ¶msParam);
1762 paramBuffer.addParam(std::move(paramsParam));
1763
1764 return CallCapture(gl::EntryPoint::GetBufferParameteri64vRobustANGLE, std::move(paramBuffer));
1765 }
1766
CaptureSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLuint pname,GLsizei bufSize,const GLint * param)1767 CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
1768 bool isCallValid,
1769 SamplerID samplerPacked,
1770 GLuint pname,
1771 GLsizei bufSize,
1772 const GLint *param)
1773 {
1774 ParamBuffer paramBuffer;
1775
1776 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
1777 paramBuffer.addValueParam("pname", ParamType::TGLuint, pname);
1778 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1779
1780 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
1781 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
1782 CaptureSamplerParameterivRobustANGLE_param(glState, isCallValid, samplerPacked, pname, bufSize,
1783 param, ¶mParam);
1784 paramBuffer.addParam(std::move(paramParam));
1785
1786 return CallCapture(gl::EntryPoint::SamplerParameterivRobustANGLE, std::move(paramBuffer));
1787 }
1788
CaptureSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLfloat * param)1789 CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
1790 bool isCallValid,
1791 SamplerID samplerPacked,
1792 GLenum pname,
1793 GLsizei bufSize,
1794 const GLfloat *param)
1795 {
1796 ParamBuffer paramBuffer;
1797
1798 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
1799 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1800 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1801
1802 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
1803 InitParamValue(ParamType::TGLfloatConstPointer, param, ¶mParam.value);
1804 CaptureSamplerParameterfvRobustANGLE_param(glState, isCallValid, samplerPacked, pname, bufSize,
1805 param, ¶mParam);
1806 paramBuffer.addParam(std::move(paramParam));
1807
1808 return CallCapture(gl::EntryPoint::SamplerParameterfvRobustANGLE, std::move(paramBuffer));
1809 }
1810
CaptureGetSamplerParameterivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1811 CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
1812 bool isCallValid,
1813 SamplerID samplerPacked,
1814 GLenum pname,
1815 GLsizei bufSize,
1816 GLsizei *length,
1817 GLint *params)
1818 {
1819 ParamBuffer paramBuffer;
1820
1821 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
1822 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1823 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1824
1825 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1826 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1827 CaptureGetSamplerParameterivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
1828 bufSize, length, params, &lengthParam);
1829 paramBuffer.addParam(std::move(lengthParam));
1830
1831 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1832 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1833 CaptureGetSamplerParameterivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
1834 bufSize, length, params, ¶msParam);
1835 paramBuffer.addParam(std::move(paramsParam));
1836
1837 return CallCapture(gl::EntryPoint::GetSamplerParameterivRobustANGLE, std::move(paramBuffer));
1838 }
1839
CaptureGetSamplerParameterfvRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1840 CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
1841 bool isCallValid,
1842 SamplerID samplerPacked,
1843 GLenum pname,
1844 GLsizei bufSize,
1845 GLsizei *length,
1846 GLfloat *params)
1847 {
1848 ParamBuffer paramBuffer;
1849
1850 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
1851 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1852 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1853
1854 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1855 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1856 CaptureGetSamplerParameterfvRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
1857 bufSize, length, params, &lengthParam);
1858 paramBuffer.addParam(std::move(lengthParam));
1859
1860 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
1861 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
1862 CaptureGetSamplerParameterfvRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
1863 bufSize, length, params, ¶msParam);
1864 paramBuffer.addParam(std::move(paramsParam));
1865
1866 return CallCapture(gl::EntryPoint::GetSamplerParameterfvRobustANGLE, std::move(paramBuffer));
1867 }
1868
CaptureGetFramebufferParameterivRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1869 CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
1870 bool isCallValid,
1871 GLenum target,
1872 GLenum pname,
1873 GLsizei bufSize,
1874 GLsizei *length,
1875 GLint *params)
1876 {
1877 ParamBuffer paramBuffer;
1878
1879 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1880 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1881 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1882
1883 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1884 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1885 CaptureGetFramebufferParameterivRobustANGLE_length(glState, isCallValid, target, pname, bufSize,
1886 length, params, &lengthParam);
1887 paramBuffer.addParam(std::move(lengthParam));
1888
1889 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1890 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1891 CaptureGetFramebufferParameterivRobustANGLE_params(glState, isCallValid, target, pname, bufSize,
1892 length, params, ¶msParam);
1893 paramBuffer.addParam(std::move(paramsParam));
1894
1895 return CallCapture(gl::EntryPoint::GetFramebufferParameterivRobustANGLE,
1896 std::move(paramBuffer));
1897 }
1898
CaptureGetProgramInterfaceivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1899 CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
1900 bool isCallValid,
1901 ShaderProgramID programPacked,
1902 GLenum programInterface,
1903 GLenum pname,
1904 GLsizei bufSize,
1905 GLsizei *length,
1906 GLint *params)
1907 {
1908 ParamBuffer paramBuffer;
1909
1910 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
1911 paramBuffer.addEnumParam("programInterface", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1912 programInterface);
1913 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1914 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1915
1916 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1917 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1918 CaptureGetProgramInterfaceivRobustANGLE_length(glState, isCallValid, programPacked,
1919 programInterface, pname, bufSize, length, params,
1920 &lengthParam);
1921 paramBuffer.addParam(std::move(lengthParam));
1922
1923 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1924 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1925 CaptureGetProgramInterfaceivRobustANGLE_params(glState, isCallValid, programPacked,
1926 programInterface, pname, bufSize, length, params,
1927 ¶msParam);
1928 paramBuffer.addParam(std::move(paramsParam));
1929
1930 return CallCapture(gl::EntryPoint::GetProgramInterfaceivRobustANGLE, std::move(paramBuffer));
1931 }
1932
CaptureGetBooleani_vRobustANGLE(const State & glState,bool isCallValid,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)1933 CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
1934 bool isCallValid,
1935 GLenum target,
1936 GLuint index,
1937 GLsizei bufSize,
1938 GLsizei *length,
1939 GLboolean *data)
1940 {
1941 ParamBuffer paramBuffer;
1942
1943 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1944 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1945 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1946
1947 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1948 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1949 CaptureGetBooleani_vRobustANGLE_length(glState, isCallValid, target, index, bufSize, length,
1950 data, &lengthParam);
1951 paramBuffer.addParam(std::move(lengthParam));
1952
1953 ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
1954 InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
1955 CaptureGetBooleani_vRobustANGLE_data(glState, isCallValid, target, index, bufSize, length, data,
1956 &dataParam);
1957 paramBuffer.addParam(std::move(dataParam));
1958
1959 return CallCapture(gl::EntryPoint::GetBooleani_vRobustANGLE, std::move(paramBuffer));
1960 }
1961
CaptureGetMultisamplefvRobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)1962 CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
1963 bool isCallValid,
1964 GLenum pname,
1965 GLuint index,
1966 GLsizei bufSize,
1967 GLsizei *length,
1968 GLfloat *val)
1969 {
1970 ParamBuffer paramBuffer;
1971
1972 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
1973 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1974 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1975
1976 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1977 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1978 CaptureGetMultisamplefvRobustANGLE_length(glState, isCallValid, pname, index, bufSize, length,
1979 val, &lengthParam);
1980 paramBuffer.addParam(std::move(lengthParam));
1981
1982 ParamCapture valParam("val", ParamType::TGLfloatPointer);
1983 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
1984 CaptureGetMultisamplefvRobustANGLE_val(glState, isCallValid, pname, index, bufSize, length, val,
1985 &valParam);
1986 paramBuffer.addParam(std::move(valParam));
1987
1988 return CallCapture(gl::EntryPoint::GetMultisamplefvRobustANGLE, std::move(paramBuffer));
1989 }
1990
CaptureGetTexLevelParameterivRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1991 CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
1992 bool isCallValid,
1993 TextureTarget targetPacked,
1994 GLint level,
1995 GLenum pname,
1996 GLsizei bufSize,
1997 GLsizei *length,
1998 GLint *params)
1999 {
2000 ParamBuffer paramBuffer;
2001
2002 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2003 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2004 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2005 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2006
2007 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2008 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2009 CaptureGetTexLevelParameterivRobustANGLE_length(glState, isCallValid, targetPacked, level,
2010 pname, bufSize, length, params, &lengthParam);
2011 paramBuffer.addParam(std::move(lengthParam));
2012
2013 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2014 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2015 CaptureGetTexLevelParameterivRobustANGLE_params(glState, isCallValid, targetPacked, level,
2016 pname, bufSize, length, params, ¶msParam);
2017 paramBuffer.addParam(std::move(paramsParam));
2018
2019 return CallCapture(gl::EntryPoint::GetTexLevelParameterivRobustANGLE, std::move(paramBuffer));
2020 }
2021
CaptureGetTexLevelParameterfvRobustANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2022 CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
2023 bool isCallValid,
2024 TextureTarget targetPacked,
2025 GLint level,
2026 GLenum pname,
2027 GLsizei bufSize,
2028 GLsizei *length,
2029 GLfloat *params)
2030 {
2031 ParamBuffer paramBuffer;
2032
2033 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2034 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2035 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2036 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2037
2038 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2039 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2040 CaptureGetTexLevelParameterfvRobustANGLE_length(glState, isCallValid, targetPacked, level,
2041 pname, bufSize, length, params, &lengthParam);
2042 paramBuffer.addParam(std::move(lengthParam));
2043
2044 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2045 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2046 CaptureGetTexLevelParameterfvRobustANGLE_params(glState, isCallValid, targetPacked, level,
2047 pname, bufSize, length, params, ¶msParam);
2048 paramBuffer.addParam(std::move(paramsParam));
2049
2050 return CallCapture(gl::EntryPoint::GetTexLevelParameterfvRobustANGLE, std::move(paramBuffer));
2051 }
2052
CaptureGetPointervRobustANGLERobustANGLE(const State & glState,bool isCallValid,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2053 CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
2054 bool isCallValid,
2055 GLenum pname,
2056 GLsizei bufSize,
2057 GLsizei *length,
2058 void **params)
2059 {
2060 ParamBuffer paramBuffer;
2061
2062 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2063 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2064
2065 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2066 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2067 CaptureGetPointervRobustANGLERobustANGLE_length(glState, isCallValid, pname, bufSize, length,
2068 params, &lengthParam);
2069 paramBuffer.addParam(std::move(lengthParam));
2070
2071 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
2072 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
2073 CaptureGetPointervRobustANGLERobustANGLE_params(glState, isCallValid, pname, bufSize, length,
2074 params, ¶msParam);
2075 paramBuffer.addParam(std::move(paramsParam));
2076
2077 return CallCapture(gl::EntryPoint::GetPointervRobustANGLERobustANGLE, std::move(paramBuffer));
2078 }
2079
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)2080 CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
2081 bool isCallValid,
2082 GLint x,
2083 GLint y,
2084 GLsizei width,
2085 GLsizei height,
2086 GLenum format,
2087 GLenum type,
2088 GLsizei bufSize,
2089 GLsizei *length,
2090 GLsizei *columns,
2091 GLsizei *rows,
2092 void *data)
2093 {
2094 ParamBuffer paramBuffer;
2095
2096 paramBuffer.addValueParam("x", ParamType::TGLint, x);
2097 paramBuffer.addValueParam("y", ParamType::TGLint, y);
2098 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2099 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2100 paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format);
2101 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
2102 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2103
2104 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2105 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2106 CaptureReadnPixelsRobustANGLE_length(glState, isCallValid, x, y, width, height, format, type,
2107 bufSize, length, columns, rows, data, &lengthParam);
2108 paramBuffer.addParam(std::move(lengthParam));
2109
2110 ParamCapture columnsParam("columns", ParamType::TGLsizeiPointer);
2111 InitParamValue(ParamType::TGLsizeiPointer, columns, &columnsParam.value);
2112 CaptureReadnPixelsRobustANGLE_columns(glState, isCallValid, x, y, width, height, format, type,
2113 bufSize, length, columns, rows, data, &columnsParam);
2114 paramBuffer.addParam(std::move(columnsParam));
2115
2116 ParamCapture rowsParam("rows", ParamType::TGLsizeiPointer);
2117 InitParamValue(ParamType::TGLsizeiPointer, rows, &rowsParam.value);
2118 CaptureReadnPixelsRobustANGLE_rows(glState, isCallValid, x, y, width, height, format, type,
2119 bufSize, length, columns, rows, data, &rowsParam);
2120 paramBuffer.addParam(std::move(rowsParam));
2121
2122 ParamCapture dataParam("data", ParamType::TvoidPointer);
2123 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
2124 CaptureReadnPixelsRobustANGLE_data(glState, isCallValid, x, y, width, height, format, type,
2125 bufSize, length, columns, rows, data, &dataParam);
2126 paramBuffer.addParam(std::move(dataParam));
2127
2128 return CallCapture(gl::EntryPoint::ReadnPixelsRobustANGLE, std::move(paramBuffer));
2129 }
2130
CaptureGetnUniformfvRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLfloat * params)2131 CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
2132 bool isCallValid,
2133 ShaderProgramID programPacked,
2134 UniformLocation locationPacked,
2135 GLsizei bufSize,
2136 GLsizei *length,
2137 GLfloat *params)
2138 {
2139 ParamBuffer paramBuffer;
2140
2141 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2142 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2143 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2144
2145 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2146 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2147 CaptureGetnUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2148 bufSize, length, params, &lengthParam);
2149 paramBuffer.addParam(std::move(lengthParam));
2150
2151 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2152 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2153 CaptureGetnUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2154 bufSize, length, params, ¶msParam);
2155 paramBuffer.addParam(std::move(paramsParam));
2156
2157 return CallCapture(gl::EntryPoint::GetnUniformfvRobustANGLE, std::move(paramBuffer));
2158 }
2159
CaptureGetnUniformivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLint * params)2160 CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
2161 bool isCallValid,
2162 ShaderProgramID programPacked,
2163 UniformLocation locationPacked,
2164 GLsizei bufSize,
2165 GLsizei *length,
2166 GLint *params)
2167 {
2168 ParamBuffer paramBuffer;
2169
2170 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2171 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2172 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2173
2174 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2175 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2176 CaptureGetnUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2177 bufSize, length, params, &lengthParam);
2178 paramBuffer.addParam(std::move(lengthParam));
2179
2180 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2181 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2182 CaptureGetnUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2183 bufSize, length, params, ¶msParam);
2184 paramBuffer.addParam(std::move(paramsParam));
2185
2186 return CallCapture(gl::EntryPoint::GetnUniformivRobustANGLE, std::move(paramBuffer));
2187 }
2188
CaptureGetnUniformuivRobustANGLE(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLsizei * length,GLuint * params)2189 CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
2190 bool isCallValid,
2191 ShaderProgramID programPacked,
2192 UniformLocation locationPacked,
2193 GLsizei bufSize,
2194 GLsizei *length,
2195 GLuint *params)
2196 {
2197 ParamBuffer paramBuffer;
2198
2199 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2200 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2201 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2202
2203 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2204 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2205 CaptureGetnUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
2206 bufSize, length, params, &lengthParam);
2207 paramBuffer.addParam(std::move(lengthParam));
2208
2209 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2210 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2211 CaptureGetnUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
2212 bufSize, length, params, ¶msParam);
2213 paramBuffer.addParam(std::move(paramsParam));
2214
2215 return CallCapture(gl::EntryPoint::GetnUniformuivRobustANGLE, std::move(paramBuffer));
2216 }
2217
CaptureTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLint * params)2218 CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
2219 bool isCallValid,
2220 TextureType targetPacked,
2221 GLenum pname,
2222 GLsizei bufSize,
2223 const GLint *params)
2224 {
2225 ParamBuffer paramBuffer;
2226
2227 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2228 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2229 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2230
2231 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
2232 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
2233 CaptureTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2234 params, ¶msParam);
2235 paramBuffer.addParam(std::move(paramsParam));
2236
2237 return CallCapture(gl::EntryPoint::TexParameterIivRobustANGLE, std::move(paramBuffer));
2238 }
2239
CaptureTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,const GLuint * params)2240 CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
2241 bool isCallValid,
2242 TextureType targetPacked,
2243 GLenum pname,
2244 GLsizei bufSize,
2245 const GLuint *params)
2246 {
2247 ParamBuffer paramBuffer;
2248
2249 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2250 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2251 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2252
2253 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
2254 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
2255 CaptureTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2256 params, ¶msParam);
2257 paramBuffer.addParam(std::move(paramsParam));
2258
2259 return CallCapture(gl::EntryPoint::TexParameterIuivRobustANGLE, std::move(paramBuffer));
2260 }
2261
CaptureGetTexParameterIivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2262 CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
2263 bool isCallValid,
2264 TextureType targetPacked,
2265 GLenum pname,
2266 GLsizei bufSize,
2267 GLsizei *length,
2268 GLint *params)
2269 {
2270 ParamBuffer paramBuffer;
2271
2272 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2273 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2274 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2275
2276 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2277 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2278 CaptureGetTexParameterIivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
2279 length, params, &lengthParam);
2280 paramBuffer.addParam(std::move(lengthParam));
2281
2282 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2283 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2284 CaptureGetTexParameterIivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2285 length, params, ¶msParam);
2286 paramBuffer.addParam(std::move(paramsParam));
2287
2288 return CallCapture(gl::EntryPoint::GetTexParameterIivRobustANGLE, std::move(paramBuffer));
2289 }
2290
CaptureGetTexParameterIuivRobustANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2291 CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
2292 bool isCallValid,
2293 TextureType targetPacked,
2294 GLenum pname,
2295 GLsizei bufSize,
2296 GLsizei *length,
2297 GLuint *params)
2298 {
2299 ParamBuffer paramBuffer;
2300
2301 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2302 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2303 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2304
2305 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2306 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2307 CaptureGetTexParameterIuivRobustANGLE_length(glState, isCallValid, targetPacked, pname, bufSize,
2308 length, params, &lengthParam);
2309 paramBuffer.addParam(std::move(lengthParam));
2310
2311 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2312 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2313 CaptureGetTexParameterIuivRobustANGLE_params(glState, isCallValid, targetPacked, pname, bufSize,
2314 length, params, ¶msParam);
2315 paramBuffer.addParam(std::move(paramsParam));
2316
2317 return CallCapture(gl::EntryPoint::GetTexParameterIuivRobustANGLE, std::move(paramBuffer));
2318 }
2319
CaptureSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLint * param)2320 CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
2321 bool isCallValid,
2322 SamplerID samplerPacked,
2323 GLenum pname,
2324 GLsizei bufSize,
2325 const GLint *param)
2326 {
2327 ParamBuffer paramBuffer;
2328
2329 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2330 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2331 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2332
2333 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
2334 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
2335 CaptureSamplerParameterIivRobustANGLE_param(glState, isCallValid, samplerPacked, pname, bufSize,
2336 param, ¶mParam);
2337 paramBuffer.addParam(std::move(paramParam));
2338
2339 return CallCapture(gl::EntryPoint::SamplerParameterIivRobustANGLE, std::move(paramBuffer));
2340 }
2341
CaptureSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,const GLuint * param)2342 CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
2343 bool isCallValid,
2344 SamplerID samplerPacked,
2345 GLenum pname,
2346 GLsizei bufSize,
2347 const GLuint *param)
2348 {
2349 ParamBuffer paramBuffer;
2350
2351 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2352 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2353 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2354
2355 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
2356 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
2357 CaptureSamplerParameterIuivRobustANGLE_param(glState, isCallValid, samplerPacked, pname,
2358 bufSize, param, ¶mParam);
2359 paramBuffer.addParam(std::move(paramParam));
2360
2361 return CallCapture(gl::EntryPoint::SamplerParameterIuivRobustANGLE, std::move(paramBuffer));
2362 }
2363
CaptureGetSamplerParameterIivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2364 CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
2365 bool isCallValid,
2366 SamplerID samplerPacked,
2367 GLenum pname,
2368 GLsizei bufSize,
2369 GLsizei *length,
2370 GLint *params)
2371 {
2372 ParamBuffer paramBuffer;
2373
2374 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2375 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2376 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2377
2378 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2379 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2380 CaptureGetSamplerParameterIivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
2381 bufSize, length, params, &lengthParam);
2382 paramBuffer.addParam(std::move(lengthParam));
2383
2384 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2385 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2386 CaptureGetSamplerParameterIivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
2387 bufSize, length, params, ¶msParam);
2388 paramBuffer.addParam(std::move(paramsParam));
2389
2390 return CallCapture(gl::EntryPoint::GetSamplerParameterIivRobustANGLE, std::move(paramBuffer));
2391 }
2392
CaptureGetSamplerParameterIuivRobustANGLE(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2393 CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
2394 bool isCallValid,
2395 SamplerID samplerPacked,
2396 GLenum pname,
2397 GLsizei bufSize,
2398 GLsizei *length,
2399 GLuint *params)
2400 {
2401 ParamBuffer paramBuffer;
2402
2403 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
2404 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2405 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2406
2407 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2408 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2409 CaptureGetSamplerParameterIuivRobustANGLE_length(glState, isCallValid, samplerPacked, pname,
2410 bufSize, length, params, &lengthParam);
2411 paramBuffer.addParam(std::move(lengthParam));
2412
2413 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
2414 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
2415 CaptureGetSamplerParameterIuivRobustANGLE_params(glState, isCallValid, samplerPacked, pname,
2416 bufSize, length, params, ¶msParam);
2417 paramBuffer.addParam(std::move(paramsParam));
2418
2419 return CallCapture(gl::EntryPoint::GetSamplerParameterIuivRobustANGLE, std::move(paramBuffer));
2420 }
2421
CaptureGetQueryObjectivRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2422 CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
2423 bool isCallValid,
2424 QueryID idPacked,
2425 GLenum pname,
2426 GLsizei bufSize,
2427 GLsizei *length,
2428 GLint *params)
2429 {
2430 ParamBuffer paramBuffer;
2431
2432 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2433 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2434 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2435
2436 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2437 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2438 CaptureGetQueryObjectivRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
2439 length, params, &lengthParam);
2440 paramBuffer.addParam(std::move(lengthParam));
2441
2442 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2443 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2444 CaptureGetQueryObjectivRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
2445 length, params, ¶msParam);
2446 paramBuffer.addParam(std::move(paramsParam));
2447
2448 return CallCapture(gl::EntryPoint::GetQueryObjectivRobustANGLE, std::move(paramBuffer));
2449 }
2450
CaptureGetQueryObjecti64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)2451 CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
2452 bool isCallValid,
2453 QueryID idPacked,
2454 GLenum pname,
2455 GLsizei bufSize,
2456 GLsizei *length,
2457 GLint64 *params)
2458 {
2459 ParamBuffer paramBuffer;
2460
2461 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2462 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2463 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2464
2465 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2466 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2467 CaptureGetQueryObjecti64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
2468 length, params, &lengthParam);
2469 paramBuffer.addParam(std::move(lengthParam));
2470
2471 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
2472 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
2473 CaptureGetQueryObjecti64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
2474 length, params, ¶msParam);
2475 paramBuffer.addParam(std::move(paramsParam));
2476
2477 return CallCapture(gl::EntryPoint::GetQueryObjecti64vRobustANGLE, std::move(paramBuffer));
2478 }
2479
CaptureGetQueryObjectui64vRobustANGLE(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)2480 CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
2481 bool isCallValid,
2482 QueryID idPacked,
2483 GLenum pname,
2484 GLsizei bufSize,
2485 GLsizei *length,
2486 GLuint64 *params)
2487 {
2488 ParamBuffer paramBuffer;
2489
2490 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2491 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2492 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
2493
2494 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2495 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2496 CaptureGetQueryObjectui64vRobustANGLE_length(glState, isCallValid, idPacked, pname, bufSize,
2497 length, params, &lengthParam);
2498 paramBuffer.addParam(std::move(lengthParam));
2499
2500 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
2501 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
2502 CaptureGetQueryObjectui64vRobustANGLE_params(glState, isCallValid, idPacked, pname, bufSize,
2503 length, params, ¶msParam);
2504 paramBuffer.addParam(std::move(paramsParam));
2505
2506 return CallCapture(gl::EntryPoint::GetQueryObjectui64vRobustANGLE, std::move(paramBuffer));
2507 }
2508
CaptureImportSemaphoreZirconHandleANGLE(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLuint handle)2509 CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
2510 bool isCallValid,
2511 SemaphoreID semaphorePacked,
2512 HandleType handleTypePacked,
2513 GLuint handle)
2514 {
2515 ParamBuffer paramBuffer;
2516
2517 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
2518 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
2519 paramBuffer.addValueParam("handle", ParamType::TGLuint, handle);
2520
2521 return CallCapture(gl::EntryPoint::ImportSemaphoreZirconHandleANGLE, std::move(paramBuffer));
2522 }
2523
CaptureTexImage2DExternalANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)2524 CallCapture CaptureTexImage2DExternalANGLE(const State &glState,
2525 bool isCallValid,
2526 TextureTarget targetPacked,
2527 GLint level,
2528 GLint internalformat,
2529 GLsizei width,
2530 GLsizei height,
2531 GLint border,
2532 GLenum format,
2533 GLenum type)
2534 {
2535 ParamBuffer paramBuffer;
2536
2537 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2538 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2539 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
2540 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2541 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2542 paramBuffer.addValueParam("border", ParamType::TGLint, border);
2543 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
2544 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
2545
2546 return CallCapture(gl::EntryPoint::TexImage2DExternalANGLE, std::move(paramBuffer));
2547 }
2548
CaptureInvalidateTextureANGLE(const State & glState,bool isCallValid,TextureType targetPacked)2549 CallCapture CaptureInvalidateTextureANGLE(const State &glState,
2550 bool isCallValid,
2551 TextureType targetPacked)
2552 {
2553 ParamBuffer paramBuffer;
2554
2555 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2556
2557 return CallCapture(gl::EntryPoint::InvalidateTextureANGLE, std::move(paramBuffer));
2558 }
2559
CaptureTexStorage2DMultisampleANGLE(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)2560 CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
2561 bool isCallValid,
2562 TextureType targetPacked,
2563 GLsizei samples,
2564 GLenum internalformat,
2565 GLsizei width,
2566 GLsizei height,
2567 GLboolean fixedsamplelocations)
2568 {
2569 ParamBuffer paramBuffer;
2570
2571 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
2572 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
2573 paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
2574 internalformat);
2575 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
2576 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
2577 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
2578
2579 return CallCapture(gl::EntryPoint::TexStorage2DMultisampleANGLE, std::move(paramBuffer));
2580 }
2581
CaptureGetTexLevelParameterivANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLint * params)2582 CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
2583 bool isCallValid,
2584 TextureTarget targetPacked,
2585 GLint level,
2586 GLenum pname,
2587 GLint *params)
2588 {
2589 ParamBuffer paramBuffer;
2590
2591 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2592 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2593 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2594
2595 ParamCapture paramsParam("params", ParamType::TGLintPointer);
2596 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
2597 CaptureGetTexLevelParameterivANGLE_params(glState, isCallValid, targetPacked, level, pname,
2598 params, ¶msParam);
2599 paramBuffer.addParam(std::move(paramsParam));
2600
2601 return CallCapture(gl::EntryPoint::GetTexLevelParameterivANGLE, std::move(paramBuffer));
2602 }
2603
CaptureGetTexLevelParameterfvANGLE(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLfloat * params)2604 CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
2605 bool isCallValid,
2606 TextureTarget targetPacked,
2607 GLint level,
2608 GLenum pname,
2609 GLfloat *params)
2610 {
2611 ParamBuffer paramBuffer;
2612
2613 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
2614 paramBuffer.addValueParam("level", ParamType::TGLint, level);
2615 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2616
2617 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
2618 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
2619 CaptureGetTexLevelParameterfvANGLE_params(glState, isCallValid, targetPacked, level, pname,
2620 params, ¶msParam);
2621 paramBuffer.addParam(std::move(paramsParam));
2622
2623 return CallCapture(gl::EntryPoint::GetTexLevelParameterfvANGLE, std::move(paramBuffer));
2624 }
2625
CaptureGetMultisamplefvANGLE(const State & glState,bool isCallValid,GLenum pname,GLuint index,GLfloat * val)2626 CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
2627 bool isCallValid,
2628 GLenum pname,
2629 GLuint index,
2630 GLfloat *val)
2631 {
2632 ParamBuffer paramBuffer;
2633
2634 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
2635 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2636
2637 ParamCapture valParam("val", ParamType::TGLfloatPointer);
2638 InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
2639 CaptureGetMultisamplefvANGLE_val(glState, isCallValid, pname, index, val, &valParam);
2640 paramBuffer.addParam(std::move(valParam));
2641
2642 return CallCapture(gl::EntryPoint::GetMultisamplefvANGLE, std::move(paramBuffer));
2643 }
2644
CaptureSampleMaskiANGLE(const State & glState,bool isCallValid,GLuint maskNumber,GLbitfield mask)2645 CallCapture CaptureSampleMaskiANGLE(const State &glState,
2646 bool isCallValid,
2647 GLuint maskNumber,
2648 GLbitfield mask)
2649 {
2650 ParamBuffer paramBuffer;
2651
2652 paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber);
2653 paramBuffer.addEnumParam("mask", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, mask);
2654
2655 return CallCapture(gl::EntryPoint::SampleMaskiANGLE, std::move(paramBuffer));
2656 }
2657
CaptureGetTranslatedShaderSourceANGLE(const State & glState,bool isCallValid,ShaderProgramID shaderPacked,GLsizei bufsize,GLsizei * length,GLchar * source)2658 CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
2659 bool isCallValid,
2660 ShaderProgramID shaderPacked,
2661 GLsizei bufsize,
2662 GLsizei *length,
2663 GLchar *source)
2664 {
2665 ParamBuffer paramBuffer;
2666
2667 paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
2668 paramBuffer.addValueParam("bufsize", ParamType::TGLsizei, bufsize);
2669
2670 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
2671 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
2672 CaptureGetTranslatedShaderSourceANGLE_length(glState, isCallValid, shaderPacked, bufsize,
2673 length, source, &lengthParam);
2674 paramBuffer.addParam(std::move(lengthParam));
2675
2676 ParamCapture sourceParam("source", ParamType::TGLcharPointer);
2677 InitParamValue(ParamType::TGLcharPointer, source, &sourceParam.value);
2678 CaptureGetTranslatedShaderSourceANGLE_source(glState, isCallValid, shaderPacked, bufsize,
2679 length, source, &sourceParam);
2680 paramBuffer.addParam(std::move(sourceParam));
2681
2682 return CallCapture(gl::EntryPoint::GetTranslatedShaderSourceANGLE, std::move(paramBuffer));
2683 }
2684
CaptureBindUniformLocationCHROMIUM(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,const GLchar * name)2685 CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
2686 bool isCallValid,
2687 ShaderProgramID programPacked,
2688 UniformLocation locationPacked,
2689 const GLchar *name)
2690 {
2691 ParamBuffer paramBuffer;
2692
2693 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2694 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
2695
2696 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
2697 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
2698 CaptureBindUniformLocationCHROMIUM_name(glState, isCallValid, programPacked, locationPacked,
2699 name, &nameParam);
2700 paramBuffer.addParam(std::move(nameParam));
2701
2702 return CallCapture(gl::EntryPoint::BindUniformLocationCHROMIUM, std::move(paramBuffer));
2703 }
2704
CaptureCompressedCopyTextureCHROMIUM(const State & glState,bool isCallValid,TextureID sourceIdPacked,TextureID destIdPacked)2705 CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
2706 bool isCallValid,
2707 TextureID sourceIdPacked,
2708 TextureID destIdPacked)
2709 {
2710 ParamBuffer paramBuffer;
2711
2712 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
2713 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
2714
2715 return CallCapture(gl::EntryPoint::CompressedCopyTextureCHROMIUM, std::move(paramBuffer));
2716 }
2717
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)2718 CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
2719 bool isCallValid,
2720 TextureID sourceIdPacked,
2721 GLint sourceLevel,
2722 TextureTarget destTargetPacked,
2723 TextureID destIdPacked,
2724 GLint destLevel,
2725 GLint internalFormat,
2726 GLenum destType,
2727 GLboolean unpackFlipY,
2728 GLboolean unpackPremultiplyAlpha,
2729 GLboolean unpackUnmultiplyAlpha)
2730 {
2731 ParamBuffer paramBuffer;
2732
2733 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
2734 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
2735 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
2736 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
2737 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
2738 paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat);
2739 paramBuffer.addEnumParam("destType", GLenumGroup::DefaultGroup, ParamType::TGLenum, destType);
2740 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
2741 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
2742 unpackPremultiplyAlpha);
2743 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
2744 unpackUnmultiplyAlpha);
2745
2746 return CallCapture(gl::EntryPoint::CopyTextureCHROMIUM, std::move(paramBuffer));
2747 }
2748
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)2749 CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
2750 bool isCallValid,
2751 TextureID sourceIdPacked,
2752 GLint sourceLevel,
2753 TextureTarget destTargetPacked,
2754 TextureID destIdPacked,
2755 GLint destLevel,
2756 GLint xoffset,
2757 GLint yoffset,
2758 GLint x,
2759 GLint y,
2760 GLint width,
2761 GLint height,
2762 GLboolean unpackFlipY,
2763 GLboolean unpackPremultiplyAlpha,
2764 GLboolean unpackUnmultiplyAlpha)
2765 {
2766 ParamBuffer paramBuffer;
2767
2768 paramBuffer.addValueParam("sourceIdPacked", ParamType::TTextureID, sourceIdPacked);
2769 paramBuffer.addValueParam("sourceLevel", ParamType::TGLint, sourceLevel);
2770 paramBuffer.addValueParam("destTargetPacked", ParamType::TTextureTarget, destTargetPacked);
2771 paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked);
2772 paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel);
2773 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
2774 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
2775 paramBuffer.addValueParam("x", ParamType::TGLint, x);
2776 paramBuffer.addValueParam("y", ParamType::TGLint, y);
2777 paramBuffer.addValueParam("width", ParamType::TGLint, width);
2778 paramBuffer.addValueParam("height", ParamType::TGLint, height);
2779 paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY);
2780 paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean,
2781 unpackPremultiplyAlpha);
2782 paramBuffer.addValueParam("unpackUnmultiplyAlpha", ParamType::TGLboolean,
2783 unpackUnmultiplyAlpha);
2784
2785 return CallCapture(gl::EntryPoint::CopySubTextureCHROMIUM, std::move(paramBuffer));
2786 }
2787
CaptureCoverageModulationCHROMIUM(const State & glState,bool isCallValid,GLenum components)2788 CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
2789 bool isCallValid,
2790 GLenum components)
2791 {
2792 ParamBuffer paramBuffer;
2793
2794 paramBuffer.addEnumParam("components", GLenumGroup::DefaultGroup, ParamType::TGLenum,
2795 components);
2796
2797 return CallCapture(gl::EntryPoint::CoverageModulationCHROMIUM, std::move(paramBuffer));
2798 }
2799
CaptureLoseContextCHROMIUM(const State & glState,bool isCallValid,GraphicsResetStatus currentPacked,GraphicsResetStatus otherPacked)2800 CallCapture CaptureLoseContextCHROMIUM(const State &glState,
2801 bool isCallValid,
2802 GraphicsResetStatus currentPacked,
2803 GraphicsResetStatus otherPacked)
2804 {
2805 ParamBuffer paramBuffer;
2806
2807 paramBuffer.addValueParam("currentPacked", ParamType::TGraphicsResetStatus, currentPacked);
2808 paramBuffer.addValueParam("otherPacked", ParamType::TGraphicsResetStatus, otherPacked);
2809
2810 return CallCapture(gl::EntryPoint::LoseContextCHROMIUM, std::move(paramBuffer));
2811 }
2812
CaptureBindFragDataLocationEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint color,const GLchar * name)2813 CallCapture CaptureBindFragDataLocationEXT(const State &glState,
2814 bool isCallValid,
2815 ShaderProgramID programPacked,
2816 GLuint color,
2817 const GLchar *name)
2818 {
2819 ParamBuffer paramBuffer;
2820
2821 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2822 paramBuffer.addValueParam("color", ParamType::TGLuint, color);
2823
2824 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
2825 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
2826 CaptureBindFragDataLocationEXT_name(glState, isCallValid, programPacked, color, name,
2827 &nameParam);
2828 paramBuffer.addParam(std::move(nameParam));
2829
2830 return CallCapture(gl::EntryPoint::BindFragDataLocationEXT, std::move(paramBuffer));
2831 }
2832
CaptureBindFragDataLocationIndexedEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLuint colorNumber,GLuint index,const GLchar * name)2833 CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
2834 bool isCallValid,
2835 ShaderProgramID programPacked,
2836 GLuint colorNumber,
2837 GLuint index,
2838 const GLchar *name)
2839 {
2840 ParamBuffer paramBuffer;
2841
2842 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2843 paramBuffer.addValueParam("colorNumber", ParamType::TGLuint, colorNumber);
2844 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2845
2846 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
2847 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
2848 CaptureBindFragDataLocationIndexedEXT_name(glState, isCallValid, programPacked, colorNumber,
2849 index, name, &nameParam);
2850 paramBuffer.addParam(std::move(nameParam));
2851
2852 return CallCapture(gl::EntryPoint::BindFragDataLocationIndexedEXT, std::move(paramBuffer));
2853 }
2854
CaptureGetFragDataIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,const GLchar * name,GLint returnValue)2855 CallCapture CaptureGetFragDataIndexEXT(const State &glState,
2856 bool isCallValid,
2857 ShaderProgramID programPacked,
2858 const GLchar *name,
2859 GLint returnValue)
2860 {
2861 ParamBuffer paramBuffer;
2862
2863 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2864
2865 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
2866 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
2867 CaptureGetFragDataIndexEXT_name(glState, isCallValid, programPacked, name, &nameParam);
2868 paramBuffer.addParam(std::move(nameParam));
2869
2870 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
2871 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
2872 paramBuffer.addReturnValue(std::move(returnValueCapture));
2873
2874 return CallCapture(gl::EntryPoint::GetFragDataIndexEXT, std::move(paramBuffer));
2875 }
2876
CaptureGetProgramResourceLocationIndexEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum programInterface,const GLchar * name,GLint returnValue)2877 CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
2878 bool isCallValid,
2879 ShaderProgramID programPacked,
2880 GLenum programInterface,
2881 const GLchar *name,
2882 GLint returnValue)
2883 {
2884 ParamBuffer paramBuffer;
2885
2886 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
2887 paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
2888 programInterface);
2889
2890 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
2891 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
2892 CaptureGetProgramResourceLocationIndexEXT_name(glState, isCallValid, programPacked,
2893 programInterface, name, &nameParam);
2894 paramBuffer.addParam(std::move(nameParam));
2895
2896 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
2897 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
2898 paramBuffer.addReturnValue(std::move(returnValueCapture));
2899
2900 return CallCapture(gl::EntryPoint::GetProgramResourceLocationIndexEXT, std::move(paramBuffer));
2901 }
2902
CaptureInsertEventMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)2903 CallCapture CaptureInsertEventMarkerEXT(const State &glState,
2904 bool isCallValid,
2905 GLsizei length,
2906 const GLchar *marker)
2907 {
2908 ParamBuffer paramBuffer;
2909
2910 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
2911
2912 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
2913 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
2914 CaptureInsertEventMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
2915 paramBuffer.addParam(std::move(markerParam));
2916
2917 return CallCapture(gl::EntryPoint::InsertEventMarkerEXT, std::move(paramBuffer));
2918 }
2919
CapturePopGroupMarkerEXT(const State & glState,bool isCallValid)2920 CallCapture CapturePopGroupMarkerEXT(const State &glState, bool isCallValid)
2921 {
2922 ParamBuffer paramBuffer;
2923
2924 return CallCapture(gl::EntryPoint::PopGroupMarkerEXT, std::move(paramBuffer));
2925 }
2926
CapturePushGroupMarkerEXT(const State & glState,bool isCallValid,GLsizei length,const GLchar * marker)2927 CallCapture CapturePushGroupMarkerEXT(const State &glState,
2928 bool isCallValid,
2929 GLsizei length,
2930 const GLchar *marker)
2931 {
2932 ParamBuffer paramBuffer;
2933
2934 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
2935
2936 ParamCapture markerParam("marker", ParamType::TGLcharConstPointer);
2937 InitParamValue(ParamType::TGLcharConstPointer, marker, &markerParam.value);
2938 CapturePushGroupMarkerEXT_marker(glState, isCallValid, length, marker, &markerParam);
2939 paramBuffer.addParam(std::move(markerParam));
2940
2941 return CallCapture(gl::EntryPoint::PushGroupMarkerEXT, std::move(paramBuffer));
2942 }
2943
CaptureDiscardFramebufferEXT(const State & glState,bool isCallValid,GLenum target,GLsizei numAttachments,const GLenum * attachments)2944 CallCapture CaptureDiscardFramebufferEXT(const State &glState,
2945 bool isCallValid,
2946 GLenum target,
2947 GLsizei numAttachments,
2948 const GLenum *attachments)
2949 {
2950 ParamBuffer paramBuffer;
2951
2952 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
2953 paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
2954
2955 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
2956 InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
2957 CaptureDiscardFramebufferEXT_attachments(glState, isCallValid, target, numAttachments,
2958 attachments, &attachmentsParam);
2959 paramBuffer.addParam(std::move(attachmentsParam));
2960
2961 return CallCapture(gl::EntryPoint::DiscardFramebufferEXT, std::move(paramBuffer));
2962 }
2963
CaptureBeginQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked,QueryID idPacked)2964 CallCapture CaptureBeginQueryEXT(const State &glState,
2965 bool isCallValid,
2966 QueryType targetPacked,
2967 QueryID idPacked)
2968 {
2969 ParamBuffer paramBuffer;
2970
2971 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
2972 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
2973
2974 return CallCapture(gl::EntryPoint::BeginQueryEXT, std::move(paramBuffer));
2975 }
2976
CaptureDeleteQueriesEXT(const State & glState,bool isCallValid,GLsizei n,const QueryID * idsPacked)2977 CallCapture CaptureDeleteQueriesEXT(const State &glState,
2978 bool isCallValid,
2979 GLsizei n,
2980 const QueryID *idsPacked)
2981 {
2982 ParamBuffer paramBuffer;
2983
2984 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
2985
2986 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
2987 InitParamValue(ParamType::TQueryIDConstPointer, idsPacked, &idsPackedParam.value);
2988 CaptureDeleteQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
2989 paramBuffer.addParam(std::move(idsPackedParam));
2990
2991 return CallCapture(gl::EntryPoint::DeleteQueriesEXT, std::move(paramBuffer));
2992 }
2993
CaptureEndQueryEXT(const State & glState,bool isCallValid,QueryType targetPacked)2994 CallCapture CaptureEndQueryEXT(const State &glState, bool isCallValid, QueryType targetPacked)
2995 {
2996 ParamBuffer paramBuffer;
2997
2998 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
2999
3000 return CallCapture(gl::EntryPoint::EndQueryEXT, std::move(paramBuffer));
3001 }
3002
CaptureGenQueriesEXT(const State & glState,bool isCallValid,GLsizei n,QueryID * idsPacked)3003 CallCapture CaptureGenQueriesEXT(const State &glState,
3004 bool isCallValid,
3005 GLsizei n,
3006 QueryID *idsPacked)
3007 {
3008 ParamBuffer paramBuffer;
3009
3010 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
3011
3012 ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
3013 InitParamValue(ParamType::TQueryIDPointer, idsPacked, &idsPackedParam.value);
3014 CaptureGenQueriesEXT_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
3015 paramBuffer.addParam(std::move(idsPackedParam));
3016
3017 return CallCapture(gl::EntryPoint::GenQueriesEXT, std::move(paramBuffer));
3018 }
3019
CaptureGetInteger64vEXT(const State & glState,bool isCallValid,GLenum pname,GLint64 * data)3020 CallCapture CaptureGetInteger64vEXT(const State &glState,
3021 bool isCallValid,
3022 GLenum pname,
3023 GLint64 *data)
3024 {
3025 ParamBuffer paramBuffer;
3026
3027 paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
3028
3029 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
3030 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
3031 CaptureGetInteger64vEXT_data(glState, isCallValid, pname, data, &dataParam);
3032 paramBuffer.addParam(std::move(dataParam));
3033
3034 return CallCapture(gl::EntryPoint::GetInteger64vEXT, std::move(paramBuffer));
3035 }
3036
CaptureGetQueryObjecti64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint64 * params)3037 CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
3038 bool isCallValid,
3039 QueryID idPacked,
3040 GLenum pname,
3041 GLint64 *params)
3042 {
3043 ParamBuffer paramBuffer;
3044
3045 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3046 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
3047 pname);
3048
3049 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
3050 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
3051 CaptureGetQueryObjecti64vEXT_params(glState, isCallValid, idPacked, pname, params,
3052 ¶msParam);
3053 paramBuffer.addParam(std::move(paramsParam));
3054
3055 return CallCapture(gl::EntryPoint::GetQueryObjecti64vEXT, std::move(paramBuffer));
3056 }
3057
CaptureGetQueryObjectivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint * params)3058 CallCapture CaptureGetQueryObjectivEXT(const State &glState,
3059 bool isCallValid,
3060 QueryID idPacked,
3061 GLenum pname,
3062 GLint *params)
3063 {
3064 ParamBuffer paramBuffer;
3065
3066 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3067 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
3068 pname);
3069
3070 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3071 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3072 CaptureGetQueryObjectivEXT_params(glState, isCallValid, idPacked, pname, params, ¶msParam);
3073 paramBuffer.addParam(std::move(paramsParam));
3074
3075 return CallCapture(gl::EntryPoint::GetQueryObjectivEXT, std::move(paramBuffer));
3076 }
3077
CaptureGetQueryObjectui64vEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint64 * params)3078 CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
3079 bool isCallValid,
3080 QueryID idPacked,
3081 GLenum pname,
3082 GLuint64 *params)
3083 {
3084 ParamBuffer paramBuffer;
3085
3086 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3087 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
3088 pname);
3089
3090 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
3091 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
3092 CaptureGetQueryObjectui64vEXT_params(glState, isCallValid, idPacked, pname, params,
3093 ¶msParam);
3094 paramBuffer.addParam(std::move(paramsParam));
3095
3096 return CallCapture(gl::EntryPoint::GetQueryObjectui64vEXT, std::move(paramBuffer));
3097 }
3098
CaptureGetQueryObjectuivEXT(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLuint * params)3099 CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
3100 bool isCallValid,
3101 QueryID idPacked,
3102 GLenum pname,
3103 GLuint *params)
3104 {
3105 ParamBuffer paramBuffer;
3106
3107 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3108 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
3109 pname);
3110
3111 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
3112 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
3113 CaptureGetQueryObjectuivEXT_params(glState, isCallValid, idPacked, pname, params, ¶msParam);
3114 paramBuffer.addParam(std::move(paramsParam));
3115
3116 return CallCapture(gl::EntryPoint::GetQueryObjectuivEXT, std::move(paramBuffer));
3117 }
3118
CaptureGetQueryivEXT(const State & glState,bool isCallValid,QueryType targetPacked,GLenum pname,GLint * params)3119 CallCapture CaptureGetQueryivEXT(const State &glState,
3120 bool isCallValid,
3121 QueryType targetPacked,
3122 GLenum pname,
3123 GLint *params)
3124 {
3125 ParamBuffer paramBuffer;
3126
3127 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
3128 paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname);
3129
3130 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3131 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3132 CaptureGetQueryivEXT_params(glState, isCallValid, targetPacked, pname, params, ¶msParam);
3133 paramBuffer.addParam(std::move(paramsParam));
3134
3135 return CallCapture(gl::EntryPoint::GetQueryivEXT, std::move(paramBuffer));
3136 }
3137
CaptureIsQueryEXT(const State & glState,bool isCallValid,QueryID idPacked,GLboolean returnValue)3138 CallCapture CaptureIsQueryEXT(const State &glState,
3139 bool isCallValid,
3140 QueryID idPacked,
3141 GLboolean returnValue)
3142 {
3143 ParamBuffer paramBuffer;
3144
3145 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3146
3147 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
3148 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
3149 paramBuffer.addReturnValue(std::move(returnValueCapture));
3150
3151 return CallCapture(gl::EntryPoint::IsQueryEXT, std::move(paramBuffer));
3152 }
3153
CaptureQueryCounterEXT(const State & glState,bool isCallValid,QueryID idPacked,QueryType targetPacked)3154 CallCapture CaptureQueryCounterEXT(const State &glState,
3155 bool isCallValid,
3156 QueryID idPacked,
3157 QueryType targetPacked)
3158 {
3159 ParamBuffer paramBuffer;
3160
3161 paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
3162 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
3163
3164 return CallCapture(gl::EntryPoint::QueryCounterEXT, std::move(paramBuffer));
3165 }
3166
CaptureDrawBuffersEXT(const State & glState,bool isCallValid,GLsizei n,const GLenum * bufs)3167 CallCapture CaptureDrawBuffersEXT(const State &glState,
3168 bool isCallValid,
3169 GLsizei n,
3170 const GLenum *bufs)
3171 {
3172 ParamBuffer paramBuffer;
3173
3174 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
3175
3176 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
3177 InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
3178 CaptureDrawBuffersEXT_bufs(glState, isCallValid, n, bufs, &bufsParam);
3179 paramBuffer.addParam(std::move(bufsParam));
3180
3181 return CallCapture(gl::EntryPoint::DrawBuffersEXT, std::move(paramBuffer));
3182 }
3183
CaptureBlendEquationSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)3184 CallCapture CaptureBlendEquationSeparateiEXT(const State &glState,
3185 bool isCallValid,
3186 GLuint buf,
3187 GLenum modeRGB,
3188 GLenum modeAlpha)
3189 {
3190 ParamBuffer paramBuffer;
3191
3192 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
3193 paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
3194 modeRGB);
3195 paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
3196 modeAlpha);
3197
3198 return CallCapture(gl::EntryPoint::BlendEquationSeparateiEXT, std::move(paramBuffer));
3199 }
3200
CaptureBlendEquationiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum mode)3201 CallCapture CaptureBlendEquationiEXT(const State &glState,
3202 bool isCallValid,
3203 GLuint buf,
3204 GLenum mode)
3205 {
3206 ParamBuffer paramBuffer;
3207
3208 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
3209 paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode);
3210
3211 return CallCapture(gl::EntryPoint::BlendEquationiEXT, std::move(paramBuffer));
3212 }
3213
CaptureBlendFuncSeparateiEXT(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)3214 CallCapture CaptureBlendFuncSeparateiEXT(const State &glState,
3215 bool isCallValid,
3216 GLuint buf,
3217 GLenum srcRGB,
3218 GLenum dstRGB,
3219 GLenum srcAlpha,
3220 GLenum dstAlpha)
3221 {
3222 ParamBuffer paramBuffer;
3223
3224 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
3225 paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB);
3226 paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB);
3227 paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha);
3228 paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha);
3229
3230 return CallCapture(gl::EntryPoint::BlendFuncSeparateiEXT, std::move(paramBuffer));
3231 }
3232
CaptureBlendFunciEXT(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)3233 CallCapture CaptureBlendFunciEXT(const State &glState,
3234 bool isCallValid,
3235 GLuint buf,
3236 GLenum src,
3237 GLenum dst)
3238 {
3239 ParamBuffer paramBuffer;
3240
3241 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
3242 paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src);
3243 paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst);
3244
3245 return CallCapture(gl::EntryPoint::BlendFunciEXT, std::move(paramBuffer));
3246 }
3247
CaptureColorMaskiEXT(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)3248 CallCapture CaptureColorMaskiEXT(const State &glState,
3249 bool isCallValid,
3250 GLuint index,
3251 GLboolean r,
3252 GLboolean g,
3253 GLboolean b,
3254 GLboolean a)
3255 {
3256 ParamBuffer paramBuffer;
3257
3258 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3259 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
3260 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
3261 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
3262 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
3263
3264 return CallCapture(gl::EntryPoint::ColorMaskiEXT, std::move(paramBuffer));
3265 }
3266
CaptureDisableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)3267 CallCapture CaptureDisableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
3268 {
3269 ParamBuffer paramBuffer;
3270
3271 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
3272 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3273
3274 return CallCapture(gl::EntryPoint::DisableiEXT, std::move(paramBuffer));
3275 }
3276
CaptureEnableiEXT(const State & glState,bool isCallValid,GLenum target,GLuint index)3277 CallCapture CaptureEnableiEXT(const State &glState, bool isCallValid, GLenum target, GLuint index)
3278 {
3279 ParamBuffer paramBuffer;
3280
3281 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
3282 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3283
3284 return CallCapture(gl::EntryPoint::EnableiEXT, std::move(paramBuffer));
3285 }
3286
CaptureIsEnablediEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)3287 CallCapture CaptureIsEnablediEXT(const State &glState,
3288 bool isCallValid,
3289 GLenum target,
3290 GLuint index,
3291 GLboolean returnValue)
3292 {
3293 ParamBuffer paramBuffer;
3294
3295 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
3296 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3297
3298 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
3299 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
3300 paramBuffer.addReturnValue(std::move(returnValueCapture));
3301
3302 return CallCapture(gl::EntryPoint::IsEnablediEXT, std::move(paramBuffer));
3303 }
3304
CaptureDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)3305 CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
3306 bool isCallValid,
3307 PrimitiveMode modePacked,
3308 GLsizei count,
3309 DrawElementsType typePacked,
3310 const void *indices,
3311 GLint basevertex)
3312 {
3313 ParamBuffer paramBuffer;
3314
3315 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
3316 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
3317 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
3318
3319 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
3320 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
3321 CaptureDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count, typePacked,
3322 indices, basevertex, &indicesParam);
3323 paramBuffer.addParam(std::move(indicesParam));
3324
3325 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
3326
3327 return CallCapture(gl::EntryPoint::DrawElementsBaseVertexEXT, std::move(paramBuffer));
3328 }
3329
CaptureDrawElementsInstancedBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)3330 CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
3331 bool isCallValid,
3332 PrimitiveMode modePacked,
3333 GLsizei count,
3334 DrawElementsType typePacked,
3335 const void *indices,
3336 GLsizei instancecount,
3337 GLint basevertex)
3338 {
3339 ParamBuffer paramBuffer;
3340
3341 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
3342 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
3343 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
3344
3345 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
3346 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
3347 CaptureDrawElementsInstancedBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
3348 typePacked, indices, instancecount,
3349 basevertex, &indicesParam);
3350 paramBuffer.addParam(std::move(indicesParam));
3351
3352 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
3353 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
3354
3355 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertexEXT, std::move(paramBuffer));
3356 }
3357
CaptureDrawRangeElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)3358 CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
3359 bool isCallValid,
3360 PrimitiveMode modePacked,
3361 GLuint start,
3362 GLuint end,
3363 GLsizei count,
3364 DrawElementsType typePacked,
3365 const void *indices,
3366 GLint basevertex)
3367 {
3368 ParamBuffer paramBuffer;
3369
3370 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
3371 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
3372 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
3373 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
3374 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
3375
3376 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
3377 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
3378 CaptureDrawRangeElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, start, end,
3379 count, typePacked, indices, basevertex,
3380 &indicesParam);
3381 paramBuffer.addParam(std::move(indicesParam));
3382
3383 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
3384
3385 return CallCapture(gl::EntryPoint::DrawRangeElementsBaseVertexEXT, std::move(paramBuffer));
3386 }
3387
CaptureMultiDrawElementsBaseVertexEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei primcount,const GLint * basevertex)3388 CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
3389 bool isCallValid,
3390 PrimitiveMode modePacked,
3391 const GLsizei *count,
3392 DrawElementsType typePacked,
3393 const void *const *indices,
3394 GLsizei primcount,
3395 const GLint *basevertex)
3396 {
3397 ParamBuffer paramBuffer;
3398
3399 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
3400
3401 ParamCapture countParam("count", ParamType::TGLsizeiConstPointer);
3402 InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value);
3403 CaptureMultiDrawElementsBaseVertexEXT_count(glState, isCallValid, modePacked, count, typePacked,
3404 indices, primcount, basevertex, &countParam);
3405 paramBuffer.addParam(std::move(countParam));
3406
3407 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
3408
3409 ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer);
3410 InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value);
3411 CaptureMultiDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count,
3412 typePacked, indices, primcount, basevertex,
3413 &indicesParam);
3414 paramBuffer.addParam(std::move(indicesParam));
3415
3416 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
3417
3418 ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer);
3419 InitParamValue(ParamType::TGLintConstPointer, basevertex, &basevertexParam.value);
3420 CaptureMultiDrawElementsBaseVertexEXT_basevertex(glState, isCallValid, modePacked, count,
3421 typePacked, indices, primcount, basevertex,
3422 &basevertexParam);
3423 paramBuffer.addParam(std::move(basevertexParam));
3424
3425 return CallCapture(gl::EntryPoint::MultiDrawElementsBaseVertexEXT, std::move(paramBuffer));
3426 }
3427
CaptureFramebufferTextureEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)3428 CallCapture CaptureFramebufferTextureEXT(const State &glState,
3429 bool isCallValid,
3430 GLenum target,
3431 GLenum attachment,
3432 TextureID texturePacked,
3433 GLint level)
3434 {
3435 ParamBuffer paramBuffer;
3436
3437 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
3438 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
3439 attachment);
3440 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
3441 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3442
3443 return CallCapture(gl::EntryPoint::FramebufferTextureEXT, std::move(paramBuffer));
3444 }
3445
CaptureDrawArraysInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLint start,GLsizei count,GLsizei primcount)3446 CallCapture CaptureDrawArraysInstancedEXT(const State &glState,
3447 bool isCallValid,
3448 PrimitiveMode modePacked,
3449 GLint start,
3450 GLsizei count,
3451 GLsizei primcount)
3452 {
3453 ParamBuffer paramBuffer;
3454
3455 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
3456 paramBuffer.addValueParam("start", ParamType::TGLint, start);
3457 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
3458 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
3459
3460 return CallCapture(gl::EntryPoint::DrawArraysInstancedEXT, std::move(paramBuffer));
3461 }
3462
CaptureDrawElementsInstancedEXT(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei primcount)3463 CallCapture CaptureDrawElementsInstancedEXT(const State &glState,
3464 bool isCallValid,
3465 PrimitiveMode modePacked,
3466 GLsizei count,
3467 DrawElementsType typePacked,
3468 const void *indices,
3469 GLsizei primcount)
3470 {
3471 ParamBuffer paramBuffer;
3472
3473 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
3474 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
3475 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
3476
3477 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
3478 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
3479 CaptureDrawElementsInstancedEXT_indices(glState, isCallValid, modePacked, count, typePacked,
3480 indices, primcount, &indicesParam);
3481 paramBuffer.addParam(std::move(indicesParam));
3482
3483 paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount);
3484
3485 return CallCapture(gl::EntryPoint::DrawElementsInstancedEXT, std::move(paramBuffer));
3486 }
3487
CaptureVertexAttribDivisorEXT(const State & glState,bool isCallValid,GLuint index,GLuint divisor)3488 CallCapture CaptureVertexAttribDivisorEXT(const State &glState,
3489 bool isCallValid,
3490 GLuint index,
3491 GLuint divisor)
3492 {
3493 ParamBuffer paramBuffer;
3494
3495 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3496 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
3497
3498 return CallCapture(gl::EntryPoint::VertexAttribDivisorEXT, std::move(paramBuffer));
3499 }
3500
CaptureFlushMappedBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length)3501 CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState,
3502 bool isCallValid,
3503 BufferBinding targetPacked,
3504 GLintptr offset,
3505 GLsizeiptr length)
3506 {
3507 ParamBuffer paramBuffer;
3508
3509 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
3510 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
3511 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
3512
3513 return CallCapture(gl::EntryPoint::FlushMappedBufferRangeEXT, std::move(paramBuffer));
3514 }
3515
CaptureMapBufferRangeEXT(const State & glState,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length,GLbitfield access,void * returnValue)3516 CallCapture CaptureMapBufferRangeEXT(const State &glState,
3517 bool isCallValid,
3518 BufferBinding targetPacked,
3519 GLintptr offset,
3520 GLsizeiptr length,
3521 GLbitfield access,
3522 void *returnValue)
3523 {
3524 ParamBuffer paramBuffer;
3525
3526 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
3527 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
3528 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
3529 paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield,
3530 access);
3531
3532 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
3533 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
3534 paramBuffer.addReturnValue(std::move(returnValueCapture));
3535
3536 return CallCapture(gl::EntryPoint::MapBufferRangeEXT, std::move(paramBuffer));
3537 }
3538
CaptureBufferStorageMemEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizeiptr size,MemoryObjectID memoryPacked,GLuint64 offset)3539 CallCapture CaptureBufferStorageMemEXT(const State &glState,
3540 bool isCallValid,
3541 TextureType targetPacked,
3542 GLsizeiptr size,
3543 MemoryObjectID memoryPacked,
3544 GLuint64 offset)
3545 {
3546 ParamBuffer paramBuffer;
3547
3548 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3549 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
3550 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
3551 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
3552
3553 return CallCapture(gl::EntryPoint::BufferStorageMemEXT, std::move(paramBuffer));
3554 }
3555
CaptureCreateMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,MemoryObjectID * memoryObjectsPacked)3556 CallCapture CaptureCreateMemoryObjectsEXT(const State &glState,
3557 bool isCallValid,
3558 GLsizei n,
3559 MemoryObjectID *memoryObjectsPacked)
3560 {
3561 ParamBuffer paramBuffer;
3562
3563 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
3564
3565 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked", ParamType::TMemoryObjectIDPointer);
3566 InitParamValue(ParamType::TMemoryObjectIDPointer, memoryObjectsPacked,
3567 &memoryObjectsPackedParam.value);
3568 CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(glState, isCallValid, n, memoryObjectsPacked,
3569 &memoryObjectsPackedParam);
3570 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
3571
3572 return CallCapture(gl::EntryPoint::CreateMemoryObjectsEXT, std::move(paramBuffer));
3573 }
3574
CaptureDeleteMemoryObjectsEXT(const State & glState,bool isCallValid,GLsizei n,const MemoryObjectID * memoryObjectsPacked)3575 CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState,
3576 bool isCallValid,
3577 GLsizei n,
3578 const MemoryObjectID *memoryObjectsPacked)
3579 {
3580 ParamBuffer paramBuffer;
3581
3582 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
3583
3584 ParamCapture memoryObjectsPackedParam("memoryObjectsPacked",
3585 ParamType::TMemoryObjectIDConstPointer);
3586 InitParamValue(ParamType::TMemoryObjectIDConstPointer, memoryObjectsPacked,
3587 &memoryObjectsPackedParam.value);
3588 CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(glState, isCallValid, n, memoryObjectsPacked,
3589 &memoryObjectsPackedParam);
3590 paramBuffer.addParam(std::move(memoryObjectsPackedParam));
3591
3592 return CallCapture(gl::EntryPoint::DeleteMemoryObjectsEXT, std::move(paramBuffer));
3593 }
3594
CaptureGetMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,GLint * params)3595 CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState,
3596 bool isCallValid,
3597 MemoryObjectID memoryObjectPacked,
3598 GLenum pname,
3599 GLint *params)
3600 {
3601 ParamBuffer paramBuffer;
3602
3603 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
3604 paramBuffer.addEnumParam("pname", GLenumGroup::MemoryObjectParameterName, ParamType::TGLenum,
3605 pname);
3606
3607 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3608 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3609 CaptureGetMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
3610 params, ¶msParam);
3611 paramBuffer.addParam(std::move(paramsParam));
3612
3613 return CallCapture(gl::EntryPoint::GetMemoryObjectParameterivEXT, std::move(paramBuffer));
3614 }
3615
CaptureGetUnsignedBytevEXT(const State & glState,bool isCallValid,GLenum pname,GLubyte * data)3616 CallCapture CaptureGetUnsignedBytevEXT(const State &glState,
3617 bool isCallValid,
3618 GLenum pname,
3619 GLubyte *data)
3620 {
3621 ParamBuffer paramBuffer;
3622
3623 paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
3624
3625 ParamCapture dataParam("data", ParamType::TGLubytePointer);
3626 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
3627 CaptureGetUnsignedBytevEXT_data(glState, isCallValid, pname, data, &dataParam);
3628 paramBuffer.addParam(std::move(dataParam));
3629
3630 return CallCapture(gl::EntryPoint::GetUnsignedBytevEXT, std::move(paramBuffer));
3631 }
3632
CaptureGetUnsignedBytei_vEXT(const State & glState,bool isCallValid,GLenum target,GLuint index,GLubyte * data)3633 CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState,
3634 bool isCallValid,
3635 GLenum target,
3636 GLuint index,
3637 GLubyte *data)
3638 {
3639 ParamBuffer paramBuffer;
3640
3641 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
3642 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
3643
3644 ParamCapture dataParam("data", ParamType::TGLubytePointer);
3645 InitParamValue(ParamType::TGLubytePointer, data, &dataParam.value);
3646 CaptureGetUnsignedBytei_vEXT_data(glState, isCallValid, target, index, data, &dataParam);
3647 paramBuffer.addParam(std::move(dataParam));
3648
3649 return CallCapture(gl::EntryPoint::GetUnsignedBytei_vEXT, std::move(paramBuffer));
3650 }
3651
CaptureIsMemoryObjectEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLboolean returnValue)3652 CallCapture CaptureIsMemoryObjectEXT(const State &glState,
3653 bool isCallValid,
3654 MemoryObjectID memoryObjectPacked,
3655 GLboolean returnValue)
3656 {
3657 ParamBuffer paramBuffer;
3658
3659 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
3660
3661 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
3662 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
3663 paramBuffer.addReturnValue(std::move(returnValueCapture));
3664
3665 return CallCapture(gl::EntryPoint::IsMemoryObjectEXT, std::move(paramBuffer));
3666 }
3667
CaptureMemoryObjectParameterivEXT(const State & glState,bool isCallValid,MemoryObjectID memoryObjectPacked,GLenum pname,const GLint * params)3668 CallCapture CaptureMemoryObjectParameterivEXT(const State &glState,
3669 bool isCallValid,
3670 MemoryObjectID memoryObjectPacked,
3671 GLenum pname,
3672 const GLint *params)
3673 {
3674 ParamBuffer paramBuffer;
3675
3676 paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked);
3677 paramBuffer.addEnumParam("pname", GLenumGroup::MemoryObjectParameterName, ParamType::TGLenum,
3678 pname);
3679
3680 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
3681 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
3682 CaptureMemoryObjectParameterivEXT_params(glState, isCallValid, memoryObjectPacked, pname,
3683 params, ¶msParam);
3684 paramBuffer.addParam(std::move(paramsParam));
3685
3686 return CallCapture(gl::EntryPoint::MemoryObjectParameterivEXT, std::move(paramBuffer));
3687 }
3688
CaptureTexStorageMem2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,MemoryObjectID memoryPacked,GLuint64 offset)3689 CallCapture CaptureTexStorageMem2DEXT(const State &glState,
3690 bool isCallValid,
3691 TextureType targetPacked,
3692 GLsizei levels,
3693 GLenum internalFormat,
3694 GLsizei width,
3695 GLsizei height,
3696 MemoryObjectID memoryPacked,
3697 GLuint64 offset)
3698 {
3699 ParamBuffer paramBuffer;
3700
3701 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3702 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
3703 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
3704 internalFormat);
3705 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3706 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3707 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
3708 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
3709
3710 return CallCapture(gl::EntryPoint::TexStorageMem2DEXT, std::move(paramBuffer));
3711 }
3712
CaptureTexStorageMem2DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)3713 CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState,
3714 bool isCallValid,
3715 TextureType targetPacked,
3716 GLsizei samples,
3717 GLenum internalFormat,
3718 GLsizei width,
3719 GLsizei height,
3720 GLboolean fixedSampleLocations,
3721 MemoryObjectID memoryPacked,
3722 GLuint64 offset)
3723 {
3724 ParamBuffer paramBuffer;
3725
3726 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3727 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
3728 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
3729 internalFormat);
3730 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3731 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3732 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
3733 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
3734 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
3735
3736 return CallCapture(gl::EntryPoint::TexStorageMem2DMultisampleEXT, std::move(paramBuffer));
3737 }
3738
CaptureTexStorageMem3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,MemoryObjectID memoryPacked,GLuint64 offset)3739 CallCapture CaptureTexStorageMem3DEXT(const State &glState,
3740 bool isCallValid,
3741 TextureType targetPacked,
3742 GLsizei levels,
3743 GLenum internalFormat,
3744 GLsizei width,
3745 GLsizei height,
3746 GLsizei depth,
3747 MemoryObjectID memoryPacked,
3748 GLuint64 offset)
3749 {
3750 ParamBuffer paramBuffer;
3751
3752 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3753 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
3754 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
3755 internalFormat);
3756 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3757 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3758 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
3759 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
3760 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
3761
3762 return CallCapture(gl::EntryPoint::TexStorageMem3DEXT, std::move(paramBuffer));
3763 }
3764
CaptureTexStorageMem3DMultisampleEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,MemoryObjectID memoryPacked,GLuint64 offset)3765 CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState,
3766 bool isCallValid,
3767 TextureType targetPacked,
3768 GLsizei samples,
3769 GLenum internalFormat,
3770 GLsizei width,
3771 GLsizei height,
3772 GLsizei depth,
3773 GLboolean fixedSampleLocations,
3774 MemoryObjectID memoryPacked,
3775 GLuint64 offset)
3776 {
3777 ParamBuffer paramBuffer;
3778
3779 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
3780 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
3781 paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
3782 internalFormat);
3783 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3784 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3785 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
3786 paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations);
3787 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
3788 paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset);
3789
3790 return CallCapture(gl::EntryPoint::TexStorageMem3DMultisampleEXT, std::move(paramBuffer));
3791 }
3792
CaptureImportMemoryFdEXT(const State & glState,bool isCallValid,MemoryObjectID memoryPacked,GLuint64 size,HandleType handleTypePacked,GLint fd)3793 CallCapture CaptureImportMemoryFdEXT(const State &glState,
3794 bool isCallValid,
3795 MemoryObjectID memoryPacked,
3796 GLuint64 size,
3797 HandleType handleTypePacked,
3798 GLint fd)
3799 {
3800 ParamBuffer paramBuffer;
3801
3802 paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked);
3803 paramBuffer.addValueParam("size", ParamType::TGLuint64, size);
3804 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
3805 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
3806
3807 return CallCapture(gl::EntryPoint::ImportMemoryFdEXT, std::move(paramBuffer));
3808 }
3809
CaptureFramebufferTexture2DMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)3810 CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
3811 bool isCallValid,
3812 GLenum target,
3813 GLenum attachment,
3814 GLenum textarget,
3815 GLuint texture,
3816 GLint level,
3817 GLsizei samples)
3818 {
3819 ParamBuffer paramBuffer;
3820
3821 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
3822 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
3823 attachment);
3824 paramBuffer.addEnumParam("textarget", GLenumGroup::TextureTarget, ParamType::TGLenum,
3825 textarget);
3826 paramBuffer.addValueParam("texture", ParamType::TGLuint, texture);
3827 paramBuffer.addValueParam("level", ParamType::TGLint, level);
3828 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
3829
3830 return CallCapture(gl::EntryPoint::FramebufferTexture2DMultisampleEXT, std::move(paramBuffer));
3831 }
3832
CaptureRenderbufferStorageMultisampleEXT(const State & glState,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)3833 CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
3834 bool isCallValid,
3835 GLenum target,
3836 GLsizei samples,
3837 GLenum internalformat,
3838 GLsizei width,
3839 GLsizei height)
3840 {
3841 ParamBuffer paramBuffer;
3842
3843 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
3844 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
3845 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
3846 internalformat);
3847 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3848 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3849
3850 return CallCapture(gl::EntryPoint::RenderbufferStorageMultisampleEXT, std::move(paramBuffer));
3851 }
3852
CaptureGetGraphicsResetStatusEXT(const State & glState,bool isCallValid,GLenum returnValue)3853 CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
3854 bool isCallValid,
3855 GLenum returnValue)
3856 {
3857 ParamBuffer paramBuffer;
3858
3859 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
3860 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
3861 paramBuffer.addReturnValue(std::move(returnValueCapture));
3862
3863 return CallCapture(gl::EntryPoint::GetGraphicsResetStatusEXT, std::move(paramBuffer));
3864 }
3865
CaptureGetnUniformfvEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)3866 CallCapture CaptureGetnUniformfvEXT(const State &glState,
3867 bool isCallValid,
3868 ShaderProgramID programPacked,
3869 UniformLocation locationPacked,
3870 GLsizei bufSize,
3871 GLfloat *params)
3872 {
3873 ParamBuffer paramBuffer;
3874
3875 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3876 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3877 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3878
3879 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
3880 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
3881 CaptureGetnUniformfvEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
3882 params, ¶msParam);
3883 paramBuffer.addParam(std::move(paramsParam));
3884
3885 return CallCapture(gl::EntryPoint::GetnUniformfvEXT, std::move(paramBuffer));
3886 }
3887
CaptureGetnUniformivEXT(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)3888 CallCapture CaptureGetnUniformivEXT(const State &glState,
3889 bool isCallValid,
3890 ShaderProgramID programPacked,
3891 UniformLocation locationPacked,
3892 GLsizei bufSize,
3893 GLint *params)
3894 {
3895 ParamBuffer paramBuffer;
3896
3897 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
3898 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
3899 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3900
3901 ParamCapture paramsParam("params", ParamType::TGLintPointer);
3902 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
3903 CaptureGetnUniformivEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
3904 params, ¶msParam);
3905 paramBuffer.addParam(std::move(paramsParam));
3906
3907 return CallCapture(gl::EntryPoint::GetnUniformivEXT, std::move(paramBuffer));
3908 }
3909
CaptureReadnPixelsEXT(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)3910 CallCapture CaptureReadnPixelsEXT(const State &glState,
3911 bool isCallValid,
3912 GLint x,
3913 GLint y,
3914 GLsizei width,
3915 GLsizei height,
3916 GLenum format,
3917 GLenum type,
3918 GLsizei bufSize,
3919 void *data)
3920 {
3921 ParamBuffer paramBuffer;
3922
3923 paramBuffer.addValueParam("x", ParamType::TGLint, x);
3924 paramBuffer.addValueParam("y", ParamType::TGLint, y);
3925 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
3926 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
3927 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
3928 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
3929 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
3930
3931 ParamCapture dataParam("data", ParamType::TvoidPointer);
3932 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
3933 CaptureReadnPixelsEXT_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
3934 data, &dataParam);
3935 paramBuffer.addParam(std::move(dataParam));
3936
3937 return CallCapture(gl::EntryPoint::ReadnPixelsEXT, std::move(paramBuffer));
3938 }
3939
CaptureDeleteSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,const SemaphoreID * semaphoresPacked)3940 CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
3941 bool isCallValid,
3942 GLsizei n,
3943 const SemaphoreID *semaphoresPacked)
3944 {
3945 ParamBuffer paramBuffer;
3946
3947 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
3948
3949 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDConstPointer);
3950 InitParamValue(ParamType::TSemaphoreIDConstPointer, semaphoresPacked,
3951 &semaphoresPackedParam.value);
3952 CaptureDeleteSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
3953 &semaphoresPackedParam);
3954 paramBuffer.addParam(std::move(semaphoresPackedParam));
3955
3956 return CallCapture(gl::EntryPoint::DeleteSemaphoresEXT, std::move(paramBuffer));
3957 }
3958
CaptureGenSemaphoresEXT(const State & glState,bool isCallValid,GLsizei n,SemaphoreID * semaphoresPacked)3959 CallCapture CaptureGenSemaphoresEXT(const State &glState,
3960 bool isCallValid,
3961 GLsizei n,
3962 SemaphoreID *semaphoresPacked)
3963 {
3964 ParamBuffer paramBuffer;
3965
3966 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
3967
3968 ParamCapture semaphoresPackedParam("semaphoresPacked", ParamType::TSemaphoreIDPointer);
3969 InitParamValue(ParamType::TSemaphoreIDPointer, semaphoresPacked, &semaphoresPackedParam.value);
3970 CaptureGenSemaphoresEXT_semaphoresPacked(glState, isCallValid, n, semaphoresPacked,
3971 &semaphoresPackedParam);
3972 paramBuffer.addParam(std::move(semaphoresPackedParam));
3973
3974 return CallCapture(gl::EntryPoint::GenSemaphoresEXT, std::move(paramBuffer));
3975 }
3976
CaptureGetSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,GLuint64 * params)3977 CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
3978 bool isCallValid,
3979 SemaphoreID semaphorePacked,
3980 GLenum pname,
3981 GLuint64 *params)
3982 {
3983 ParamBuffer paramBuffer;
3984
3985 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
3986 paramBuffer.addEnumParam("pname", GLenumGroup::SemaphoreParameterName, ParamType::TGLenum,
3987 pname);
3988
3989 ParamCapture paramsParam("params", ParamType::TGLuint64Pointer);
3990 InitParamValue(ParamType::TGLuint64Pointer, params, ¶msParam.value);
3991 CaptureGetSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname,
3992 params, ¶msParam);
3993 paramBuffer.addParam(std::move(paramsParam));
3994
3995 return CallCapture(gl::EntryPoint::GetSemaphoreParameterui64vEXT, std::move(paramBuffer));
3996 }
3997
CaptureIsSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLboolean returnValue)3998 CallCapture CaptureIsSemaphoreEXT(const State &glState,
3999 bool isCallValid,
4000 SemaphoreID semaphorePacked,
4001 GLboolean returnValue)
4002 {
4003 ParamBuffer paramBuffer;
4004
4005 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4006
4007 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
4008 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
4009 paramBuffer.addReturnValue(std::move(returnValueCapture));
4010
4011 return CallCapture(gl::EntryPoint::IsSemaphoreEXT, std::move(paramBuffer));
4012 }
4013
CaptureSemaphoreParameterui64vEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLenum pname,const GLuint64 * params)4014 CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
4015 bool isCallValid,
4016 SemaphoreID semaphorePacked,
4017 GLenum pname,
4018 const GLuint64 *params)
4019 {
4020 ParamBuffer paramBuffer;
4021
4022 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4023 paramBuffer.addEnumParam("pname", GLenumGroup::SemaphoreParameterName, ParamType::TGLenum,
4024 pname);
4025
4026 ParamCapture paramsParam("params", ParamType::TGLuint64ConstPointer);
4027 InitParamValue(ParamType::TGLuint64ConstPointer, params, ¶msParam.value);
4028 CaptureSemaphoreParameterui64vEXT_params(glState, isCallValid, semaphorePacked, pname, params,
4029 ¶msParam);
4030 paramBuffer.addParam(std::move(paramsParam));
4031
4032 return CallCapture(gl::EntryPoint::SemaphoreParameterui64vEXT, std::move(paramBuffer));
4033 }
4034
CaptureSignalSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * dstLayouts)4035 CallCapture CaptureSignalSemaphoreEXT(const State &glState,
4036 bool isCallValid,
4037 SemaphoreID semaphorePacked,
4038 GLuint numBufferBarriers,
4039 const BufferID *buffersPacked,
4040 GLuint numTextureBarriers,
4041 const TextureID *texturesPacked,
4042 const GLenum *dstLayouts)
4043 {
4044 ParamBuffer paramBuffer;
4045
4046 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4047 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
4048
4049 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
4050 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
4051 CaptureSignalSemaphoreEXT_buffersPacked(glState, isCallValid, semaphorePacked,
4052 numBufferBarriers, buffersPacked, numTextureBarriers,
4053 texturesPacked, dstLayouts, &buffersPackedParam);
4054 paramBuffer.addParam(std::move(buffersPackedParam));
4055
4056 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
4057
4058 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
4059 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked, &texturesPackedParam.value);
4060 CaptureSignalSemaphoreEXT_texturesPacked(glState, isCallValid, semaphorePacked,
4061 numBufferBarriers, buffersPacked, numTextureBarriers,
4062 texturesPacked, dstLayouts, &texturesPackedParam);
4063 paramBuffer.addParam(std::move(texturesPackedParam));
4064
4065 ParamCapture dstLayoutsParam("dstLayouts", ParamType::TGLenumConstPointer);
4066 InitParamValue(ParamType::TGLenumConstPointer, dstLayouts, &dstLayoutsParam.value);
4067 CaptureSignalSemaphoreEXT_dstLayouts(glState, isCallValid, semaphorePacked, numBufferBarriers,
4068 buffersPacked, numTextureBarriers, texturesPacked,
4069 dstLayouts, &dstLayoutsParam);
4070 paramBuffer.addParam(std::move(dstLayoutsParam));
4071
4072 return CallCapture(gl::EntryPoint::SignalSemaphoreEXT, std::move(paramBuffer));
4073 }
4074
CaptureWaitSemaphoreEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,GLuint numBufferBarriers,const BufferID * buffersPacked,GLuint numTextureBarriers,const TextureID * texturesPacked,const GLenum * srcLayouts)4075 CallCapture CaptureWaitSemaphoreEXT(const State &glState,
4076 bool isCallValid,
4077 SemaphoreID semaphorePacked,
4078 GLuint numBufferBarriers,
4079 const BufferID *buffersPacked,
4080 GLuint numTextureBarriers,
4081 const TextureID *texturesPacked,
4082 const GLenum *srcLayouts)
4083 {
4084 ParamBuffer paramBuffer;
4085
4086 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4087 paramBuffer.addValueParam("numBufferBarriers", ParamType::TGLuint, numBufferBarriers);
4088
4089 ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
4090 InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
4091 CaptureWaitSemaphoreEXT_buffersPacked(glState, isCallValid, semaphorePacked, numBufferBarriers,
4092 buffersPacked, numTextureBarriers, texturesPacked,
4093 srcLayouts, &buffersPackedParam);
4094 paramBuffer.addParam(std::move(buffersPackedParam));
4095
4096 paramBuffer.addValueParam("numTextureBarriers", ParamType::TGLuint, numTextureBarriers);
4097
4098 ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
4099 InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked, &texturesPackedParam.value);
4100 CaptureWaitSemaphoreEXT_texturesPacked(glState, isCallValid, semaphorePacked, numBufferBarriers,
4101 buffersPacked, numTextureBarriers, texturesPacked,
4102 srcLayouts, &texturesPackedParam);
4103 paramBuffer.addParam(std::move(texturesPackedParam));
4104
4105 ParamCapture srcLayoutsParam("srcLayouts", ParamType::TGLenumConstPointer);
4106 InitParamValue(ParamType::TGLenumConstPointer, srcLayouts, &srcLayoutsParam.value);
4107 CaptureWaitSemaphoreEXT_srcLayouts(glState, isCallValid, semaphorePacked, numBufferBarriers,
4108 buffersPacked, numTextureBarriers, texturesPacked,
4109 srcLayouts, &srcLayoutsParam);
4110 paramBuffer.addParam(std::move(srcLayoutsParam));
4111
4112 return CallCapture(gl::EntryPoint::WaitSemaphoreEXT, std::move(paramBuffer));
4113 }
4114
CaptureImportSemaphoreFdEXT(const State & glState,bool isCallValid,SemaphoreID semaphorePacked,HandleType handleTypePacked,GLint fd)4115 CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
4116 bool isCallValid,
4117 SemaphoreID semaphorePacked,
4118 HandleType handleTypePacked,
4119 GLint fd)
4120 {
4121 ParamBuffer paramBuffer;
4122
4123 paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked);
4124 paramBuffer.addValueParam("handleTypePacked", ParamType::THandleType, handleTypePacked);
4125 paramBuffer.addValueParam("fd", ParamType::TGLint, fd);
4126
4127 return CallCapture(gl::EntryPoint::ImportSemaphoreFdEXT, std::move(paramBuffer));
4128 }
4129
CaptureTexStorage1DEXT(const State & glState,bool isCallValid,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)4130 CallCapture CaptureTexStorage1DEXT(const State &glState,
4131 bool isCallValid,
4132 GLenum target,
4133 GLsizei levels,
4134 GLenum internalformat,
4135 GLsizei width)
4136 {
4137 ParamBuffer paramBuffer;
4138
4139 paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target);
4140 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
4141 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
4142 internalformat);
4143 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
4144
4145 return CallCapture(gl::EntryPoint::TexStorage1DEXT, std::move(paramBuffer));
4146 }
4147
CaptureTexStorage2DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)4148 CallCapture CaptureTexStorage2DEXT(const State &glState,
4149 bool isCallValid,
4150 TextureType targetPacked,
4151 GLsizei levels,
4152 GLenum internalformat,
4153 GLsizei width,
4154 GLsizei height)
4155 {
4156 ParamBuffer paramBuffer;
4157
4158 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4159 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
4160 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
4161 internalformat);
4162 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
4163 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
4164
4165 return CallCapture(gl::EntryPoint::TexStorage2DEXT, std::move(paramBuffer));
4166 }
4167
CaptureTexStorage3DEXT(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)4168 CallCapture CaptureTexStorage3DEXT(const State &glState,
4169 bool isCallValid,
4170 TextureType targetPacked,
4171 GLsizei levels,
4172 GLenum internalformat,
4173 GLsizei width,
4174 GLsizei height,
4175 GLsizei depth)
4176 {
4177 ParamBuffer paramBuffer;
4178
4179 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4180 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
4181 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
4182 internalformat);
4183 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
4184 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
4185 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
4186
4187 return CallCapture(gl::EntryPoint::TexStorage3DEXT, std::move(paramBuffer));
4188 }
4189
CaptureDebugMessageCallbackKHR(const State & glState,bool isCallValid,GLDEBUGPROCKHR callback,const void * userParam)4190 CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
4191 bool isCallValid,
4192 GLDEBUGPROCKHR callback,
4193 const void *userParam)
4194 {
4195 ParamBuffer paramBuffer;
4196
4197 paramBuffer.addValueParam("callback", ParamType::TGLDEBUGPROCKHR, callback);
4198
4199 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
4200 InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
4201 CaptureDebugMessageCallbackKHR_userParam(glState, isCallValid, callback, userParam,
4202 &userParamParam);
4203 paramBuffer.addParam(std::move(userParamParam));
4204
4205 return CallCapture(gl::EntryPoint::DebugMessageCallbackKHR, std::move(paramBuffer));
4206 }
4207
CaptureDebugMessageControlKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)4208 CallCapture CaptureDebugMessageControlKHR(const State &glState,
4209 bool isCallValid,
4210 GLenum source,
4211 GLenum type,
4212 GLenum severity,
4213 GLsizei count,
4214 const GLuint *ids,
4215 GLboolean enabled)
4216 {
4217 ParamBuffer paramBuffer;
4218
4219 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
4220 paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type);
4221 paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
4222 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
4223
4224 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
4225 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
4226 CaptureDebugMessageControlKHR_ids(glState, isCallValid, source, type, severity, count, ids,
4227 enabled, &idsParam);
4228 paramBuffer.addParam(std::move(idsParam));
4229
4230 paramBuffer.addValueParam("enabled", ParamType::TGLboolean, enabled);
4231
4232 return CallCapture(gl::EntryPoint::DebugMessageControlKHR, std::move(paramBuffer));
4233 }
4234
CaptureDebugMessageInsertKHR(const State & glState,bool isCallValid,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)4235 CallCapture CaptureDebugMessageInsertKHR(const State &glState,
4236 bool isCallValid,
4237 GLenum source,
4238 GLenum type,
4239 GLuint id,
4240 GLenum severity,
4241 GLsizei length,
4242 const GLchar *buf)
4243 {
4244 ParamBuffer paramBuffer;
4245
4246 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
4247 paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type);
4248 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
4249 paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
4250 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
4251
4252 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
4253 InitParamValue(ParamType::TGLcharConstPointer, buf, &bufParam.value);
4254 CaptureDebugMessageInsertKHR_buf(glState, isCallValid, source, type, id, severity, length, buf,
4255 &bufParam);
4256 paramBuffer.addParam(std::move(bufParam));
4257
4258 return CallCapture(gl::EntryPoint::DebugMessageInsertKHR, std::move(paramBuffer));
4259 }
4260
CaptureGetDebugMessageLogKHR(const State & glState,bool isCallValid,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog,GLuint returnValue)4261 CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
4262 bool isCallValid,
4263 GLuint count,
4264 GLsizei bufSize,
4265 GLenum *sources,
4266 GLenum *types,
4267 GLuint *ids,
4268 GLenum *severities,
4269 GLsizei *lengths,
4270 GLchar *messageLog,
4271 GLuint returnValue)
4272 {
4273 ParamBuffer paramBuffer;
4274
4275 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
4276 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4277
4278 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
4279 InitParamValue(ParamType::TGLenumPointer, sources, &sourcesParam.value);
4280 CaptureGetDebugMessageLogKHR_sources(glState, isCallValid, count, bufSize, sources, types, ids,
4281 severities, lengths, messageLog, &sourcesParam);
4282 paramBuffer.addParam(std::move(sourcesParam));
4283
4284 ParamCapture typesParam("types", ParamType::TGLenumPointer);
4285 InitParamValue(ParamType::TGLenumPointer, types, &typesParam.value);
4286 CaptureGetDebugMessageLogKHR_types(glState, isCallValid, count, bufSize, sources, types, ids,
4287 severities, lengths, messageLog, &typesParam);
4288 paramBuffer.addParam(std::move(typesParam));
4289
4290 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
4291 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
4292 CaptureGetDebugMessageLogKHR_ids(glState, isCallValid, count, bufSize, sources, types, ids,
4293 severities, lengths, messageLog, &idsParam);
4294 paramBuffer.addParam(std::move(idsParam));
4295
4296 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
4297 InitParamValue(ParamType::TGLenumPointer, severities, &severitiesParam.value);
4298 CaptureGetDebugMessageLogKHR_severities(glState, isCallValid, count, bufSize, sources, types,
4299 ids, severities, lengths, messageLog, &severitiesParam);
4300 paramBuffer.addParam(std::move(severitiesParam));
4301
4302 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
4303 InitParamValue(ParamType::TGLsizeiPointer, lengths, &lengthsParam.value);
4304 CaptureGetDebugMessageLogKHR_lengths(glState, isCallValid, count, bufSize, sources, types, ids,
4305 severities, lengths, messageLog, &lengthsParam);
4306 paramBuffer.addParam(std::move(lengthsParam));
4307
4308 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
4309 InitParamValue(ParamType::TGLcharPointer, messageLog, &messageLogParam.value);
4310 CaptureGetDebugMessageLogKHR_messageLog(glState, isCallValid, count, bufSize, sources, types,
4311 ids, severities, lengths, messageLog, &messageLogParam);
4312 paramBuffer.addParam(std::move(messageLogParam));
4313
4314 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
4315 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
4316 paramBuffer.addReturnValue(std::move(returnValueCapture));
4317
4318 return CallCapture(gl::EntryPoint::GetDebugMessageLogKHR, std::move(paramBuffer));
4319 }
4320
CaptureGetObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)4321 CallCapture CaptureGetObjectLabelKHR(const State &glState,
4322 bool isCallValid,
4323 GLenum identifier,
4324 GLuint name,
4325 GLsizei bufSize,
4326 GLsizei *length,
4327 GLchar *label)
4328 {
4329 ParamBuffer paramBuffer;
4330
4331 paramBuffer.addEnumParam("identifier", GLenumGroup::DefaultGroup, ParamType::TGLenum,
4332 identifier);
4333 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
4334 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4335
4336 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4337 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4338 CaptureGetObjectLabelKHR_length(glState, isCallValid, identifier, name, bufSize, length, label,
4339 &lengthParam);
4340 paramBuffer.addParam(std::move(lengthParam));
4341
4342 ParamCapture labelParam("label", ParamType::TGLcharPointer);
4343 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
4344 CaptureGetObjectLabelKHR_label(glState, isCallValid, identifier, name, bufSize, length, label,
4345 &labelParam);
4346 paramBuffer.addParam(std::move(labelParam));
4347
4348 return CallCapture(gl::EntryPoint::GetObjectLabelKHR, std::move(paramBuffer));
4349 }
4350
CaptureGetObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)4351 CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
4352 bool isCallValid,
4353 const void *ptr,
4354 GLsizei bufSize,
4355 GLsizei *length,
4356 GLchar *label)
4357 {
4358 ParamBuffer paramBuffer;
4359
4360 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
4361 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
4362 CaptureGetObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, bufSize, length, label, &ptrParam);
4363 paramBuffer.addParam(std::move(ptrParam));
4364
4365 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
4366
4367 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
4368 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
4369 CaptureGetObjectPtrLabelKHR_length(glState, isCallValid, ptr, bufSize, length, label,
4370 &lengthParam);
4371 paramBuffer.addParam(std::move(lengthParam));
4372
4373 ParamCapture labelParam("label", ParamType::TGLcharPointer);
4374 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
4375 CaptureGetObjectPtrLabelKHR_label(glState, isCallValid, ptr, bufSize, length, label,
4376 &labelParam);
4377 paramBuffer.addParam(std::move(labelParam));
4378
4379 return CallCapture(gl::EntryPoint::GetObjectPtrLabelKHR, std::move(paramBuffer));
4380 }
4381
CaptureGetPointervKHR(const State & glState,bool isCallValid,GLenum pname,void ** params)4382 CallCapture CaptureGetPointervKHR(const State &glState,
4383 bool isCallValid,
4384 GLenum pname,
4385 void **params)
4386 {
4387 ParamBuffer paramBuffer;
4388
4389 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
4390
4391 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
4392 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
4393 CaptureGetPointervKHR_params(glState, isCallValid, pname, params, ¶msParam);
4394 paramBuffer.addParam(std::move(paramsParam));
4395
4396 return CallCapture(gl::EntryPoint::GetPointervKHR, std::move(paramBuffer));
4397 }
4398
CaptureObjectLabelKHR(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)4399 CallCapture CaptureObjectLabelKHR(const State &glState,
4400 bool isCallValid,
4401 GLenum identifier,
4402 GLuint name,
4403 GLsizei length,
4404 const GLchar *label)
4405 {
4406 ParamBuffer paramBuffer;
4407
4408 paramBuffer.addEnumParam("identifier", GLenumGroup::ObjectIdentifier, ParamType::TGLenum,
4409 identifier);
4410 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
4411 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
4412
4413 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
4414 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
4415 CaptureObjectLabelKHR_label(glState, isCallValid, identifier, name, length, label, &labelParam);
4416 paramBuffer.addParam(std::move(labelParam));
4417
4418 return CallCapture(gl::EntryPoint::ObjectLabelKHR, std::move(paramBuffer));
4419 }
4420
CaptureObjectPtrLabelKHR(const State & glState,bool isCallValid,const void * ptr,GLsizei length,const GLchar * label)4421 CallCapture CaptureObjectPtrLabelKHR(const State &glState,
4422 bool isCallValid,
4423 const void *ptr,
4424 GLsizei length,
4425 const GLchar *label)
4426 {
4427 ParamBuffer paramBuffer;
4428
4429 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
4430 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
4431 CaptureObjectPtrLabelKHR_ptr(glState, isCallValid, ptr, length, label, &ptrParam);
4432 paramBuffer.addParam(std::move(ptrParam));
4433
4434 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
4435
4436 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
4437 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
4438 CaptureObjectPtrLabelKHR_label(glState, isCallValid, ptr, length, label, &labelParam);
4439 paramBuffer.addParam(std::move(labelParam));
4440
4441 return CallCapture(gl::EntryPoint::ObjectPtrLabelKHR, std::move(paramBuffer));
4442 }
4443
CapturePopDebugGroupKHR(const State & glState,bool isCallValid)4444 CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid)
4445 {
4446 ParamBuffer paramBuffer;
4447
4448 return CallCapture(gl::EntryPoint::PopDebugGroupKHR, std::move(paramBuffer));
4449 }
4450
CapturePushDebugGroupKHR(const State & glState,bool isCallValid,GLenum source,GLuint id,GLsizei length,const GLchar * message)4451 CallCapture CapturePushDebugGroupKHR(const State &glState,
4452 bool isCallValid,
4453 GLenum source,
4454 GLuint id,
4455 GLsizei length,
4456 const GLchar *message)
4457 {
4458 ParamBuffer paramBuffer;
4459
4460 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
4461 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
4462 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
4463
4464 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
4465 InitParamValue(ParamType::TGLcharConstPointer, message, &messageParam.value);
4466 CapturePushDebugGroupKHR_message(glState, isCallValid, source, id, length, message,
4467 &messageParam);
4468 paramBuffer.addParam(std::move(messageParam));
4469
4470 return CallCapture(gl::EntryPoint::PushDebugGroupKHR, std::move(paramBuffer));
4471 }
4472
CaptureMaxShaderCompilerThreadsKHR(const State & glState,bool isCallValid,GLuint count)4473 CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState, bool isCallValid, GLuint count)
4474 {
4475 ParamBuffer paramBuffer;
4476
4477 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
4478
4479 return CallCapture(gl::EntryPoint::MaxShaderCompilerThreadsKHR, std::move(paramBuffer));
4480 }
4481
CaptureDeleteFencesNV(const State & glState,bool isCallValid,GLsizei n,const FenceNVID * fencesPacked)4482 CallCapture CaptureDeleteFencesNV(const State &glState,
4483 bool isCallValid,
4484 GLsizei n,
4485 const FenceNVID *fencesPacked)
4486 {
4487 ParamBuffer paramBuffer;
4488
4489 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4490
4491 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDConstPointer);
4492 InitParamValue(ParamType::TFenceNVIDConstPointer, fencesPacked, &fencesPackedParam.value);
4493 CaptureDeleteFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked, &fencesPackedParam);
4494 paramBuffer.addParam(std::move(fencesPackedParam));
4495
4496 return CallCapture(gl::EntryPoint::DeleteFencesNV, std::move(paramBuffer));
4497 }
4498
CaptureFinishFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked)4499 CallCapture CaptureFinishFenceNV(const State &glState, bool isCallValid, FenceNVID fencePacked)
4500 {
4501 ParamBuffer paramBuffer;
4502
4503 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
4504
4505 return CallCapture(gl::EntryPoint::FinishFenceNV, std::move(paramBuffer));
4506 }
4507
CaptureGenFencesNV(const State & glState,bool isCallValid,GLsizei n,FenceNVID * fencesPacked)4508 CallCapture CaptureGenFencesNV(const State &glState,
4509 bool isCallValid,
4510 GLsizei n,
4511 FenceNVID *fencesPacked)
4512 {
4513 ParamBuffer paramBuffer;
4514
4515 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4516
4517 ParamCapture fencesPackedParam("fencesPacked", ParamType::TFenceNVIDPointer);
4518 InitParamValue(ParamType::TFenceNVIDPointer, fencesPacked, &fencesPackedParam.value);
4519 CaptureGenFencesNV_fencesPacked(glState, isCallValid, n, fencesPacked, &fencesPackedParam);
4520 paramBuffer.addParam(std::move(fencesPackedParam));
4521
4522 return CallCapture(gl::EntryPoint::GenFencesNV, std::move(paramBuffer));
4523 }
4524
CaptureGetFenceivNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum pname,GLint * params)4525 CallCapture CaptureGetFenceivNV(const State &glState,
4526 bool isCallValid,
4527 FenceNVID fencePacked,
4528 GLenum pname,
4529 GLint *params)
4530 {
4531 ParamBuffer paramBuffer;
4532
4533 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
4534 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
4535
4536 ParamCapture paramsParam("params", ParamType::TGLintPointer);
4537 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
4538 CaptureGetFenceivNV_params(glState, isCallValid, fencePacked, pname, params, ¶msParam);
4539 paramBuffer.addParam(std::move(paramsParam));
4540
4541 return CallCapture(gl::EntryPoint::GetFenceivNV, std::move(paramBuffer));
4542 }
4543
CaptureIsFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)4544 CallCapture CaptureIsFenceNV(const State &glState,
4545 bool isCallValid,
4546 FenceNVID fencePacked,
4547 GLboolean returnValue)
4548 {
4549 ParamBuffer paramBuffer;
4550
4551 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
4552
4553 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
4554 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
4555 paramBuffer.addReturnValue(std::move(returnValueCapture));
4556
4557 return CallCapture(gl::EntryPoint::IsFenceNV, std::move(paramBuffer));
4558 }
4559
CaptureSetFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLenum condition)4560 CallCapture CaptureSetFenceNV(const State &glState,
4561 bool isCallValid,
4562 FenceNVID fencePacked,
4563 GLenum condition)
4564 {
4565 ParamBuffer paramBuffer;
4566
4567 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
4568 paramBuffer.addEnumParam("condition", GLenumGroup::DefaultGroup, ParamType::TGLenum, condition);
4569
4570 return CallCapture(gl::EntryPoint::SetFenceNV, std::move(paramBuffer));
4571 }
4572
CaptureTestFenceNV(const State & glState,bool isCallValid,FenceNVID fencePacked,GLboolean returnValue)4573 CallCapture CaptureTestFenceNV(const State &glState,
4574 bool isCallValid,
4575 FenceNVID fencePacked,
4576 GLboolean returnValue)
4577 {
4578 ParamBuffer paramBuffer;
4579
4580 paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked);
4581
4582 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
4583 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
4584 paramBuffer.addReturnValue(std::move(returnValueCapture));
4585
4586 return CallCapture(gl::EntryPoint::TestFenceNV, std::move(paramBuffer));
4587 }
4588
CaptureEGLImageTargetRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLeglImageOES image)4589 CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
4590 bool isCallValid,
4591 GLenum target,
4592 GLeglImageOES image)
4593 {
4594 ParamBuffer paramBuffer;
4595
4596 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
4597 paramBuffer.addValueParam("image", ParamType::TGLeglImageOES, image);
4598
4599 return CallCapture(gl::EntryPoint::EGLImageTargetRenderbufferStorageOES,
4600 std::move(paramBuffer));
4601 }
4602
CaptureEGLImageTargetTexture2DOES(const State & glState,bool isCallValid,TextureType targetPacked,GLeglImageOES image)4603 CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
4604 bool isCallValid,
4605 TextureType targetPacked,
4606 GLeglImageOES image)
4607 {
4608 ParamBuffer paramBuffer;
4609
4610 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
4611 paramBuffer.addValueParam("image", ParamType::TGLeglImageOES, image);
4612
4613 return CallCapture(gl::EntryPoint::EGLImageTargetTexture2DOES, std::move(paramBuffer));
4614 }
4615
CaptureBlendEquationSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)4616 CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
4617 bool isCallValid,
4618 GLuint buf,
4619 GLenum modeRGB,
4620 GLenum modeAlpha)
4621 {
4622 ParamBuffer paramBuffer;
4623
4624 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
4625 paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
4626 modeRGB);
4627 paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
4628 modeAlpha);
4629
4630 return CallCapture(gl::EntryPoint::BlendEquationSeparateiOES, std::move(paramBuffer));
4631 }
4632
CaptureBlendEquationiOES(const State & glState,bool isCallValid,GLuint buf,GLenum mode)4633 CallCapture CaptureBlendEquationiOES(const State &glState,
4634 bool isCallValid,
4635 GLuint buf,
4636 GLenum mode)
4637 {
4638 ParamBuffer paramBuffer;
4639
4640 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
4641 paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode);
4642
4643 return CallCapture(gl::EntryPoint::BlendEquationiOES, std::move(paramBuffer));
4644 }
4645
CaptureBlendFuncSeparateiOES(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)4646 CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
4647 bool isCallValid,
4648 GLuint buf,
4649 GLenum srcRGB,
4650 GLenum dstRGB,
4651 GLenum srcAlpha,
4652 GLenum dstAlpha)
4653 {
4654 ParamBuffer paramBuffer;
4655
4656 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
4657 paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB);
4658 paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB);
4659 paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha);
4660 paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha);
4661
4662 return CallCapture(gl::EntryPoint::BlendFuncSeparateiOES, std::move(paramBuffer));
4663 }
4664
CaptureBlendFunciOES(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)4665 CallCapture CaptureBlendFunciOES(const State &glState,
4666 bool isCallValid,
4667 GLuint buf,
4668 GLenum src,
4669 GLenum dst)
4670 {
4671 ParamBuffer paramBuffer;
4672
4673 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
4674 paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src);
4675 paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst);
4676
4677 return CallCapture(gl::EntryPoint::BlendFunciOES, std::move(paramBuffer));
4678 }
4679
CaptureColorMaskiOES(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)4680 CallCapture CaptureColorMaskiOES(const State &glState,
4681 bool isCallValid,
4682 GLuint index,
4683 GLboolean r,
4684 GLboolean g,
4685 GLboolean b,
4686 GLboolean a)
4687 {
4688 ParamBuffer paramBuffer;
4689
4690 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
4691 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
4692 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
4693 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
4694 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
4695
4696 return CallCapture(gl::EntryPoint::ColorMaskiOES, std::move(paramBuffer));
4697 }
4698
CaptureDisableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)4699 CallCapture CaptureDisableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
4700 {
4701 ParamBuffer paramBuffer;
4702
4703 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
4704 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
4705
4706 return CallCapture(gl::EntryPoint::DisableiOES, std::move(paramBuffer));
4707 }
4708
CaptureEnableiOES(const State & glState,bool isCallValid,GLenum target,GLuint index)4709 CallCapture CaptureEnableiOES(const State &glState, bool isCallValid, GLenum target, GLuint index)
4710 {
4711 ParamBuffer paramBuffer;
4712
4713 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
4714 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
4715
4716 return CallCapture(gl::EntryPoint::EnableiOES, std::move(paramBuffer));
4717 }
4718
CaptureIsEnablediOES(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)4719 CallCapture CaptureIsEnablediOES(const State &glState,
4720 bool isCallValid,
4721 GLenum target,
4722 GLuint index,
4723 GLboolean returnValue)
4724 {
4725 ParamBuffer paramBuffer;
4726
4727 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
4728 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
4729
4730 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
4731 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
4732 paramBuffer.addReturnValue(std::move(returnValueCapture));
4733
4734 return CallCapture(gl::EntryPoint::IsEnablediOES, std::move(paramBuffer));
4735 }
4736
CaptureDrawElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)4737 CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
4738 bool isCallValid,
4739 PrimitiveMode modePacked,
4740 GLsizei count,
4741 DrawElementsType typePacked,
4742 const void *indices,
4743 GLint basevertex)
4744 {
4745 ParamBuffer paramBuffer;
4746
4747 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
4748 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
4749 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
4750
4751 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
4752 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
4753 CaptureDrawElementsBaseVertexOES_indices(glState, isCallValid, modePacked, count, typePacked,
4754 indices, basevertex, &indicesParam);
4755 paramBuffer.addParam(std::move(indicesParam));
4756
4757 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
4758
4759 return CallCapture(gl::EntryPoint::DrawElementsBaseVertexOES, std::move(paramBuffer));
4760 }
4761
CaptureDrawElementsInstancedBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)4762 CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
4763 bool isCallValid,
4764 PrimitiveMode modePacked,
4765 GLsizei count,
4766 DrawElementsType typePacked,
4767 const void *indices,
4768 GLsizei instancecount,
4769 GLint basevertex)
4770 {
4771 ParamBuffer paramBuffer;
4772
4773 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
4774 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
4775 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
4776
4777 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
4778 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
4779 CaptureDrawElementsInstancedBaseVertexOES_indices(glState, isCallValid, modePacked, count,
4780 typePacked, indices, instancecount,
4781 basevertex, &indicesParam);
4782 paramBuffer.addParam(std::move(indicesParam));
4783
4784 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
4785 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
4786
4787 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertexOES, std::move(paramBuffer));
4788 }
4789
CaptureDrawRangeElementsBaseVertexOES(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)4790 CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
4791 bool isCallValid,
4792 PrimitiveMode modePacked,
4793 GLuint start,
4794 GLuint end,
4795 GLsizei count,
4796 DrawElementsType typePacked,
4797 const void *indices,
4798 GLint basevertex)
4799 {
4800 ParamBuffer paramBuffer;
4801
4802 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
4803 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
4804 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
4805 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
4806 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
4807
4808 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
4809 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
4810 CaptureDrawRangeElementsBaseVertexOES_indices(glState, isCallValid, modePacked, start, end,
4811 count, typePacked, indices, basevertex,
4812 &indicesParam);
4813 paramBuffer.addParam(std::move(indicesParam));
4814
4815 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
4816
4817 return CallCapture(gl::EntryPoint::DrawRangeElementsBaseVertexOES, std::move(paramBuffer));
4818 }
4819
CaptureDrawTexfOES(const State & glState,bool isCallValid,GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)4820 CallCapture CaptureDrawTexfOES(const State &glState,
4821 bool isCallValid,
4822 GLfloat x,
4823 GLfloat y,
4824 GLfloat z,
4825 GLfloat width,
4826 GLfloat height)
4827 {
4828 ParamBuffer paramBuffer;
4829
4830 paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
4831 paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
4832 paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
4833 paramBuffer.addValueParam("width", ParamType::TGLfloat, width);
4834 paramBuffer.addValueParam("height", ParamType::TGLfloat, height);
4835
4836 return CallCapture(gl::EntryPoint::DrawTexfOES, std::move(paramBuffer));
4837 }
4838
CaptureDrawTexfvOES(const State & glState,bool isCallValid,const GLfloat * coords)4839 CallCapture CaptureDrawTexfvOES(const State &glState, bool isCallValid, const GLfloat *coords)
4840 {
4841 ParamBuffer paramBuffer;
4842
4843 ParamCapture coordsParam("coords", ParamType::TGLfloatConstPointer);
4844 InitParamValue(ParamType::TGLfloatConstPointer, coords, &coordsParam.value);
4845 CaptureDrawTexfvOES_coords(glState, isCallValid, coords, &coordsParam);
4846 paramBuffer.addParam(std::move(coordsParam));
4847
4848 return CallCapture(gl::EntryPoint::DrawTexfvOES, std::move(paramBuffer));
4849 }
4850
CaptureDrawTexiOES(const State & glState,bool isCallValid,GLint x,GLint y,GLint z,GLint width,GLint height)4851 CallCapture CaptureDrawTexiOES(const State &glState,
4852 bool isCallValid,
4853 GLint x,
4854 GLint y,
4855 GLint z,
4856 GLint width,
4857 GLint height)
4858 {
4859 ParamBuffer paramBuffer;
4860
4861 paramBuffer.addValueParam("x", ParamType::TGLint, x);
4862 paramBuffer.addValueParam("y", ParamType::TGLint, y);
4863 paramBuffer.addValueParam("z", ParamType::TGLint, z);
4864 paramBuffer.addValueParam("width", ParamType::TGLint, width);
4865 paramBuffer.addValueParam("height", ParamType::TGLint, height);
4866
4867 return CallCapture(gl::EntryPoint::DrawTexiOES, std::move(paramBuffer));
4868 }
4869
CaptureDrawTexivOES(const State & glState,bool isCallValid,const GLint * coords)4870 CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords)
4871 {
4872 ParamBuffer paramBuffer;
4873
4874 ParamCapture coordsParam("coords", ParamType::TGLintConstPointer);
4875 InitParamValue(ParamType::TGLintConstPointer, coords, &coordsParam.value);
4876 CaptureDrawTexivOES_coords(glState, isCallValid, coords, &coordsParam);
4877 paramBuffer.addParam(std::move(coordsParam));
4878
4879 return CallCapture(gl::EntryPoint::DrawTexivOES, std::move(paramBuffer));
4880 }
4881
CaptureDrawTexsOES(const State & glState,bool isCallValid,GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)4882 CallCapture CaptureDrawTexsOES(const State &glState,
4883 bool isCallValid,
4884 GLshort x,
4885 GLshort y,
4886 GLshort z,
4887 GLshort width,
4888 GLshort height)
4889 {
4890 ParamBuffer paramBuffer;
4891
4892 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
4893 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
4894 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
4895 paramBuffer.addValueParam("width", ParamType::TGLshort, width);
4896 paramBuffer.addValueParam("height", ParamType::TGLshort, height);
4897
4898 return CallCapture(gl::EntryPoint::DrawTexsOES, std::move(paramBuffer));
4899 }
4900
CaptureDrawTexsvOES(const State & glState,bool isCallValid,const GLshort * coords)4901 CallCapture CaptureDrawTexsvOES(const State &glState, bool isCallValid, const GLshort *coords)
4902 {
4903 ParamBuffer paramBuffer;
4904
4905 ParamCapture coordsParam("coords", ParamType::TGLshortConstPointer);
4906 InitParamValue(ParamType::TGLshortConstPointer, coords, &coordsParam.value);
4907 CaptureDrawTexsvOES_coords(glState, isCallValid, coords, &coordsParam);
4908 paramBuffer.addParam(std::move(coordsParam));
4909
4910 return CallCapture(gl::EntryPoint::DrawTexsvOES, std::move(paramBuffer));
4911 }
4912
CaptureDrawTexxOES(const State & glState,bool isCallValid,GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)4913 CallCapture CaptureDrawTexxOES(const State &glState,
4914 bool isCallValid,
4915 GLfixed x,
4916 GLfixed y,
4917 GLfixed z,
4918 GLfixed width,
4919 GLfixed height)
4920 {
4921 ParamBuffer paramBuffer;
4922
4923 paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
4924 paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
4925 paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
4926 paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
4927 paramBuffer.addValueParam("height", ParamType::TGLfixed, height);
4928
4929 return CallCapture(gl::EntryPoint::DrawTexxOES, std::move(paramBuffer));
4930 }
4931
CaptureDrawTexxvOES(const State & glState,bool isCallValid,const GLfixed * coords)4932 CallCapture CaptureDrawTexxvOES(const State &glState, bool isCallValid, const GLfixed *coords)
4933 {
4934 ParamBuffer paramBuffer;
4935
4936 ParamCapture coordsParam("coords", ParamType::TGLfixedConstPointer);
4937 InitParamValue(ParamType::TGLfixedConstPointer, coords, &coordsParam.value);
4938 CaptureDrawTexxvOES_coords(glState, isCallValid, coords, &coordsParam);
4939 paramBuffer.addParam(std::move(coordsParam));
4940
4941 return CallCapture(gl::EntryPoint::DrawTexxvOES, std::move(paramBuffer));
4942 }
4943
CaptureBindFramebufferOES(const State & glState,bool isCallValid,GLenum target,FramebufferID framebufferPacked)4944 CallCapture CaptureBindFramebufferOES(const State &glState,
4945 bool isCallValid,
4946 GLenum target,
4947 FramebufferID framebufferPacked)
4948 {
4949 ParamBuffer paramBuffer;
4950
4951 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
4952 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
4953
4954 return CallCapture(gl::EntryPoint::BindFramebufferOES, std::move(paramBuffer));
4955 }
4956
CaptureBindRenderbufferOES(const State & glState,bool isCallValid,GLenum target,RenderbufferID renderbufferPacked)4957 CallCapture CaptureBindRenderbufferOES(const State &glState,
4958 bool isCallValid,
4959 GLenum target,
4960 RenderbufferID renderbufferPacked)
4961 {
4962 ParamBuffer paramBuffer;
4963
4964 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
4965 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
4966
4967 return CallCapture(gl::EntryPoint::BindRenderbufferOES, std::move(paramBuffer));
4968 }
4969
CaptureCheckFramebufferStatusOES(const State & glState,bool isCallValid,GLenum target,GLenum returnValue)4970 CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
4971 bool isCallValid,
4972 GLenum target,
4973 GLenum returnValue)
4974 {
4975 ParamBuffer paramBuffer;
4976
4977 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
4978
4979 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
4980 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
4981 paramBuffer.addReturnValue(std::move(returnValueCapture));
4982
4983 return CallCapture(gl::EntryPoint::CheckFramebufferStatusOES, std::move(paramBuffer));
4984 }
4985
CaptureDeleteFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,const FramebufferID * framebuffersPacked)4986 CallCapture CaptureDeleteFramebuffersOES(const State &glState,
4987 bool isCallValid,
4988 GLsizei n,
4989 const FramebufferID *framebuffersPacked)
4990 {
4991 ParamBuffer paramBuffer;
4992
4993 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
4994
4995 ParamCapture framebuffersPackedParam("framebuffersPacked",
4996 ParamType::TFramebufferIDConstPointer);
4997 InitParamValue(ParamType::TFramebufferIDConstPointer, framebuffersPacked,
4998 &framebuffersPackedParam.value);
4999 CaptureDeleteFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
5000 &framebuffersPackedParam);
5001 paramBuffer.addParam(std::move(framebuffersPackedParam));
5002
5003 return CallCapture(gl::EntryPoint::DeleteFramebuffersOES, std::move(paramBuffer));
5004 }
5005
CaptureDeleteRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,const RenderbufferID * renderbuffersPacked)5006 CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
5007 bool isCallValid,
5008 GLsizei n,
5009 const RenderbufferID *renderbuffersPacked)
5010 {
5011 ParamBuffer paramBuffer;
5012
5013 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5014
5015 ParamCapture renderbuffersPackedParam("renderbuffersPacked",
5016 ParamType::TRenderbufferIDConstPointer);
5017 InitParamValue(ParamType::TRenderbufferIDConstPointer, renderbuffersPacked,
5018 &renderbuffersPackedParam.value);
5019 CaptureDeleteRenderbuffersOES_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
5020 &renderbuffersPackedParam);
5021 paramBuffer.addParam(std::move(renderbuffersPackedParam));
5022
5023 return CallCapture(gl::EntryPoint::DeleteRenderbuffersOES, std::move(paramBuffer));
5024 }
5025
CaptureFramebufferRenderbufferOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum renderbuffertarget,RenderbufferID renderbufferPacked)5026 CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
5027 bool isCallValid,
5028 GLenum target,
5029 GLenum attachment,
5030 GLenum renderbuffertarget,
5031 RenderbufferID renderbufferPacked)
5032 {
5033 ParamBuffer paramBuffer;
5034
5035 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
5036 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
5037 attachment);
5038 paramBuffer.addEnumParam("renderbuffertarget", GLenumGroup::RenderbufferTarget,
5039 ParamType::TGLenum, renderbuffertarget);
5040 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
5041
5042 return CallCapture(gl::EntryPoint::FramebufferRenderbufferOES, std::move(paramBuffer));
5043 }
5044
CaptureFramebufferTexture2DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level)5045 CallCapture CaptureFramebufferTexture2DOES(const State &glState,
5046 bool isCallValid,
5047 GLenum target,
5048 GLenum attachment,
5049 TextureTarget textargetPacked,
5050 TextureID texturePacked,
5051 GLint level)
5052 {
5053 ParamBuffer paramBuffer;
5054
5055 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
5056 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
5057 attachment);
5058 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
5059 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
5060 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5061
5062 return CallCapture(gl::EntryPoint::FramebufferTexture2DOES, std::move(paramBuffer));
5063 }
5064
CaptureGenFramebuffersOES(const State & glState,bool isCallValid,GLsizei n,FramebufferID * framebuffersPacked)5065 CallCapture CaptureGenFramebuffersOES(const State &glState,
5066 bool isCallValid,
5067 GLsizei n,
5068 FramebufferID *framebuffersPacked)
5069 {
5070 ParamBuffer paramBuffer;
5071
5072 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5073
5074 ParamCapture framebuffersPackedParam("framebuffersPacked", ParamType::TFramebufferIDPointer);
5075 InitParamValue(ParamType::TFramebufferIDPointer, framebuffersPacked,
5076 &framebuffersPackedParam.value);
5077 CaptureGenFramebuffersOES_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
5078 &framebuffersPackedParam);
5079 paramBuffer.addParam(std::move(framebuffersPackedParam));
5080
5081 return CallCapture(gl::EntryPoint::GenFramebuffersOES, std::move(paramBuffer));
5082 }
5083
CaptureGenRenderbuffersOES(const State & glState,bool isCallValid,GLsizei n,RenderbufferID * renderbuffersPacked)5084 CallCapture CaptureGenRenderbuffersOES(const State &glState,
5085 bool isCallValid,
5086 GLsizei n,
5087 RenderbufferID *renderbuffersPacked)
5088 {
5089 ParamBuffer paramBuffer;
5090
5091 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5092
5093 ParamCapture renderbuffersPackedParam("renderbuffersPacked", ParamType::TRenderbufferIDPointer);
5094 InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
5095 &renderbuffersPackedParam.value);
5096 CaptureGenRenderbuffersOES_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
5097 &renderbuffersPackedParam);
5098 paramBuffer.addParam(std::move(renderbuffersPackedParam));
5099
5100 return CallCapture(gl::EntryPoint::GenRenderbuffersOES, std::move(paramBuffer));
5101 }
5102
CaptureGenerateMipmapOES(const State & glState,bool isCallValid,TextureType targetPacked)5103 CallCapture CaptureGenerateMipmapOES(const State &glState,
5104 bool isCallValid,
5105 TextureType targetPacked)
5106 {
5107 ParamBuffer paramBuffer;
5108
5109 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5110
5111 return CallCapture(gl::EntryPoint::GenerateMipmapOES, std::move(paramBuffer));
5112 }
5113
CaptureGetFramebufferAttachmentParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLint * params)5114 CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
5115 bool isCallValid,
5116 GLenum target,
5117 GLenum attachment,
5118 GLenum pname,
5119 GLint *params)
5120 {
5121 ParamBuffer paramBuffer;
5122
5123 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
5124 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
5125 attachment);
5126 paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName,
5127 ParamType::TGLenum, pname);
5128
5129 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5130 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5131 CaptureGetFramebufferAttachmentParameterivOES_params(glState, isCallValid, target, attachment,
5132 pname, params, ¶msParam);
5133 paramBuffer.addParam(std::move(paramsParam));
5134
5135 return CallCapture(gl::EntryPoint::GetFramebufferAttachmentParameterivOES,
5136 std::move(paramBuffer));
5137 }
5138
CaptureGetRenderbufferParameterivOES(const State & glState,bool isCallValid,GLenum target,GLenum pname,GLint * params)5139 CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
5140 bool isCallValid,
5141 GLenum target,
5142 GLenum pname,
5143 GLint *params)
5144 {
5145 ParamBuffer paramBuffer;
5146
5147 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
5148 paramBuffer.addEnumParam("pname", GLenumGroup::RenderbufferParameterName, ParamType::TGLenum,
5149 pname);
5150
5151 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5152 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5153 CaptureGetRenderbufferParameterivOES_params(glState, isCallValid, target, pname, params,
5154 ¶msParam);
5155 paramBuffer.addParam(std::move(paramsParam));
5156
5157 return CallCapture(gl::EntryPoint::GetRenderbufferParameterivOES, std::move(paramBuffer));
5158 }
5159
CaptureIsFramebufferOES(const State & glState,bool isCallValid,FramebufferID framebufferPacked,GLboolean returnValue)5160 CallCapture CaptureIsFramebufferOES(const State &glState,
5161 bool isCallValid,
5162 FramebufferID framebufferPacked,
5163 GLboolean returnValue)
5164 {
5165 ParamBuffer paramBuffer;
5166
5167 paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
5168
5169 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
5170 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
5171 paramBuffer.addReturnValue(std::move(returnValueCapture));
5172
5173 return CallCapture(gl::EntryPoint::IsFramebufferOES, std::move(paramBuffer));
5174 }
5175
CaptureIsRenderbufferOES(const State & glState,bool isCallValid,RenderbufferID renderbufferPacked,GLboolean returnValue)5176 CallCapture CaptureIsRenderbufferOES(const State &glState,
5177 bool isCallValid,
5178 RenderbufferID renderbufferPacked,
5179 GLboolean returnValue)
5180 {
5181 ParamBuffer paramBuffer;
5182
5183 paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
5184
5185 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
5186 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
5187 paramBuffer.addReturnValue(std::move(returnValueCapture));
5188
5189 return CallCapture(gl::EntryPoint::IsRenderbufferOES, std::move(paramBuffer));
5190 }
5191
CaptureRenderbufferStorageOES(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)5192 CallCapture CaptureRenderbufferStorageOES(const State &glState,
5193 bool isCallValid,
5194 GLenum target,
5195 GLenum internalformat,
5196 GLsizei width,
5197 GLsizei height)
5198 {
5199 ParamBuffer paramBuffer;
5200
5201 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
5202 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
5203 internalformat);
5204 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5205 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5206
5207 return CallCapture(gl::EntryPoint::RenderbufferStorageOES, std::move(paramBuffer));
5208 }
5209
CaptureGetProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)5210 CallCapture CaptureGetProgramBinaryOES(const State &glState,
5211 bool isCallValid,
5212 ShaderProgramID programPacked,
5213 GLsizei bufSize,
5214 GLsizei *length,
5215 GLenum *binaryFormat,
5216 void *binary)
5217 {
5218 ParamBuffer paramBuffer;
5219
5220 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5221 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
5222
5223 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
5224 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
5225 CaptureGetProgramBinaryOES_length(glState, isCallValid, programPacked, bufSize, length,
5226 binaryFormat, binary, &lengthParam);
5227 paramBuffer.addParam(std::move(lengthParam));
5228
5229 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
5230 InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
5231 CaptureGetProgramBinaryOES_binaryFormat(glState, isCallValid, programPacked, bufSize, length,
5232 binaryFormat, binary, &binaryFormatParam);
5233 paramBuffer.addParam(std::move(binaryFormatParam));
5234
5235 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
5236 InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
5237 CaptureGetProgramBinaryOES_binary(glState, isCallValid, programPacked, bufSize, length,
5238 binaryFormat, binary, &binaryParam);
5239 paramBuffer.addParam(std::move(binaryParam));
5240
5241 return CallCapture(gl::EntryPoint::GetProgramBinaryOES, std::move(paramBuffer));
5242 }
5243
CaptureProgramBinaryOES(const State & glState,bool isCallValid,ShaderProgramID programPacked,GLenum binaryFormat,const void * binary,GLint length)5244 CallCapture CaptureProgramBinaryOES(const State &glState,
5245 bool isCallValid,
5246 ShaderProgramID programPacked,
5247 GLenum binaryFormat,
5248 const void *binary,
5249 GLint length)
5250 {
5251 ParamBuffer paramBuffer;
5252
5253 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
5254 paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
5255 binaryFormat);
5256
5257 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
5258 InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
5259 CaptureProgramBinaryOES_binary(glState, isCallValid, programPacked, binaryFormat, binary,
5260 length, &binaryParam);
5261 paramBuffer.addParam(std::move(binaryParam));
5262
5263 paramBuffer.addValueParam("length", ParamType::TGLint, length);
5264
5265 return CallCapture(gl::EntryPoint::ProgramBinaryOES, std::move(paramBuffer));
5266 }
5267
CaptureGetBufferPointervOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum pname,void ** params)5268 CallCapture CaptureGetBufferPointervOES(const State &glState,
5269 bool isCallValid,
5270 BufferBinding targetPacked,
5271 GLenum pname,
5272 void **params)
5273 {
5274 ParamBuffer paramBuffer;
5275
5276 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5277 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
5278
5279 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
5280 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
5281 CaptureGetBufferPointervOES_params(glState, isCallValid, targetPacked, pname, params,
5282 ¶msParam);
5283 paramBuffer.addParam(std::move(paramsParam));
5284
5285 return CallCapture(gl::EntryPoint::GetBufferPointervOES, std::move(paramBuffer));
5286 }
5287
CaptureMapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLenum access,void * returnValue)5288 CallCapture CaptureMapBufferOES(const State &glState,
5289 bool isCallValid,
5290 BufferBinding targetPacked,
5291 GLenum access,
5292 void *returnValue)
5293 {
5294 ParamBuffer paramBuffer;
5295
5296 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5297 paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access);
5298
5299 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
5300 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
5301 paramBuffer.addReturnValue(std::move(returnValueCapture));
5302
5303 return CallCapture(gl::EntryPoint::MapBufferOES, std::move(paramBuffer));
5304 }
5305
CaptureUnmapBufferOES(const State & glState,bool isCallValid,BufferBinding targetPacked,GLboolean returnValue)5306 CallCapture CaptureUnmapBufferOES(const State &glState,
5307 bool isCallValid,
5308 BufferBinding targetPacked,
5309 GLboolean returnValue)
5310 {
5311 ParamBuffer paramBuffer;
5312
5313 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
5314
5315 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
5316 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
5317 paramBuffer.addReturnValue(std::move(returnValueCapture));
5318
5319 return CallCapture(gl::EntryPoint::UnmapBufferOES, std::move(paramBuffer));
5320 }
5321
CaptureCurrentPaletteMatrixOES(const State & glState,bool isCallValid,GLuint matrixpaletteindex)5322 CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
5323 bool isCallValid,
5324 GLuint matrixpaletteindex)
5325 {
5326 ParamBuffer paramBuffer;
5327
5328 paramBuffer.addValueParam("matrixpaletteindex", ParamType::TGLuint, matrixpaletteindex);
5329
5330 return CallCapture(gl::EntryPoint::CurrentPaletteMatrixOES, std::move(paramBuffer));
5331 }
5332
CaptureLoadPaletteFromModelViewMatrixOES(const State & glState,bool isCallValid)5333 CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid)
5334 {
5335 ParamBuffer paramBuffer;
5336
5337 return CallCapture(gl::EntryPoint::LoadPaletteFromModelViewMatrixOES, std::move(paramBuffer));
5338 }
5339
CaptureMatrixIndexPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)5340 CallCapture CaptureMatrixIndexPointerOES(const State &glState,
5341 bool isCallValid,
5342 GLint size,
5343 GLenum type,
5344 GLsizei stride,
5345 const void *pointer)
5346 {
5347 ParamBuffer paramBuffer;
5348
5349 paramBuffer.addValueParam("size", ParamType::TGLint, size);
5350 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
5351 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
5352
5353 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
5354 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
5355 CaptureMatrixIndexPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
5356 &pointerParam);
5357 paramBuffer.addParam(std::move(pointerParam));
5358
5359 return CallCapture(gl::EntryPoint::MatrixIndexPointerOES, std::move(paramBuffer));
5360 }
5361
CaptureWeightPointerOES(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer)5362 CallCapture CaptureWeightPointerOES(const State &glState,
5363 bool isCallValid,
5364 GLint size,
5365 GLenum type,
5366 GLsizei stride,
5367 const void *pointer)
5368 {
5369 ParamBuffer paramBuffer;
5370
5371 paramBuffer.addValueParam("size", ParamType::TGLint, size);
5372 paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type);
5373 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
5374
5375 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
5376 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
5377 CaptureWeightPointerOES_pointer(glState, isCallValid, size, type, stride, pointer,
5378 &pointerParam);
5379 paramBuffer.addParam(std::move(pointerParam));
5380
5381 return CallCapture(gl::EntryPoint::WeightPointerOES, std::move(paramBuffer));
5382 }
5383
CapturePointSizePointerOES(const State & glState,bool isCallValid,VertexAttribType typePacked,GLsizei stride,const void * pointer)5384 CallCapture CapturePointSizePointerOES(const State &glState,
5385 bool isCallValid,
5386 VertexAttribType typePacked,
5387 GLsizei stride,
5388 const void *pointer)
5389 {
5390 ParamBuffer paramBuffer;
5391
5392 paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
5393 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
5394
5395 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
5396 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
5397 CapturePointSizePointerOES_pointer(glState, isCallValid, typePacked, stride, pointer,
5398 &pointerParam);
5399 paramBuffer.addParam(std::move(pointerParam));
5400
5401 return CallCapture(gl::EntryPoint::PointSizePointerOES, std::move(paramBuffer));
5402 }
5403
CaptureQueryMatrixxOES(const State & glState,bool isCallValid,GLfixed * mantissa,GLint * exponent,GLbitfield returnValue)5404 CallCapture CaptureQueryMatrixxOES(const State &glState,
5405 bool isCallValid,
5406 GLfixed *mantissa,
5407 GLint *exponent,
5408 GLbitfield returnValue)
5409 {
5410 ParamBuffer paramBuffer;
5411
5412 ParamCapture mantissaParam("mantissa", ParamType::TGLfixedPointer);
5413 InitParamValue(ParamType::TGLfixedPointer, mantissa, &mantissaParam.value);
5414 CaptureQueryMatrixxOES_mantissa(glState, isCallValid, mantissa, exponent, &mantissaParam);
5415 paramBuffer.addParam(std::move(mantissaParam));
5416
5417 ParamCapture exponentParam("exponent", ParamType::TGLintPointer);
5418 InitParamValue(ParamType::TGLintPointer, exponent, &exponentParam.value);
5419 CaptureQueryMatrixxOES_exponent(glState, isCallValid, mantissa, exponent, &exponentParam);
5420 paramBuffer.addParam(std::move(exponentParam));
5421
5422 ParamCapture returnValueCapture("returnValue", ParamType::TGLbitfield);
5423 InitParamValue(ParamType::TGLbitfield, returnValue, &returnValueCapture.value);
5424 paramBuffer.addReturnValue(std::move(returnValueCapture));
5425
5426 return CallCapture(gl::EntryPoint::QueryMatrixxOES, std::move(paramBuffer));
5427 }
5428
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)5429 CallCapture CaptureCompressedTexImage3DOES(const State &glState,
5430 bool isCallValid,
5431 TextureTarget targetPacked,
5432 GLint level,
5433 GLenum internalformat,
5434 GLsizei width,
5435 GLsizei height,
5436 GLsizei depth,
5437 GLint border,
5438 GLsizei imageSize,
5439 const void *data)
5440 {
5441 ParamBuffer paramBuffer;
5442
5443 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5444 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5445 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
5446 internalformat);
5447 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5448 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5449 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5450 paramBuffer.addValueParam("border", ParamType::TGLint, border);
5451 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
5452
5453 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5454 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
5455 CaptureCompressedTexImage3DOES_data(glState, isCallValid, targetPacked, level, internalformat,
5456 width, height, depth, border, imageSize, data, &dataParam);
5457 paramBuffer.addParam(std::move(dataParam));
5458
5459 return CallCapture(gl::EntryPoint::CompressedTexImage3DOES, std::move(paramBuffer));
5460 }
5461
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)5462 CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
5463 bool isCallValid,
5464 TextureTarget targetPacked,
5465 GLint level,
5466 GLint xoffset,
5467 GLint yoffset,
5468 GLint zoffset,
5469 GLsizei width,
5470 GLsizei height,
5471 GLsizei depth,
5472 GLenum format,
5473 GLsizei imageSize,
5474 const void *data)
5475 {
5476 ParamBuffer paramBuffer;
5477
5478 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5479 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5480 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
5481 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
5482 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
5483 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5484 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5485 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5486 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
5487 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
5488
5489 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
5490 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
5491 CaptureCompressedTexSubImage3DOES_data(glState, isCallValid, targetPacked, level, xoffset,
5492 yoffset, zoffset, width, height, depth, format,
5493 imageSize, data, &dataParam);
5494 paramBuffer.addParam(std::move(dataParam));
5495
5496 return CallCapture(gl::EntryPoint::CompressedTexSubImage3DOES, std::move(paramBuffer));
5497 }
5498
CaptureCopyTexSubImage3DOES(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)5499 CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
5500 bool isCallValid,
5501 TextureTarget targetPacked,
5502 GLint level,
5503 GLint xoffset,
5504 GLint yoffset,
5505 GLint zoffset,
5506 GLint x,
5507 GLint y,
5508 GLsizei width,
5509 GLsizei height)
5510 {
5511 ParamBuffer paramBuffer;
5512
5513 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5514 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5515 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
5516 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
5517 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
5518 paramBuffer.addValueParam("x", ParamType::TGLint, x);
5519 paramBuffer.addValueParam("y", ParamType::TGLint, y);
5520 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5521 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5522
5523 return CallCapture(gl::EntryPoint::CopyTexSubImage3DOES, std::move(paramBuffer));
5524 }
5525
CaptureFramebufferTexture3DOES(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureTarget textargetPacked,TextureID texturePacked,GLint level,GLint zoffset)5526 CallCapture CaptureFramebufferTexture3DOES(const State &glState,
5527 bool isCallValid,
5528 GLenum target,
5529 GLenum attachment,
5530 TextureTarget textargetPacked,
5531 TextureID texturePacked,
5532 GLint level,
5533 GLint zoffset)
5534 {
5535 ParamBuffer paramBuffer;
5536
5537 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
5538 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
5539 attachment);
5540 paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked);
5541 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
5542 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5543 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
5544
5545 return CallCapture(gl::EntryPoint::FramebufferTexture3DOES, std::move(paramBuffer));
5546 }
5547
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)5548 CallCapture CaptureTexImage3DOES(const State &glState,
5549 bool isCallValid,
5550 TextureTarget targetPacked,
5551 GLint level,
5552 GLenum internalformat,
5553 GLsizei width,
5554 GLsizei height,
5555 GLsizei depth,
5556 GLint border,
5557 GLenum format,
5558 GLenum type,
5559 const void *pixels)
5560 {
5561 ParamBuffer paramBuffer;
5562
5563 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5564 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5565 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
5566 internalformat);
5567 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5568 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5569 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5570 paramBuffer.addValueParam("border", ParamType::TGLint, border);
5571 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
5572 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
5573
5574 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
5575 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
5576 CaptureTexImage3DOES_pixels(glState, isCallValid, targetPacked, level, internalformat, width,
5577 height, depth, border, format, type, pixels, &pixelsParam);
5578 paramBuffer.addParam(std::move(pixelsParam));
5579
5580 return CallCapture(gl::EntryPoint::TexImage3DOES, std::move(paramBuffer));
5581 }
5582
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)5583 CallCapture CaptureTexSubImage3DOES(const State &glState,
5584 bool isCallValid,
5585 TextureTarget targetPacked,
5586 GLint level,
5587 GLint xoffset,
5588 GLint yoffset,
5589 GLint zoffset,
5590 GLsizei width,
5591 GLsizei height,
5592 GLsizei depth,
5593 GLenum format,
5594 GLenum type,
5595 const void *pixels)
5596 {
5597 ParamBuffer paramBuffer;
5598
5599 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
5600 paramBuffer.addValueParam("level", ParamType::TGLint, level);
5601 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
5602 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
5603 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
5604 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5605 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5606 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5607 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
5608 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
5609
5610 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
5611 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
5612 CaptureTexSubImage3DOES_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
5613 zoffset, width, height, depth, format, type, pixels,
5614 &pixelsParam);
5615 paramBuffer.addParam(std::move(pixelsParam));
5616
5617 return CallCapture(gl::EntryPoint::TexSubImage3DOES, std::move(paramBuffer));
5618 }
5619
CaptureGetSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)5620 CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
5621 bool isCallValid,
5622 SamplerID samplerPacked,
5623 GLenum pname,
5624 GLint *params)
5625 {
5626 ParamBuffer paramBuffer;
5627
5628 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
5629 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
5630
5631 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5632 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5633 CaptureGetSamplerParameterIivOES_params(glState, isCallValid, samplerPacked, pname, params,
5634 ¶msParam);
5635 paramBuffer.addParam(std::move(paramsParam));
5636
5637 return CallCapture(gl::EntryPoint::GetSamplerParameterIivOES, std::move(paramBuffer));
5638 }
5639
CaptureGetSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)5640 CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
5641 bool isCallValid,
5642 SamplerID samplerPacked,
5643 GLenum pname,
5644 GLuint *params)
5645 {
5646 ParamBuffer paramBuffer;
5647
5648 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
5649 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
5650
5651 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
5652 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
5653 CaptureGetSamplerParameterIuivOES_params(glState, isCallValid, samplerPacked, pname, params,
5654 ¶msParam);
5655 paramBuffer.addParam(std::move(paramsParam));
5656
5657 return CallCapture(gl::EntryPoint::GetSamplerParameterIuivOES, std::move(paramBuffer));
5658 }
5659
CaptureGetTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)5660 CallCapture CaptureGetTexParameterIivOES(const State &glState,
5661 bool isCallValid,
5662 TextureType targetPacked,
5663 GLenum pname,
5664 GLint *params)
5665 {
5666 ParamBuffer paramBuffer;
5667
5668 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5669 paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
5670
5671 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5672 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5673 CaptureGetTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
5674 ¶msParam);
5675 paramBuffer.addParam(std::move(paramsParam));
5676
5677 return CallCapture(gl::EntryPoint::GetTexParameterIivOES, std::move(paramBuffer));
5678 }
5679
CaptureGetTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)5680 CallCapture CaptureGetTexParameterIuivOES(const State &glState,
5681 bool isCallValid,
5682 TextureType targetPacked,
5683 GLenum pname,
5684 GLuint *params)
5685 {
5686 ParamBuffer paramBuffer;
5687
5688 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5689 paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
5690
5691 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
5692 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
5693 CaptureGetTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
5694 ¶msParam);
5695 paramBuffer.addParam(std::move(paramsParam));
5696
5697 return CallCapture(gl::EntryPoint::GetTexParameterIuivOES, std::move(paramBuffer));
5698 }
5699
CaptureSamplerParameterIivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)5700 CallCapture CaptureSamplerParameterIivOES(const State &glState,
5701 bool isCallValid,
5702 SamplerID samplerPacked,
5703 GLenum pname,
5704 const GLint *param)
5705 {
5706 ParamBuffer paramBuffer;
5707
5708 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
5709 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
5710
5711 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
5712 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
5713 CaptureSamplerParameterIivOES_param(glState, isCallValid, samplerPacked, pname, param,
5714 ¶mParam);
5715 paramBuffer.addParam(std::move(paramParam));
5716
5717 return CallCapture(gl::EntryPoint::SamplerParameterIivOES, std::move(paramBuffer));
5718 }
5719
CaptureSamplerParameterIuivOES(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)5720 CallCapture CaptureSamplerParameterIuivOES(const State &glState,
5721 bool isCallValid,
5722 SamplerID samplerPacked,
5723 GLenum pname,
5724 const GLuint *param)
5725 {
5726 ParamBuffer paramBuffer;
5727
5728 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
5729 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
5730
5731 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
5732 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
5733 CaptureSamplerParameterIuivOES_param(glState, isCallValid, samplerPacked, pname, param,
5734 ¶mParam);
5735 paramBuffer.addParam(std::move(paramParam));
5736
5737 return CallCapture(gl::EntryPoint::SamplerParameterIuivOES, std::move(paramBuffer));
5738 }
5739
CaptureTexParameterIivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)5740 CallCapture CaptureTexParameterIivOES(const State &glState,
5741 bool isCallValid,
5742 TextureType targetPacked,
5743 GLenum pname,
5744 const GLint *params)
5745 {
5746 ParamBuffer paramBuffer;
5747
5748 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5749 paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
5750
5751 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
5752 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
5753 CaptureTexParameterIivOES_params(glState, isCallValid, targetPacked, pname, params,
5754 ¶msParam);
5755 paramBuffer.addParam(std::move(paramsParam));
5756
5757 return CallCapture(gl::EntryPoint::TexParameterIivOES, std::move(paramBuffer));
5758 }
5759
CaptureTexParameterIuivOES(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)5760 CallCapture CaptureTexParameterIuivOES(const State &glState,
5761 bool isCallValid,
5762 TextureType targetPacked,
5763 GLenum pname,
5764 const GLuint *params)
5765 {
5766 ParamBuffer paramBuffer;
5767
5768 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5769 paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
5770
5771 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
5772 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
5773 CaptureTexParameterIuivOES_params(glState, isCallValid, targetPacked, pname, params,
5774 ¶msParam);
5775 paramBuffer.addParam(std::move(paramsParam));
5776
5777 return CallCapture(gl::EntryPoint::TexParameterIuivOES, std::move(paramBuffer));
5778 }
5779
CaptureGetTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat * params)5780 CallCapture CaptureGetTexGenfvOES(const State &glState,
5781 bool isCallValid,
5782 GLenum coord,
5783 GLenum pname,
5784 GLfloat *params)
5785 {
5786 ParamBuffer paramBuffer;
5787
5788 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5789 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5790
5791 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
5792 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
5793 CaptureGetTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
5794 paramBuffer.addParam(std::move(paramsParam));
5795
5796 return CallCapture(gl::EntryPoint::GetTexGenfvOES, std::move(paramBuffer));
5797 }
5798
CaptureGetTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint * params)5799 CallCapture CaptureGetTexGenivOES(const State &glState,
5800 bool isCallValid,
5801 GLenum coord,
5802 GLenum pname,
5803 GLint *params)
5804 {
5805 ParamBuffer paramBuffer;
5806
5807 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5808 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5809
5810 ParamCapture paramsParam("params", ParamType::TGLintPointer);
5811 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
5812 CaptureGetTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
5813 paramBuffer.addParam(std::move(paramsParam));
5814
5815 return CallCapture(gl::EntryPoint::GetTexGenivOES, std::move(paramBuffer));
5816 }
5817
CaptureGetTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed * params)5818 CallCapture CaptureGetTexGenxvOES(const State &glState,
5819 bool isCallValid,
5820 GLenum coord,
5821 GLenum pname,
5822 GLfixed *params)
5823 {
5824 ParamBuffer paramBuffer;
5825
5826 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5827 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5828
5829 ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
5830 InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value);
5831 CaptureGetTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
5832 paramBuffer.addParam(std::move(paramsParam));
5833
5834 return CallCapture(gl::EntryPoint::GetTexGenxvOES, std::move(paramBuffer));
5835 }
5836
CaptureTexGenfOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat param)5837 CallCapture CaptureTexGenfOES(const State &glState,
5838 bool isCallValid,
5839 GLenum coord,
5840 GLenum pname,
5841 GLfloat param)
5842 {
5843 ParamBuffer paramBuffer;
5844
5845 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5846 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5847 paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
5848
5849 return CallCapture(gl::EntryPoint::TexGenfOES, std::move(paramBuffer));
5850 }
5851
CaptureTexGenfvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfloat * params)5852 CallCapture CaptureTexGenfvOES(const State &glState,
5853 bool isCallValid,
5854 GLenum coord,
5855 GLenum pname,
5856 const GLfloat *params)
5857 {
5858 ParamBuffer paramBuffer;
5859
5860 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5861 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5862
5863 ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
5864 InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value);
5865 CaptureTexGenfvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
5866 paramBuffer.addParam(std::move(paramsParam));
5867
5868 return CallCapture(gl::EntryPoint::TexGenfvOES, std::move(paramBuffer));
5869 }
5870
CaptureTexGeniOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint param)5871 CallCapture CaptureTexGeniOES(const State &glState,
5872 bool isCallValid,
5873 GLenum coord,
5874 GLenum pname,
5875 GLint param)
5876 {
5877 ParamBuffer paramBuffer;
5878
5879 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5880 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5881 paramBuffer.addValueParam("param", ParamType::TGLint, param);
5882
5883 return CallCapture(gl::EntryPoint::TexGeniOES, std::move(paramBuffer));
5884 }
5885
CaptureTexGenivOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLint * params)5886 CallCapture CaptureTexGenivOES(const State &glState,
5887 bool isCallValid,
5888 GLenum coord,
5889 GLenum pname,
5890 const GLint *params)
5891 {
5892 ParamBuffer paramBuffer;
5893
5894 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5895 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5896
5897 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
5898 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
5899 CaptureTexGenivOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
5900 paramBuffer.addParam(std::move(paramsParam));
5901
5902 return CallCapture(gl::EntryPoint::TexGenivOES, std::move(paramBuffer));
5903 }
5904
CaptureTexGenxOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfixed param)5905 CallCapture CaptureTexGenxOES(const State &glState,
5906 bool isCallValid,
5907 GLenum coord,
5908 GLenum pname,
5909 GLfixed param)
5910 {
5911 ParamBuffer paramBuffer;
5912
5913 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5914 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5915 paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
5916
5917 return CallCapture(gl::EntryPoint::TexGenxOES, std::move(paramBuffer));
5918 }
5919
CaptureTexGenxvOES(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfixed * params)5920 CallCapture CaptureTexGenxvOES(const State &glState,
5921 bool isCallValid,
5922 GLenum coord,
5923 GLenum pname,
5924 const GLfixed *params)
5925 {
5926 ParamBuffer paramBuffer;
5927
5928 paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord);
5929 paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname);
5930
5931 ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
5932 InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value);
5933 CaptureTexGenxvOES_params(glState, isCallValid, coord, pname, params, ¶msParam);
5934 paramBuffer.addParam(std::move(paramsParam));
5935
5936 return CallCapture(gl::EntryPoint::TexGenxvOES, std::move(paramBuffer));
5937 }
5938
CaptureTexStorage3DMultisampleOES(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)5939 CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
5940 bool isCallValid,
5941 TextureType targetPacked,
5942 GLsizei samples,
5943 GLenum internalformat,
5944 GLsizei width,
5945 GLsizei height,
5946 GLsizei depth,
5947 GLboolean fixedsamplelocations)
5948 {
5949 ParamBuffer paramBuffer;
5950
5951 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
5952 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
5953 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
5954 internalformat);
5955 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
5956 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
5957 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
5958 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
5959
5960 return CallCapture(gl::EntryPoint::TexStorage3DMultisampleOES, std::move(paramBuffer));
5961 }
5962
CaptureBindVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked)5963 CallCapture CaptureBindVertexArrayOES(const State &glState,
5964 bool isCallValid,
5965 VertexArrayID arrayPacked)
5966 {
5967 ParamBuffer paramBuffer;
5968
5969 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
5970
5971 return CallCapture(gl::EntryPoint::BindVertexArrayOES, std::move(paramBuffer));
5972 }
5973
CaptureDeleteVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,const VertexArrayID * arraysPacked)5974 CallCapture CaptureDeleteVertexArraysOES(const State &glState,
5975 bool isCallValid,
5976 GLsizei n,
5977 const VertexArrayID *arraysPacked)
5978 {
5979 ParamBuffer paramBuffer;
5980
5981 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
5982
5983 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
5984 InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked, &arraysPackedParam.value);
5985 CaptureDeleteVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
5986 &arraysPackedParam);
5987 paramBuffer.addParam(std::move(arraysPackedParam));
5988
5989 return CallCapture(gl::EntryPoint::DeleteVertexArraysOES, std::move(paramBuffer));
5990 }
5991
CaptureGenVertexArraysOES(const State & glState,bool isCallValid,GLsizei n,VertexArrayID * arraysPacked)5992 CallCapture CaptureGenVertexArraysOES(const State &glState,
5993 bool isCallValid,
5994 GLsizei n,
5995 VertexArrayID *arraysPacked)
5996 {
5997 ParamBuffer paramBuffer;
5998
5999 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
6000
6001 ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
6002 InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
6003 CaptureGenVertexArraysOES_arraysPacked(glState, isCallValid, n, arraysPacked,
6004 &arraysPackedParam);
6005 paramBuffer.addParam(std::move(arraysPackedParam));
6006
6007 return CallCapture(gl::EntryPoint::GenVertexArraysOES, std::move(paramBuffer));
6008 }
6009
CaptureIsVertexArrayOES(const State & glState,bool isCallValid,VertexArrayID arrayPacked,GLboolean returnValue)6010 CallCapture CaptureIsVertexArrayOES(const State &glState,
6011 bool isCallValid,
6012 VertexArrayID arrayPacked,
6013 GLboolean returnValue)
6014 {
6015 ParamBuffer paramBuffer;
6016
6017 paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked);
6018
6019 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
6020 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
6021 paramBuffer.addReturnValue(std::move(returnValueCapture));
6022
6023 return CallCapture(gl::EntryPoint::IsVertexArrayOES, std::move(paramBuffer));
6024 }
6025
CaptureFramebufferTextureMultiviewOVR(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level,GLint baseViewIndex,GLsizei numViews)6026 CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
6027 bool isCallValid,
6028 GLenum target,
6029 GLenum attachment,
6030 TextureID texturePacked,
6031 GLint level,
6032 GLint baseViewIndex,
6033 GLsizei numViews)
6034 {
6035 ParamBuffer paramBuffer;
6036
6037 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
6038 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
6039 attachment);
6040 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
6041 paramBuffer.addValueParam("level", ParamType::TGLint, level);
6042 paramBuffer.addValueParam("baseViewIndex", ParamType::TGLint, baseViewIndex);
6043 paramBuffer.addValueParam("numViews", ParamType::TGLsizei, numViews);
6044
6045 return CallCapture(gl::EntryPoint::FramebufferTextureMultiviewOVR, std::move(paramBuffer));
6046 }
6047
6048 } // namespace gl
6049