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