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_3_0_autogen.cpp:
9 // Capture functions for the OpenGL ES 3.0 entry points.
10
11 #include "libANGLE/capture_gles_3_0_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/FrameCapture.h"
15 #include "libANGLE/gl_enum_utils_autogen.h"
16 #include "libANGLE/validationES3.h"
17
18 using namespace angle;
19
20 namespace gl
21 {
22
CaptureBeginQuery(const Context * context,bool isCallValid,QueryType targetPacked,GLuint id)23 CallCapture CaptureBeginQuery(const Context *context,
24 bool isCallValid,
25 QueryType targetPacked,
26 GLuint id)
27 {
28 ParamBuffer paramBuffer;
29
30 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
31 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
32
33 return CallCapture(gl::EntryPoint::BeginQuery, std::move(paramBuffer));
34 }
35
CaptureBeginTransformFeedback(const Context * context,bool isCallValid,PrimitiveMode primitiveModePacked)36 CallCapture CaptureBeginTransformFeedback(const Context *context,
37 bool isCallValid,
38 PrimitiveMode primitiveModePacked)
39 {
40 ParamBuffer paramBuffer;
41
42 paramBuffer.addValueParam("primitiveModePacked", ParamType::TPrimitiveMode,
43 primitiveModePacked);
44
45 return CallCapture(gl::EntryPoint::BeginTransformFeedback, std::move(paramBuffer));
46 }
47
CaptureBindBufferBase(const Context * context,bool isCallValid,BufferBinding targetPacked,GLuint index,BufferID bufferPacked)48 CallCapture CaptureBindBufferBase(const Context *context,
49 bool isCallValid,
50 BufferBinding targetPacked,
51 GLuint index,
52 BufferID bufferPacked)
53 {
54 ParamBuffer paramBuffer;
55
56 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
57 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
58 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
59
60 return CallCapture(gl::EntryPoint::BindBufferBase, std::move(paramBuffer));
61 }
62
CaptureBindBufferRange(const Context * context,bool isCallValid,BufferBinding targetPacked,GLuint index,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)63 CallCapture CaptureBindBufferRange(const Context *context,
64 bool isCallValid,
65 BufferBinding targetPacked,
66 GLuint index,
67 BufferID bufferPacked,
68 GLintptr offset,
69 GLsizeiptr size)
70 {
71 ParamBuffer paramBuffer;
72
73 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
74 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
75 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
76 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
77 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
78
79 return CallCapture(gl::EntryPoint::BindBufferRange, std::move(paramBuffer));
80 }
81
CaptureBindSampler(const Context * context,bool isCallValid,GLuint unit,GLuint sampler)82 CallCapture CaptureBindSampler(const Context *context,
83 bool isCallValid,
84 GLuint unit,
85 GLuint sampler)
86 {
87 ParamBuffer paramBuffer;
88
89 paramBuffer.addValueParam("unit", ParamType::TGLuint, unit);
90 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
91
92 return CallCapture(gl::EntryPoint::BindSampler, std::move(paramBuffer));
93 }
94
CaptureBindTransformFeedback(const Context * context,bool isCallValid,GLenum target,GLuint id)95 CallCapture CaptureBindTransformFeedback(const Context *context,
96 bool isCallValid,
97 GLenum target,
98 GLuint id)
99 {
100 ParamBuffer paramBuffer;
101
102 paramBuffer.addEnumParam("target", GLenumGroup::BindTransformFeedbackTarget, ParamType::TGLenum,
103 target);
104 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
105
106 return CallCapture(gl::EntryPoint::BindTransformFeedback, std::move(paramBuffer));
107 }
108
CaptureBindVertexArray(const Context * context,bool isCallValid,GLuint array)109 CallCapture CaptureBindVertexArray(const Context *context, bool isCallValid, GLuint array)
110 {
111 ParamBuffer paramBuffer;
112
113 paramBuffer.addValueParam("array", ParamType::TGLuint, array);
114
115 return CallCapture(gl::EntryPoint::BindVertexArray, std::move(paramBuffer));
116 }
117
CaptureBlitFramebuffer(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)118 CallCapture CaptureBlitFramebuffer(const Context *context,
119 bool isCallValid,
120 GLint srcX0,
121 GLint srcY0,
122 GLint srcX1,
123 GLint srcY1,
124 GLint dstX0,
125 GLint dstY0,
126 GLint dstX1,
127 GLint dstY1,
128 GLbitfield mask,
129 GLenum filter)
130 {
131 ParamBuffer paramBuffer;
132
133 paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
134 paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
135 paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
136 paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
137 paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
138 paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
139 paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
140 paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
141 paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask);
142 paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum,
143 filter);
144
145 return CallCapture(gl::EntryPoint::BlitFramebuffer, std::move(paramBuffer));
146 }
147
CaptureClearBufferfi(const Context * context,bool isCallValid,GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil)148 CallCapture CaptureClearBufferfi(const Context *context,
149 bool isCallValid,
150 GLenum buffer,
151 GLint drawbuffer,
152 GLfloat depth,
153 GLint stencil)
154 {
155 ParamBuffer paramBuffer;
156
157 paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
158 paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
159 paramBuffer.addValueParam("depth", ParamType::TGLfloat, depth);
160 paramBuffer.addValueParam("stencil", ParamType::TGLint, stencil);
161
162 return CallCapture(gl::EntryPoint::ClearBufferfi, std::move(paramBuffer));
163 }
164
CaptureClearBufferfv(const Context * context,bool isCallValid,GLenum buffer,GLint drawbuffer,const GLfloat * value)165 CallCapture CaptureClearBufferfv(const Context *context,
166 bool isCallValid,
167 GLenum buffer,
168 GLint drawbuffer,
169 const GLfloat *value)
170 {
171 ParamBuffer paramBuffer;
172
173 paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
174 paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
175
176 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
177 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
178 CaptureClearBufferfv_value(context, isCallValid, buffer, drawbuffer, value, &valueParam);
179 paramBuffer.addParam(std::move(valueParam));
180
181 return CallCapture(gl::EntryPoint::ClearBufferfv, std::move(paramBuffer));
182 }
183
CaptureClearBufferiv(const Context * context,bool isCallValid,GLenum buffer,GLint drawbuffer,const GLint * value)184 CallCapture CaptureClearBufferiv(const Context *context,
185 bool isCallValid,
186 GLenum buffer,
187 GLint drawbuffer,
188 const GLint *value)
189 {
190 ParamBuffer paramBuffer;
191
192 paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
193 paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
194
195 ParamCapture valueParam("value", ParamType::TGLintConstPointer);
196 InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
197 CaptureClearBufferiv_value(context, isCallValid, buffer, drawbuffer, value, &valueParam);
198 paramBuffer.addParam(std::move(valueParam));
199
200 return CallCapture(gl::EntryPoint::ClearBufferiv, std::move(paramBuffer));
201 }
202
CaptureClearBufferuiv(const Context * context,bool isCallValid,GLenum buffer,GLint drawbuffer,const GLuint * value)203 CallCapture CaptureClearBufferuiv(const Context *context,
204 bool isCallValid,
205 GLenum buffer,
206 GLint drawbuffer,
207 const GLuint *value)
208 {
209 ParamBuffer paramBuffer;
210
211 paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
212 paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
213
214 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
215 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
216 CaptureClearBufferuiv_value(context, isCallValid, buffer, drawbuffer, value, &valueParam);
217 paramBuffer.addParam(std::move(valueParam));
218
219 return CallCapture(gl::EntryPoint::ClearBufferuiv, std::move(paramBuffer));
220 }
221
CaptureClientWaitSync(const Context * context,bool isCallValid,GLsync sync,GLbitfield flags,GLuint64 timeout,GLenum returnValue)222 CallCapture CaptureClientWaitSync(const Context *context,
223 bool isCallValid,
224 GLsync sync,
225 GLbitfield flags,
226 GLuint64 timeout,
227 GLenum returnValue)
228 {
229 ParamBuffer paramBuffer;
230
231 paramBuffer.addValueParam("sync", ParamType::TGLsync, sync);
232 paramBuffer.addEnumParam("flags", GLenumGroup::SyncObjectMask, ParamType::TGLbitfield, flags);
233 paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout);
234
235 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
236 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
237 paramBuffer.addReturnValue(std::move(returnValueCapture));
238
239 return CallCapture(gl::EntryPoint::ClientWaitSync, std::move(paramBuffer));
240 }
241
CaptureCompressedTexImage3D(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)242 CallCapture CaptureCompressedTexImage3D(const Context *context,
243 bool isCallValid,
244 TextureTarget targetPacked,
245 GLint level,
246 GLenum internalformat,
247 GLsizei width,
248 GLsizei height,
249 GLsizei depth,
250 GLint border,
251 GLsizei imageSize,
252 const void *data)
253 {
254 ParamBuffer paramBuffer;
255
256 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
257 paramBuffer.addValueParam("level", ParamType::TGLint, level);
258 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
259 internalformat);
260 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
261 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
262 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
263 paramBuffer.addValueParam("border", ParamType::TGLint, border);
264 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
265
266 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
267 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
268 CaptureCompressedTexImage3D_data(context, isCallValid, targetPacked, level, internalformat,
269 width, height, depth, border, imageSize, data, &dataParam);
270 paramBuffer.addParam(std::move(dataParam));
271
272 return CallCapture(gl::EntryPoint::CompressedTexImage3D, std::move(paramBuffer));
273 }
274
CaptureCompressedTexSubImage3D(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)275 CallCapture CaptureCompressedTexSubImage3D(const Context *context,
276 bool isCallValid,
277 TextureTarget targetPacked,
278 GLint level,
279 GLint xoffset,
280 GLint yoffset,
281 GLint zoffset,
282 GLsizei width,
283 GLsizei height,
284 GLsizei depth,
285 GLenum format,
286 GLsizei imageSize,
287 const void *data)
288 {
289 ParamBuffer paramBuffer;
290
291 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
292 paramBuffer.addValueParam("level", ParamType::TGLint, level);
293 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
294 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
295 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
296 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
297 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
298 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
299 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
300 paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
301
302 ParamCapture dataParam("data", ParamType::TvoidConstPointer);
303 InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
304 CaptureCompressedTexSubImage3D_data(context, isCallValid, targetPacked, level, xoffset, yoffset,
305 zoffset, width, height, depth, format, imageSize, data,
306 &dataParam);
307 paramBuffer.addParam(std::move(dataParam));
308
309 return CallCapture(gl::EntryPoint::CompressedTexSubImage3D, std::move(paramBuffer));
310 }
311
CaptureCopyBufferSubData(const Context * context,bool isCallValid,BufferBinding readTargetPacked,BufferBinding writeTargetPacked,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size)312 CallCapture CaptureCopyBufferSubData(const Context *context,
313 bool isCallValid,
314 BufferBinding readTargetPacked,
315 BufferBinding writeTargetPacked,
316 GLintptr readOffset,
317 GLintptr writeOffset,
318 GLsizeiptr size)
319 {
320 ParamBuffer paramBuffer;
321
322 paramBuffer.addValueParam("readTargetPacked", ParamType::TBufferBinding, readTargetPacked);
323 paramBuffer.addValueParam("writeTargetPacked", ParamType::TBufferBinding, writeTargetPacked);
324 paramBuffer.addValueParam("readOffset", ParamType::TGLintptr, readOffset);
325 paramBuffer.addValueParam("writeOffset", ParamType::TGLintptr, writeOffset);
326 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
327
328 return CallCapture(gl::EntryPoint::CopyBufferSubData, std::move(paramBuffer));
329 }
330
CaptureCopyTexSubImage3D(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)331 CallCapture CaptureCopyTexSubImage3D(const Context *context,
332 bool isCallValid,
333 TextureTarget targetPacked,
334 GLint level,
335 GLint xoffset,
336 GLint yoffset,
337 GLint zoffset,
338 GLint x,
339 GLint y,
340 GLsizei width,
341 GLsizei height)
342 {
343 ParamBuffer paramBuffer;
344
345 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
346 paramBuffer.addValueParam("level", ParamType::TGLint, level);
347 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
348 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
349 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
350 paramBuffer.addValueParam("x", ParamType::TGLint, x);
351 paramBuffer.addValueParam("y", ParamType::TGLint, y);
352 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
353 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
354
355 return CallCapture(gl::EntryPoint::CopyTexSubImage3D, std::move(paramBuffer));
356 }
357
CaptureDeleteQueries(const Context * context,bool isCallValid,GLsizei n,const GLuint * ids)358 CallCapture CaptureDeleteQueries(const Context *context,
359 bool isCallValid,
360 GLsizei n,
361 const GLuint *ids)
362 {
363 ParamBuffer paramBuffer;
364
365 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
366
367 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
368 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
369 CaptureDeleteQueries_ids(context, isCallValid, n, ids, &idsParam);
370 paramBuffer.addParam(std::move(idsParam));
371
372 return CallCapture(gl::EntryPoint::DeleteQueries, std::move(paramBuffer));
373 }
374
CaptureDeleteSamplers(const Context * context,bool isCallValid,GLsizei count,const GLuint * samplers)375 CallCapture CaptureDeleteSamplers(const Context *context,
376 bool isCallValid,
377 GLsizei count,
378 const GLuint *samplers)
379 {
380 ParamBuffer paramBuffer;
381
382 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
383
384 ParamCapture samplersParam("samplers", ParamType::TGLuintConstPointer);
385 InitParamValue(ParamType::TGLuintConstPointer, samplers, &samplersParam.value);
386 CaptureDeleteSamplers_samplers(context, isCallValid, count, samplers, &samplersParam);
387 paramBuffer.addParam(std::move(samplersParam));
388
389 return CallCapture(gl::EntryPoint::DeleteSamplers, std::move(paramBuffer));
390 }
391
CaptureDeleteSync(const Context * context,bool isCallValid,GLsync sync)392 CallCapture CaptureDeleteSync(const Context *context, bool isCallValid, GLsync sync)
393 {
394 ParamBuffer paramBuffer;
395
396 paramBuffer.addValueParam("sync", ParamType::TGLsync, sync);
397
398 return CallCapture(gl::EntryPoint::DeleteSync, std::move(paramBuffer));
399 }
400
CaptureDeleteTransformFeedbacks(const Context * context,bool isCallValid,GLsizei n,const GLuint * ids)401 CallCapture CaptureDeleteTransformFeedbacks(const Context *context,
402 bool isCallValid,
403 GLsizei n,
404 const GLuint *ids)
405 {
406 ParamBuffer paramBuffer;
407
408 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
409
410 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
411 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
412 CaptureDeleteTransformFeedbacks_ids(context, isCallValid, n, ids, &idsParam);
413 paramBuffer.addParam(std::move(idsParam));
414
415 return CallCapture(gl::EntryPoint::DeleteTransformFeedbacks, std::move(paramBuffer));
416 }
417
CaptureDeleteVertexArrays(const Context * context,bool isCallValid,GLsizei n,const GLuint * arrays)418 CallCapture CaptureDeleteVertexArrays(const Context *context,
419 bool isCallValid,
420 GLsizei n,
421 const GLuint *arrays)
422 {
423 ParamBuffer paramBuffer;
424
425 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
426
427 ParamCapture arraysParam("arrays", ParamType::TGLuintConstPointer);
428 InitParamValue(ParamType::TGLuintConstPointer, arrays, &arraysParam.value);
429 CaptureDeleteVertexArrays_arrays(context, isCallValid, n, arrays, &arraysParam);
430 paramBuffer.addParam(std::move(arraysParam));
431
432 return CallCapture(gl::EntryPoint::DeleteVertexArrays, std::move(paramBuffer));
433 }
434
CaptureDrawArraysInstanced(const Context * context,bool isCallValid,PrimitiveMode modePacked,GLint first,GLsizei count,GLsizei instancecount)435 CallCapture CaptureDrawArraysInstanced(const Context *context,
436 bool isCallValid,
437 PrimitiveMode modePacked,
438 GLint first,
439 GLsizei count,
440 GLsizei instancecount)
441 {
442 ParamBuffer paramBuffer;
443
444 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
445 paramBuffer.addValueParam("first", ParamType::TGLint, first);
446 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
447 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
448
449 return CallCapture(gl::EntryPoint::DrawArraysInstanced, std::move(paramBuffer));
450 }
451
CaptureDrawBuffers(const Context * context,bool isCallValid,GLsizei n,const GLenum * bufs)452 CallCapture CaptureDrawBuffers(const Context *context,
453 bool isCallValid,
454 GLsizei n,
455 const GLenum *bufs)
456 {
457 ParamBuffer paramBuffer;
458
459 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
460
461 ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
462 InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
463 CaptureDrawBuffers_bufs(context, isCallValid, n, bufs, &bufsParam);
464 paramBuffer.addParam(std::move(bufsParam));
465
466 return CallCapture(gl::EntryPoint::DrawBuffers, std::move(paramBuffer));
467 }
468
CaptureDrawElementsInstanced(const Context * context,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount)469 CallCapture CaptureDrawElementsInstanced(const Context *context,
470 bool isCallValid,
471 PrimitiveMode modePacked,
472 GLsizei count,
473 DrawElementsType typePacked,
474 const void *indices,
475 GLsizei instancecount)
476 {
477 ParamBuffer paramBuffer;
478
479 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
480 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
481 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
482
483 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
484 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
485 CaptureDrawElementsInstanced_indices(context, isCallValid, modePacked, count, typePacked,
486 indices, instancecount, &indicesParam);
487 paramBuffer.addParam(std::move(indicesParam));
488
489 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
490
491 return CallCapture(gl::EntryPoint::DrawElementsInstanced, std::move(paramBuffer));
492 }
493
CaptureDrawRangeElements(const Context * context,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices)494 CallCapture CaptureDrawRangeElements(const Context *context,
495 bool isCallValid,
496 PrimitiveMode modePacked,
497 GLuint start,
498 GLuint end,
499 GLsizei count,
500 DrawElementsType typePacked,
501 const void *indices)
502 {
503 ParamBuffer paramBuffer;
504
505 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
506 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
507 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
508 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
509 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
510
511 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
512 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
513 CaptureDrawRangeElements_indices(context, isCallValid, modePacked, start, end, count,
514 typePacked, indices, &indicesParam);
515 paramBuffer.addParam(std::move(indicesParam));
516
517 return CallCapture(gl::EntryPoint::DrawRangeElements, std::move(paramBuffer));
518 }
519
CaptureEndQuery(const Context * context,bool isCallValid,QueryType targetPacked)520 CallCapture CaptureEndQuery(const Context *context, bool isCallValid, QueryType targetPacked)
521 {
522 ParamBuffer paramBuffer;
523
524 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
525
526 return CallCapture(gl::EntryPoint::EndQuery, std::move(paramBuffer));
527 }
528
CaptureEndTransformFeedback(const Context * context,bool isCallValid)529 CallCapture CaptureEndTransformFeedback(const Context *context, bool isCallValid)
530 {
531 ParamBuffer paramBuffer;
532
533 return CallCapture(gl::EntryPoint::EndTransformFeedback, std::move(paramBuffer));
534 }
535
CaptureFenceSync(const Context * context,bool isCallValid,GLenum condition,GLbitfield flags,GLsync returnValue)536 CallCapture CaptureFenceSync(const Context *context,
537 bool isCallValid,
538 GLenum condition,
539 GLbitfield flags,
540 GLsync returnValue)
541 {
542 ParamBuffer paramBuffer;
543
544 paramBuffer.addEnumParam("condition", GLenumGroup::SyncCondition, ParamType::TGLenum,
545 condition);
546 paramBuffer.addEnumParam("flags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, flags);
547
548 ParamCapture returnValueCapture("returnValue", ParamType::TGLsync);
549 InitParamValue(ParamType::TGLsync, returnValue, &returnValueCapture.value);
550 paramBuffer.addReturnValue(std::move(returnValueCapture));
551
552 return CallCapture(gl::EntryPoint::FenceSync, std::move(paramBuffer));
553 }
554
CaptureFlushMappedBufferRange(const Context * context,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length)555 CallCapture CaptureFlushMappedBufferRange(const Context *context,
556 bool isCallValid,
557 BufferBinding targetPacked,
558 GLintptr offset,
559 GLsizeiptr length)
560 {
561 ParamBuffer paramBuffer;
562
563 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
564 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
565 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
566
567 return CallCapture(gl::EntryPoint::FlushMappedBufferRange, std::move(paramBuffer));
568 }
569
CaptureFramebufferTextureLayer(const Context * context,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level,GLint layer)570 CallCapture CaptureFramebufferTextureLayer(const Context *context,
571 bool isCallValid,
572 GLenum target,
573 GLenum attachment,
574 TextureID texturePacked,
575 GLint level,
576 GLint layer)
577 {
578 ParamBuffer paramBuffer;
579
580 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
581 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
582 attachment);
583 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
584 paramBuffer.addValueParam("level", ParamType::TGLint, level);
585 paramBuffer.addValueParam("layer", ParamType::TGLint, layer);
586
587 return CallCapture(gl::EntryPoint::FramebufferTextureLayer, std::move(paramBuffer));
588 }
589
CaptureGenQueries(const Context * context,bool isCallValid,GLsizei n,GLuint * ids)590 CallCapture CaptureGenQueries(const Context *context, bool isCallValid, GLsizei n, GLuint *ids)
591 {
592 ParamBuffer paramBuffer;
593
594 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
595
596 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
597 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
598 CaptureGenQueries_ids(context, isCallValid, n, ids, &idsParam);
599 paramBuffer.addParam(std::move(idsParam));
600
601 return CallCapture(gl::EntryPoint::GenQueries, std::move(paramBuffer));
602 }
603
CaptureGenSamplers(const Context * context,bool isCallValid,GLsizei count,GLuint * samplers)604 CallCapture CaptureGenSamplers(const Context *context,
605 bool isCallValid,
606 GLsizei count,
607 GLuint *samplers)
608 {
609 ParamBuffer paramBuffer;
610
611 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
612
613 ParamCapture samplersParam("samplers", ParamType::TGLuintPointer);
614 InitParamValue(ParamType::TGLuintPointer, samplers, &samplersParam.value);
615 CaptureGenSamplers_samplers(context, isCallValid, count, samplers, &samplersParam);
616 paramBuffer.addParam(std::move(samplersParam));
617
618 return CallCapture(gl::EntryPoint::GenSamplers, std::move(paramBuffer));
619 }
620
CaptureGenTransformFeedbacks(const Context * context,bool isCallValid,GLsizei n,GLuint * ids)621 CallCapture CaptureGenTransformFeedbacks(const Context *context,
622 bool isCallValid,
623 GLsizei n,
624 GLuint *ids)
625 {
626 ParamBuffer paramBuffer;
627
628 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
629
630 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
631 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
632 CaptureGenTransformFeedbacks_ids(context, isCallValid, n, ids, &idsParam);
633 paramBuffer.addParam(std::move(idsParam));
634
635 return CallCapture(gl::EntryPoint::GenTransformFeedbacks, std::move(paramBuffer));
636 }
637
CaptureGenVertexArrays(const Context * context,bool isCallValid,GLsizei n,GLuint * arrays)638 CallCapture CaptureGenVertexArrays(const Context *context,
639 bool isCallValid,
640 GLsizei n,
641 GLuint *arrays)
642 {
643 ParamBuffer paramBuffer;
644
645 paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
646
647 ParamCapture arraysParam("arrays", ParamType::TGLuintPointer);
648 InitParamValue(ParamType::TGLuintPointer, arrays, &arraysParam.value);
649 CaptureGenVertexArrays_arrays(context, isCallValid, n, arrays, &arraysParam);
650 paramBuffer.addParam(std::move(arraysParam));
651
652 return CallCapture(gl::EntryPoint::GenVertexArrays, std::move(paramBuffer));
653 }
654
CaptureGetActiveUniformBlockName(const Context * context,bool isCallValid,GLuint program,GLuint uniformBlockIndex,GLsizei bufSize,GLsizei * length,GLchar * uniformBlockName)655 CallCapture CaptureGetActiveUniformBlockName(const Context *context,
656 bool isCallValid,
657 GLuint program,
658 GLuint uniformBlockIndex,
659 GLsizei bufSize,
660 GLsizei *length,
661 GLchar *uniformBlockName)
662 {
663 ParamBuffer paramBuffer;
664
665 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
666 paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
667 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
668
669 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
670 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
671 CaptureGetActiveUniformBlockName_length(context, isCallValid, program, uniformBlockIndex,
672 bufSize, length, uniformBlockName, &lengthParam);
673 paramBuffer.addParam(std::move(lengthParam));
674
675 ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharPointer);
676 InitParamValue(ParamType::TGLcharPointer, uniformBlockName, &uniformBlockNameParam.value);
677 CaptureGetActiveUniformBlockName_uniformBlockName(context, isCallValid, program,
678 uniformBlockIndex, bufSize, length,
679 uniformBlockName, &uniformBlockNameParam);
680 paramBuffer.addParam(std::move(uniformBlockNameParam));
681
682 return CallCapture(gl::EntryPoint::GetActiveUniformBlockName, std::move(paramBuffer));
683 }
684
CaptureGetActiveUniformBlockiv(const Context * context,bool isCallValid,GLuint program,GLuint uniformBlockIndex,GLenum pname,GLint * params)685 CallCapture CaptureGetActiveUniformBlockiv(const Context *context,
686 bool isCallValid,
687 GLuint program,
688 GLuint uniformBlockIndex,
689 GLenum pname,
690 GLint *params)
691 {
692 ParamBuffer paramBuffer;
693
694 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
695 paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
696 paramBuffer.addEnumParam("pname", GLenumGroup::UniformBlockPName, ParamType::TGLenum, pname);
697
698 ParamCapture paramsParam("params", ParamType::TGLintPointer);
699 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
700 CaptureGetActiveUniformBlockiv_params(context, isCallValid, program, uniformBlockIndex, pname,
701 params, ¶msParam);
702 paramBuffer.addParam(std::move(paramsParam));
703
704 return CallCapture(gl::EntryPoint::GetActiveUniformBlockiv, std::move(paramBuffer));
705 }
706
CaptureGetActiveUniformsiv(const Context * context,bool isCallValid,GLuint program,GLsizei uniformCount,const GLuint * uniformIndices,GLenum pname,GLint * params)707 CallCapture CaptureGetActiveUniformsiv(const Context *context,
708 bool isCallValid,
709 GLuint program,
710 GLsizei uniformCount,
711 const GLuint *uniformIndices,
712 GLenum pname,
713 GLint *params)
714 {
715 ParamBuffer paramBuffer;
716
717 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
718 paramBuffer.addValueParam("uniformCount", ParamType::TGLsizei, uniformCount);
719
720 ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintConstPointer);
721 InitParamValue(ParamType::TGLuintConstPointer, uniformIndices, &uniformIndicesParam.value);
722 CaptureGetActiveUniformsiv_uniformIndices(context, isCallValid, program, uniformCount,
723 uniformIndices, pname, params, &uniformIndicesParam);
724 paramBuffer.addParam(std::move(uniformIndicesParam));
725
726 paramBuffer.addEnumParam("pname", GLenumGroup::UniformPName, ParamType::TGLenum, pname);
727
728 ParamCapture paramsParam("params", ParamType::TGLintPointer);
729 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
730 CaptureGetActiveUniformsiv_params(context, isCallValid, program, uniformCount, uniformIndices,
731 pname, params, ¶msParam);
732 paramBuffer.addParam(std::move(paramsParam));
733
734 return CallCapture(gl::EntryPoint::GetActiveUniformsiv, std::move(paramBuffer));
735 }
736
CaptureGetBufferParameteri64v(const Context * context,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLint64 * params)737 CallCapture CaptureGetBufferParameteri64v(const Context *context,
738 bool isCallValid,
739 BufferBinding targetPacked,
740 GLenum pname,
741 GLint64 *params)
742 {
743 ParamBuffer paramBuffer;
744
745 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
746 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
747
748 ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
749 InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value);
750 CaptureGetBufferParameteri64v_params(context, isCallValid, targetPacked, pname, params,
751 ¶msParam);
752 paramBuffer.addParam(std::move(paramsParam));
753
754 return CallCapture(gl::EntryPoint::GetBufferParameteri64v, std::move(paramBuffer));
755 }
756
CaptureGetBufferPointerv(const Context * context,bool isCallValid,BufferBinding targetPacked,GLenum pname,void ** params)757 CallCapture CaptureGetBufferPointerv(const Context *context,
758 bool isCallValid,
759 BufferBinding targetPacked,
760 GLenum pname,
761 void **params)
762 {
763 ParamBuffer paramBuffer;
764
765 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
766 paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
767
768 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
769 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
770 CaptureGetBufferPointerv_params(context, isCallValid, targetPacked, pname, params,
771 ¶msParam);
772 paramBuffer.addParam(std::move(paramsParam));
773
774 return CallCapture(gl::EntryPoint::GetBufferPointerv, std::move(paramBuffer));
775 }
776
CaptureGetFragDataLocation(const Context * context,bool isCallValid,GLuint program,const GLchar * name,GLint returnValue)777 CallCapture CaptureGetFragDataLocation(const Context *context,
778 bool isCallValid,
779 GLuint program,
780 const GLchar *name,
781 GLint returnValue)
782 {
783 ParamBuffer paramBuffer;
784
785 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
786
787 ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
788 InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
789 CaptureGetFragDataLocation_name(context, isCallValid, program, name, &nameParam);
790 paramBuffer.addParam(std::move(nameParam));
791
792 ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
793 InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
794 paramBuffer.addReturnValue(std::move(returnValueCapture));
795
796 return CallCapture(gl::EntryPoint::GetFragDataLocation, std::move(paramBuffer));
797 }
798
CaptureGetInteger64i_v(const Context * context,bool isCallValid,GLenum target,GLuint index,GLint64 * data)799 CallCapture CaptureGetInteger64i_v(const Context *context,
800 bool isCallValid,
801 GLenum target,
802 GLuint index,
803 GLint64 *data)
804 {
805 ParamBuffer paramBuffer;
806
807 paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target);
808 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
809
810 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
811 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
812 CaptureGetInteger64i_v_data(context, isCallValid, target, index, data, &dataParam);
813 paramBuffer.addParam(std::move(dataParam));
814
815 return CallCapture(gl::EntryPoint::GetInteger64i_v, std::move(paramBuffer));
816 }
817
CaptureGetInteger64v(const Context * context,bool isCallValid,GLenum pname,GLint64 * data)818 CallCapture CaptureGetInteger64v(const Context *context,
819 bool isCallValid,
820 GLenum pname,
821 GLint64 *data)
822 {
823 ParamBuffer paramBuffer;
824
825 paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
826
827 ParamCapture dataParam("data", ParamType::TGLint64Pointer);
828 InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
829 CaptureGetInteger64v_data(context, isCallValid, pname, data, &dataParam);
830 paramBuffer.addParam(std::move(dataParam));
831
832 return CallCapture(gl::EntryPoint::GetInteger64v, std::move(paramBuffer));
833 }
834
CaptureGetIntegeri_v(const Context * context,bool isCallValid,GLenum target,GLuint index,GLint * data)835 CallCapture CaptureGetIntegeri_v(const Context *context,
836 bool isCallValid,
837 GLenum target,
838 GLuint index,
839 GLint *data)
840 {
841 ParamBuffer paramBuffer;
842
843 paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target);
844 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
845
846 ParamCapture dataParam("data", ParamType::TGLintPointer);
847 InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
848 CaptureGetIntegeri_v_data(context, isCallValid, target, index, data, &dataParam);
849 paramBuffer.addParam(std::move(dataParam));
850
851 return CallCapture(gl::EntryPoint::GetIntegeri_v, std::move(paramBuffer));
852 }
853
CaptureGetInternalformativ(const Context * context,bool isCallValid,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint * params)854 CallCapture CaptureGetInternalformativ(const Context *context,
855 bool isCallValid,
856 GLenum target,
857 GLenum internalformat,
858 GLenum pname,
859 GLsizei bufSize,
860 GLint *params)
861 {
862 ParamBuffer paramBuffer;
863
864 paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target);
865 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
866 internalformat);
867 paramBuffer.addEnumParam("pname", GLenumGroup::InternalFormatPName, ParamType::TGLenum, pname);
868 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
869
870 ParamCapture paramsParam("params", ParamType::TGLintPointer);
871 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
872 CaptureGetInternalformativ_params(context, isCallValid, target, internalformat, pname, bufSize,
873 params, ¶msParam);
874 paramBuffer.addParam(std::move(paramsParam));
875
876 return CallCapture(gl::EntryPoint::GetInternalformativ, std::move(paramBuffer));
877 }
878
CaptureGetProgramBinary(const Context * context,bool isCallValid,GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)879 CallCapture CaptureGetProgramBinary(const Context *context,
880 bool isCallValid,
881 GLuint program,
882 GLsizei bufSize,
883 GLsizei *length,
884 GLenum *binaryFormat,
885 void *binary)
886 {
887 ParamBuffer paramBuffer;
888
889 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
890 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
891
892 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
893 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
894 CaptureGetProgramBinary_length(context, isCallValid, program, bufSize, length, binaryFormat,
895 binary, &lengthParam);
896 paramBuffer.addParam(std::move(lengthParam));
897
898 ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
899 InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
900 CaptureGetProgramBinary_binaryFormat(context, isCallValid, program, bufSize, length,
901 binaryFormat, binary, &binaryFormatParam);
902 paramBuffer.addParam(std::move(binaryFormatParam));
903
904 ParamCapture binaryParam("binary", ParamType::TvoidPointer);
905 InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
906 CaptureGetProgramBinary_binary(context, isCallValid, program, bufSize, length, binaryFormat,
907 binary, &binaryParam);
908 paramBuffer.addParam(std::move(binaryParam));
909
910 return CallCapture(gl::EntryPoint::GetProgramBinary, std::move(paramBuffer));
911 }
912
CaptureGetQueryObjectuiv(const Context * context,bool isCallValid,GLuint id,GLenum pname,GLuint * params)913 CallCapture CaptureGetQueryObjectuiv(const Context *context,
914 bool isCallValid,
915 GLuint id,
916 GLenum pname,
917 GLuint *params)
918 {
919 ParamBuffer paramBuffer;
920
921 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
922 paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
923 pname);
924
925 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
926 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
927 CaptureGetQueryObjectuiv_params(context, isCallValid, id, pname, params, ¶msParam);
928 paramBuffer.addParam(std::move(paramsParam));
929
930 return CallCapture(gl::EntryPoint::GetQueryObjectuiv, std::move(paramBuffer));
931 }
932
CaptureGetQueryiv(const Context * context,bool isCallValid,QueryType targetPacked,GLenum pname,GLint * params)933 CallCapture CaptureGetQueryiv(const Context *context,
934 bool isCallValid,
935 QueryType targetPacked,
936 GLenum pname,
937 GLint *params)
938 {
939 ParamBuffer paramBuffer;
940
941 paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
942 paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname);
943
944 ParamCapture paramsParam("params", ParamType::TGLintPointer);
945 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
946 CaptureGetQueryiv_params(context, isCallValid, targetPacked, pname, params, ¶msParam);
947 paramBuffer.addParam(std::move(paramsParam));
948
949 return CallCapture(gl::EntryPoint::GetQueryiv, std::move(paramBuffer));
950 }
951
CaptureGetSamplerParameterfv(const Context * context,bool isCallValid,GLuint sampler,GLenum pname,GLfloat * params)952 CallCapture CaptureGetSamplerParameterfv(const Context *context,
953 bool isCallValid,
954 GLuint sampler,
955 GLenum pname,
956 GLfloat *params)
957 {
958 ParamBuffer paramBuffer;
959
960 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
961 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
962
963 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
964 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
965 CaptureGetSamplerParameterfv_params(context, isCallValid, sampler, pname, params, ¶msParam);
966 paramBuffer.addParam(std::move(paramsParam));
967
968 return CallCapture(gl::EntryPoint::GetSamplerParameterfv, std::move(paramBuffer));
969 }
970
CaptureGetSamplerParameteriv(const Context * context,bool isCallValid,GLuint sampler,GLenum pname,GLint * params)971 CallCapture CaptureGetSamplerParameteriv(const Context *context,
972 bool isCallValid,
973 GLuint sampler,
974 GLenum pname,
975 GLint *params)
976 {
977 ParamBuffer paramBuffer;
978
979 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
980 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
981
982 ParamCapture paramsParam("params", ParamType::TGLintPointer);
983 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
984 CaptureGetSamplerParameteriv_params(context, isCallValid, sampler, pname, params, ¶msParam);
985 paramBuffer.addParam(std::move(paramsParam));
986
987 return CallCapture(gl::EntryPoint::GetSamplerParameteriv, std::move(paramBuffer));
988 }
989
CaptureGetStringi(const Context * context,bool isCallValid,GLenum name,GLuint index,const GLubyte * returnValue)990 CallCapture CaptureGetStringi(const Context *context,
991 bool isCallValid,
992 GLenum name,
993 GLuint index,
994 const GLubyte *returnValue)
995 {
996 ParamBuffer paramBuffer;
997
998 paramBuffer.addEnumParam("name", GLenumGroup::StringName, ParamType::TGLenum, name);
999 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1000
1001 ParamCapture returnValueCapture("returnValue", ParamType::TGLubyteConstPointer);
1002 InitParamValue(ParamType::TGLubyteConstPointer, returnValue, &returnValueCapture.value);
1003 paramBuffer.addReturnValue(std::move(returnValueCapture));
1004
1005 return CallCapture(gl::EntryPoint::GetStringi, std::move(paramBuffer));
1006 }
1007
CaptureGetSynciv(const Context * context,bool isCallValid,GLsync sync,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * values)1008 CallCapture CaptureGetSynciv(const Context *context,
1009 bool isCallValid,
1010 GLsync sync,
1011 GLenum pname,
1012 GLsizei bufSize,
1013 GLsizei *length,
1014 GLint *values)
1015 {
1016 ParamBuffer paramBuffer;
1017
1018 paramBuffer.addValueParam("sync", ParamType::TGLsync, sync);
1019 paramBuffer.addEnumParam("pname", GLenumGroup::SyncParameterName, ParamType::TGLenum, pname);
1020 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1021
1022 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1023 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1024 CaptureGetSynciv_length(context, isCallValid, sync, pname, bufSize, length, values,
1025 &lengthParam);
1026 paramBuffer.addParam(std::move(lengthParam));
1027
1028 ParamCapture valuesParam("values", ParamType::TGLintPointer);
1029 InitParamValue(ParamType::TGLintPointer, values, &valuesParam.value);
1030 CaptureGetSynciv_values(context, isCallValid, sync, pname, bufSize, length, values,
1031 &valuesParam);
1032 paramBuffer.addParam(std::move(valuesParam));
1033
1034 return CallCapture(gl::EntryPoint::GetSynciv, std::move(paramBuffer));
1035 }
1036
CaptureGetTransformFeedbackVarying(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLsizei * size,GLenum * type,GLchar * name)1037 CallCapture CaptureGetTransformFeedbackVarying(const Context *context,
1038 bool isCallValid,
1039 GLuint program,
1040 GLuint index,
1041 GLsizei bufSize,
1042 GLsizei *length,
1043 GLsizei *size,
1044 GLenum *type,
1045 GLchar *name)
1046 {
1047 ParamBuffer paramBuffer;
1048
1049 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1050 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1051 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
1052
1053 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
1054 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
1055 CaptureGetTransformFeedbackVarying_length(context, isCallValid, program, index, bufSize, length,
1056 size, type, name, &lengthParam);
1057 paramBuffer.addParam(std::move(lengthParam));
1058
1059 ParamCapture sizeParam("size", ParamType::TGLsizeiPointer);
1060 InitParamValue(ParamType::TGLsizeiPointer, size, &sizeParam.value);
1061 CaptureGetTransformFeedbackVarying_size(context, isCallValid, program, index, bufSize, length,
1062 size, type, name, &sizeParam);
1063 paramBuffer.addParam(std::move(sizeParam));
1064
1065 ParamCapture typeParam("type", ParamType::TGLenumPointer);
1066 InitParamValue(ParamType::TGLenumPointer, type, &typeParam.value);
1067 CaptureGetTransformFeedbackVarying_type(context, isCallValid, program, index, bufSize, length,
1068 size, type, name, &typeParam);
1069 paramBuffer.addParam(std::move(typeParam));
1070
1071 ParamCapture nameParam("name", ParamType::TGLcharPointer);
1072 InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
1073 CaptureGetTransformFeedbackVarying_name(context, isCallValid, program, index, bufSize, length,
1074 size, type, name, &nameParam);
1075 paramBuffer.addParam(std::move(nameParam));
1076
1077 return CallCapture(gl::EntryPoint::GetTransformFeedbackVarying, std::move(paramBuffer));
1078 }
1079
CaptureGetUniformBlockIndex(const Context * context,bool isCallValid,GLuint program,const GLchar * uniformBlockName,GLuint returnValue)1080 CallCapture CaptureGetUniformBlockIndex(const Context *context,
1081 bool isCallValid,
1082 GLuint program,
1083 const GLchar *uniformBlockName,
1084 GLuint returnValue)
1085 {
1086 ParamBuffer paramBuffer;
1087
1088 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1089
1090 ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharConstPointer);
1091 InitParamValue(ParamType::TGLcharConstPointer, uniformBlockName, &uniformBlockNameParam.value);
1092 CaptureGetUniformBlockIndex_uniformBlockName(context, isCallValid, program, uniformBlockName,
1093 &uniformBlockNameParam);
1094 paramBuffer.addParam(std::move(uniformBlockNameParam));
1095
1096 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
1097 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
1098 paramBuffer.addReturnValue(std::move(returnValueCapture));
1099
1100 return CallCapture(gl::EntryPoint::GetUniformBlockIndex, std::move(paramBuffer));
1101 }
1102
CaptureGetUniformIndices(const Context * context,bool isCallValid,GLuint program,GLsizei uniformCount,const GLchar * const * uniformNames,GLuint * uniformIndices)1103 CallCapture CaptureGetUniformIndices(const Context *context,
1104 bool isCallValid,
1105 GLuint program,
1106 GLsizei uniformCount,
1107 const GLchar *const *uniformNames,
1108 GLuint *uniformIndices)
1109 {
1110 ParamBuffer paramBuffer;
1111
1112 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1113 paramBuffer.addValueParam("uniformCount", ParamType::TGLsizei, uniformCount);
1114
1115 ParamCapture uniformNamesParam("uniformNames", ParamType::TGLcharConstPointerPointer);
1116 InitParamValue(ParamType::TGLcharConstPointerPointer, uniformNames, &uniformNamesParam.value);
1117 CaptureGetUniformIndices_uniformNames(context, isCallValid, program, uniformCount, uniformNames,
1118 uniformIndices, &uniformNamesParam);
1119 paramBuffer.addParam(std::move(uniformNamesParam));
1120
1121 ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintPointer);
1122 InitParamValue(ParamType::TGLuintPointer, uniformIndices, &uniformIndicesParam.value);
1123 CaptureGetUniformIndices_uniformIndices(context, isCallValid, program, uniformCount,
1124 uniformNames, uniformIndices, &uniformIndicesParam);
1125 paramBuffer.addParam(std::move(uniformIndicesParam));
1126
1127 return CallCapture(gl::EntryPoint::GetUniformIndices, std::move(paramBuffer));
1128 }
1129
CaptureGetUniformuiv(const Context * context,bool isCallValid,GLuint program,GLint location,GLuint * params)1130 CallCapture CaptureGetUniformuiv(const Context *context,
1131 bool isCallValid,
1132 GLuint program,
1133 GLint location,
1134 GLuint *params)
1135 {
1136 ParamBuffer paramBuffer;
1137
1138 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1139 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1140
1141 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
1142 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
1143 CaptureGetUniformuiv_params(context, isCallValid, program, location, params, ¶msParam);
1144 paramBuffer.addParam(std::move(paramsParam));
1145
1146 return CallCapture(gl::EntryPoint::GetUniformuiv, std::move(paramBuffer));
1147 }
1148
CaptureGetVertexAttribIiv(const Context * context,bool isCallValid,GLuint index,GLenum pname,GLint * params)1149 CallCapture CaptureGetVertexAttribIiv(const Context *context,
1150 bool isCallValid,
1151 GLuint index,
1152 GLenum pname,
1153 GLint *params)
1154 {
1155 ParamBuffer paramBuffer;
1156
1157 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1158 paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname);
1159
1160 ParamCapture paramsParam("params", ParamType::TGLintPointer);
1161 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
1162 CaptureGetVertexAttribIiv_params(context, isCallValid, index, pname, params, ¶msParam);
1163 paramBuffer.addParam(std::move(paramsParam));
1164
1165 return CallCapture(gl::EntryPoint::GetVertexAttribIiv, std::move(paramBuffer));
1166 }
1167
CaptureGetVertexAttribIuiv(const Context * context,bool isCallValid,GLuint index,GLenum pname,GLuint * params)1168 CallCapture CaptureGetVertexAttribIuiv(const Context *context,
1169 bool isCallValid,
1170 GLuint index,
1171 GLenum pname,
1172 GLuint *params)
1173 {
1174 ParamBuffer paramBuffer;
1175
1176 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1177 paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname);
1178
1179 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
1180 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
1181 CaptureGetVertexAttribIuiv_params(context, isCallValid, index, pname, params, ¶msParam);
1182 paramBuffer.addParam(std::move(paramsParam));
1183
1184 return CallCapture(gl::EntryPoint::GetVertexAttribIuiv, std::move(paramBuffer));
1185 }
1186
CaptureInvalidateFramebuffer(const Context * context,bool isCallValid,GLenum target,GLsizei numAttachments,const GLenum * attachments)1187 CallCapture CaptureInvalidateFramebuffer(const Context *context,
1188 bool isCallValid,
1189 GLenum target,
1190 GLsizei numAttachments,
1191 const GLenum *attachments)
1192 {
1193 ParamBuffer paramBuffer;
1194
1195 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
1196 paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
1197
1198 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
1199 InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
1200 CaptureInvalidateFramebuffer_attachments(context, isCallValid, target, numAttachments,
1201 attachments, &attachmentsParam);
1202 paramBuffer.addParam(std::move(attachmentsParam));
1203
1204 return CallCapture(gl::EntryPoint::InvalidateFramebuffer, std::move(paramBuffer));
1205 }
1206
CaptureInvalidateSubFramebuffer(const Context * context,bool isCallValid,GLenum target,GLsizei numAttachments,const GLenum * attachments,GLint x,GLint y,GLsizei width,GLsizei height)1207 CallCapture CaptureInvalidateSubFramebuffer(const Context *context,
1208 bool isCallValid,
1209 GLenum target,
1210 GLsizei numAttachments,
1211 const GLenum *attachments,
1212 GLint x,
1213 GLint y,
1214 GLsizei width,
1215 GLsizei height)
1216 {
1217 ParamBuffer paramBuffer;
1218
1219 paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
1220 paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
1221
1222 ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
1223 InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
1224 CaptureInvalidateSubFramebuffer_attachments(context, isCallValid, target, numAttachments,
1225 attachments, x, y, width, height,
1226 &attachmentsParam);
1227 paramBuffer.addParam(std::move(attachmentsParam));
1228
1229 paramBuffer.addValueParam("x", ParamType::TGLint, x);
1230 paramBuffer.addValueParam("y", ParamType::TGLint, y);
1231 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1232 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1233
1234 return CallCapture(gl::EntryPoint::InvalidateSubFramebuffer, std::move(paramBuffer));
1235 }
1236
CaptureIsQuery(const Context * context,bool isCallValid,GLuint id,GLboolean returnValue)1237 CallCapture CaptureIsQuery(const Context *context,
1238 bool isCallValid,
1239 GLuint id,
1240 GLboolean returnValue)
1241 {
1242 ParamBuffer paramBuffer;
1243
1244 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
1245
1246 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
1247 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
1248 paramBuffer.addReturnValue(std::move(returnValueCapture));
1249
1250 return CallCapture(gl::EntryPoint::IsQuery, std::move(paramBuffer));
1251 }
1252
CaptureIsSampler(const Context * context,bool isCallValid,GLuint sampler,GLboolean returnValue)1253 CallCapture CaptureIsSampler(const Context *context,
1254 bool isCallValid,
1255 GLuint sampler,
1256 GLboolean returnValue)
1257 {
1258 ParamBuffer paramBuffer;
1259
1260 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
1261
1262 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
1263 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
1264 paramBuffer.addReturnValue(std::move(returnValueCapture));
1265
1266 return CallCapture(gl::EntryPoint::IsSampler, std::move(paramBuffer));
1267 }
1268
CaptureIsSync(const Context * context,bool isCallValid,GLsync sync,GLboolean returnValue)1269 CallCapture CaptureIsSync(const Context *context,
1270 bool isCallValid,
1271 GLsync sync,
1272 GLboolean returnValue)
1273 {
1274 ParamBuffer paramBuffer;
1275
1276 paramBuffer.addValueParam("sync", ParamType::TGLsync, sync);
1277
1278 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
1279 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
1280 paramBuffer.addReturnValue(std::move(returnValueCapture));
1281
1282 return CallCapture(gl::EntryPoint::IsSync, std::move(paramBuffer));
1283 }
1284
CaptureIsTransformFeedback(const Context * context,bool isCallValid,GLuint id,GLboolean returnValue)1285 CallCapture CaptureIsTransformFeedback(const Context *context,
1286 bool isCallValid,
1287 GLuint id,
1288 GLboolean returnValue)
1289 {
1290 ParamBuffer paramBuffer;
1291
1292 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
1293
1294 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
1295 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
1296 paramBuffer.addReturnValue(std::move(returnValueCapture));
1297
1298 return CallCapture(gl::EntryPoint::IsTransformFeedback, std::move(paramBuffer));
1299 }
1300
CaptureIsVertexArray(const Context * context,bool isCallValid,GLuint array,GLboolean returnValue)1301 CallCapture CaptureIsVertexArray(const Context *context,
1302 bool isCallValid,
1303 GLuint array,
1304 GLboolean returnValue)
1305 {
1306 ParamBuffer paramBuffer;
1307
1308 paramBuffer.addValueParam("array", ParamType::TGLuint, array);
1309
1310 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
1311 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
1312 paramBuffer.addReturnValue(std::move(returnValueCapture));
1313
1314 return CallCapture(gl::EntryPoint::IsVertexArray, std::move(paramBuffer));
1315 }
1316
CaptureMapBufferRange(const Context * context,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr length,GLbitfield access,void * returnValue)1317 CallCapture CaptureMapBufferRange(const Context *context,
1318 bool isCallValid,
1319 BufferBinding targetPacked,
1320 GLintptr offset,
1321 GLsizeiptr length,
1322 GLbitfield access,
1323 void *returnValue)
1324 {
1325 ParamBuffer paramBuffer;
1326
1327 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1328 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
1329 paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
1330 paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield,
1331 access);
1332
1333 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
1334 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
1335 paramBuffer.addReturnValue(std::move(returnValueCapture));
1336
1337 return CallCapture(gl::EntryPoint::MapBufferRange, std::move(paramBuffer));
1338 }
1339
CapturePauseTransformFeedback(const Context * context,bool isCallValid)1340 CallCapture CapturePauseTransformFeedback(const Context *context, bool isCallValid)
1341 {
1342 ParamBuffer paramBuffer;
1343
1344 return CallCapture(gl::EntryPoint::PauseTransformFeedback, std::move(paramBuffer));
1345 }
1346
CaptureProgramBinary(const Context * context,bool isCallValid,GLuint program,GLenum binaryFormat,const void * binary,GLsizei length)1347 CallCapture CaptureProgramBinary(const Context *context,
1348 bool isCallValid,
1349 GLuint program,
1350 GLenum binaryFormat,
1351 const void *binary,
1352 GLsizei length)
1353 {
1354 ParamBuffer paramBuffer;
1355
1356 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1357 paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1358 binaryFormat);
1359
1360 ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
1361 InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
1362 CaptureProgramBinary_binary(context, isCallValid, program, binaryFormat, binary, length,
1363 &binaryParam);
1364 paramBuffer.addParam(std::move(binaryParam));
1365
1366 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
1367
1368 return CallCapture(gl::EntryPoint::ProgramBinary, std::move(paramBuffer));
1369 }
1370
CaptureProgramParameteri(const Context * context,bool isCallValid,GLuint program,GLenum pname,GLint value)1371 CallCapture CaptureProgramParameteri(const Context *context,
1372 bool isCallValid,
1373 GLuint program,
1374 GLenum pname,
1375 GLint value)
1376 {
1377 ParamBuffer paramBuffer;
1378
1379 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1380 paramBuffer.addEnumParam("pname", GLenumGroup::ProgramParameterPName, ParamType::TGLenum,
1381 pname);
1382 paramBuffer.addValueParam("value", ParamType::TGLint, value);
1383
1384 return CallCapture(gl::EntryPoint::ProgramParameteri, std::move(paramBuffer));
1385 }
1386
CaptureReadBuffer(const Context * context,bool isCallValid,GLenum src)1387 CallCapture CaptureReadBuffer(const Context *context, bool isCallValid, GLenum src)
1388 {
1389 ParamBuffer paramBuffer;
1390
1391 paramBuffer.addEnumParam("src", GLenumGroup::ReadBufferMode, ParamType::TGLenum, src);
1392
1393 return CallCapture(gl::EntryPoint::ReadBuffer, std::move(paramBuffer));
1394 }
1395
CaptureRenderbufferStorageMultisample(const Context * context,bool isCallValid,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)1396 CallCapture CaptureRenderbufferStorageMultisample(const Context *context,
1397 bool isCallValid,
1398 GLenum target,
1399 GLsizei samples,
1400 GLenum internalformat,
1401 GLsizei width,
1402 GLsizei height)
1403 {
1404 ParamBuffer paramBuffer;
1405
1406 paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target);
1407 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
1408 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
1409 internalformat);
1410 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1411 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1412
1413 return CallCapture(gl::EntryPoint::RenderbufferStorageMultisample, std::move(paramBuffer));
1414 }
1415
CaptureResumeTransformFeedback(const Context * context,bool isCallValid)1416 CallCapture CaptureResumeTransformFeedback(const Context *context, bool isCallValid)
1417 {
1418 ParamBuffer paramBuffer;
1419
1420 return CallCapture(gl::EntryPoint::ResumeTransformFeedback, std::move(paramBuffer));
1421 }
1422
CaptureSamplerParameterf(const Context * context,bool isCallValid,GLuint sampler,GLenum pname,GLfloat param)1423 CallCapture CaptureSamplerParameterf(const Context *context,
1424 bool isCallValid,
1425 GLuint sampler,
1426 GLenum pname,
1427 GLfloat param)
1428 {
1429 ParamBuffer paramBuffer;
1430
1431 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
1432 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
1433 paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
1434
1435 return CallCapture(gl::EntryPoint::SamplerParameterf, std::move(paramBuffer));
1436 }
1437
CaptureSamplerParameterfv(const Context * context,bool isCallValid,GLuint sampler,GLenum pname,const GLfloat * param)1438 CallCapture CaptureSamplerParameterfv(const Context *context,
1439 bool isCallValid,
1440 GLuint sampler,
1441 GLenum pname,
1442 const GLfloat *param)
1443 {
1444 ParamBuffer paramBuffer;
1445
1446 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
1447 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
1448
1449 ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
1450 InitParamValue(ParamType::TGLfloatConstPointer, param, ¶mParam.value);
1451 CaptureSamplerParameterfv_param(context, isCallValid, sampler, pname, param, ¶mParam);
1452 paramBuffer.addParam(std::move(paramParam));
1453
1454 return CallCapture(gl::EntryPoint::SamplerParameterfv, std::move(paramBuffer));
1455 }
1456
CaptureSamplerParameteri(const Context * context,bool isCallValid,GLuint sampler,GLenum pname,GLint param)1457 CallCapture CaptureSamplerParameteri(const Context *context,
1458 bool isCallValid,
1459 GLuint sampler,
1460 GLenum pname,
1461 GLint param)
1462 {
1463 ParamBuffer paramBuffer;
1464
1465 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
1466 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
1467 paramBuffer.addValueParam("param", ParamType::TGLint, param);
1468
1469 return CallCapture(gl::EntryPoint::SamplerParameteri, std::move(paramBuffer));
1470 }
1471
CaptureSamplerParameteriv(const Context * context,bool isCallValid,GLuint sampler,GLenum pname,const GLint * param)1472 CallCapture CaptureSamplerParameteriv(const Context *context,
1473 bool isCallValid,
1474 GLuint sampler,
1475 GLenum pname,
1476 const GLint *param)
1477 {
1478 ParamBuffer paramBuffer;
1479
1480 paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
1481 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
1482
1483 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
1484 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
1485 CaptureSamplerParameteriv_param(context, isCallValid, sampler, pname, param, ¶mParam);
1486 paramBuffer.addParam(std::move(paramParam));
1487
1488 return CallCapture(gl::EntryPoint::SamplerParameteriv, std::move(paramBuffer));
1489 }
1490
CaptureTexImage3D(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)1491 CallCapture CaptureTexImage3D(const Context *context,
1492 bool isCallValid,
1493 TextureTarget targetPacked,
1494 GLint level,
1495 GLint internalformat,
1496 GLsizei width,
1497 GLsizei height,
1498 GLsizei depth,
1499 GLint border,
1500 GLenum format,
1501 GLenum type,
1502 const void *pixels)
1503 {
1504 ParamBuffer paramBuffer;
1505
1506 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1507 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1508 paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat);
1509 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1510 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1511 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1512 paramBuffer.addValueParam("border", ParamType::TGLint, border);
1513 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
1514 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
1515
1516 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1517 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1518 CaptureTexImage3D_pixels(context, isCallValid, targetPacked, level, internalformat, width,
1519 height, depth, border, format, type, pixels, &pixelsParam);
1520 paramBuffer.addParam(std::move(pixelsParam));
1521
1522 return CallCapture(gl::EntryPoint::TexImage3D, std::move(paramBuffer));
1523 }
1524
CaptureTexStorage2D(const Context * context,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)1525 CallCapture CaptureTexStorage2D(const Context *context,
1526 bool isCallValid,
1527 TextureType targetPacked,
1528 GLsizei levels,
1529 GLenum internalformat,
1530 GLsizei width,
1531 GLsizei height)
1532 {
1533 ParamBuffer paramBuffer;
1534
1535 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1536 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
1537 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
1538 internalformat);
1539 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1540 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1541
1542 return CallCapture(gl::EntryPoint::TexStorage2D, std::move(paramBuffer));
1543 }
1544
CaptureTexStorage3D(const Context * context,bool isCallValid,TextureType targetPacked,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)1545 CallCapture CaptureTexStorage3D(const Context *context,
1546 bool isCallValid,
1547 TextureType targetPacked,
1548 GLsizei levels,
1549 GLenum internalformat,
1550 GLsizei width,
1551 GLsizei height,
1552 GLsizei depth)
1553 {
1554 ParamBuffer paramBuffer;
1555
1556 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1557 paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
1558 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
1559 internalformat);
1560 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1561 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1562 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1563
1564 return CallCapture(gl::EntryPoint::TexStorage3D, std::move(paramBuffer));
1565 }
1566
CaptureTexSubImage3D(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)1567 CallCapture CaptureTexSubImage3D(const Context *context,
1568 bool isCallValid,
1569 TextureTarget targetPacked,
1570 GLint level,
1571 GLint xoffset,
1572 GLint yoffset,
1573 GLint zoffset,
1574 GLsizei width,
1575 GLsizei height,
1576 GLsizei depth,
1577 GLenum format,
1578 GLenum type,
1579 const void *pixels)
1580 {
1581 ParamBuffer paramBuffer;
1582
1583 paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
1584 paramBuffer.addValueParam("level", ParamType::TGLint, level);
1585 paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
1586 paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
1587 paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
1588 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1589 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1590 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
1591 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
1592 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
1593
1594 ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
1595 InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
1596 CaptureTexSubImage3D_pixels(context, isCallValid, targetPacked, level, xoffset, yoffset,
1597 zoffset, width, height, depth, format, type, pixels, &pixelsParam);
1598 paramBuffer.addParam(std::move(pixelsParam));
1599
1600 return CallCapture(gl::EntryPoint::TexSubImage3D, std::move(paramBuffer));
1601 }
1602
CaptureTransformFeedbackVaryings(const Context * context,bool isCallValid,GLuint program,GLsizei count,const GLchar * const * varyings,GLenum bufferMode)1603 CallCapture CaptureTransformFeedbackVaryings(const Context *context,
1604 bool isCallValid,
1605 GLuint program,
1606 GLsizei count,
1607 const GLchar *const *varyings,
1608 GLenum bufferMode)
1609 {
1610 ParamBuffer paramBuffer;
1611
1612 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1613 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1614
1615 ParamCapture varyingsParam("varyings", ParamType::TGLcharConstPointerPointer);
1616 InitParamValue(ParamType::TGLcharConstPointerPointer, varyings, &varyingsParam.value);
1617 CaptureTransformFeedbackVaryings_varyings(context, isCallValid, program, count, varyings,
1618 bufferMode, &varyingsParam);
1619 paramBuffer.addParam(std::move(varyingsParam));
1620
1621 paramBuffer.addEnumParam("bufferMode", GLenumGroup::DefaultGroup, ParamType::TGLenum,
1622 bufferMode);
1623
1624 return CallCapture(gl::EntryPoint::TransformFeedbackVaryings, std::move(paramBuffer));
1625 }
1626
CaptureUniform1ui(const Context * context,bool isCallValid,GLint location,GLuint v0)1627 CallCapture CaptureUniform1ui(const Context *context, bool isCallValid, GLint location, GLuint v0)
1628 {
1629 ParamBuffer paramBuffer;
1630
1631 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1632 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
1633
1634 return CallCapture(gl::EntryPoint::Uniform1ui, std::move(paramBuffer));
1635 }
1636
CaptureUniform1uiv(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLuint * value)1637 CallCapture CaptureUniform1uiv(const Context *context,
1638 bool isCallValid,
1639 GLint location,
1640 GLsizei count,
1641 const GLuint *value)
1642 {
1643 ParamBuffer paramBuffer;
1644
1645 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1646 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1647
1648 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1649 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1650 CaptureUniform1uiv_value(context, isCallValid, location, count, value, &valueParam);
1651 paramBuffer.addParam(std::move(valueParam));
1652
1653 return CallCapture(gl::EntryPoint::Uniform1uiv, std::move(paramBuffer));
1654 }
1655
CaptureUniform2ui(const Context * context,bool isCallValid,GLint location,GLuint v0,GLuint v1)1656 CallCapture CaptureUniform2ui(const Context *context,
1657 bool isCallValid,
1658 GLint location,
1659 GLuint v0,
1660 GLuint v1)
1661 {
1662 ParamBuffer paramBuffer;
1663
1664 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1665 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
1666 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
1667
1668 return CallCapture(gl::EntryPoint::Uniform2ui, std::move(paramBuffer));
1669 }
1670
CaptureUniform2uiv(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLuint * value)1671 CallCapture CaptureUniform2uiv(const Context *context,
1672 bool isCallValid,
1673 GLint location,
1674 GLsizei count,
1675 const GLuint *value)
1676 {
1677 ParamBuffer paramBuffer;
1678
1679 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1680 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1681
1682 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1683 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1684 CaptureUniform2uiv_value(context, isCallValid, location, count, value, &valueParam);
1685 paramBuffer.addParam(std::move(valueParam));
1686
1687 return CallCapture(gl::EntryPoint::Uniform2uiv, std::move(paramBuffer));
1688 }
1689
CaptureUniform3ui(const Context * context,bool isCallValid,GLint location,GLuint v0,GLuint v1,GLuint v2)1690 CallCapture CaptureUniform3ui(const Context *context,
1691 bool isCallValid,
1692 GLint location,
1693 GLuint v0,
1694 GLuint v1,
1695 GLuint v2)
1696 {
1697 ParamBuffer paramBuffer;
1698
1699 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1700 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
1701 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
1702 paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
1703
1704 return CallCapture(gl::EntryPoint::Uniform3ui, std::move(paramBuffer));
1705 }
1706
CaptureUniform3uiv(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLuint * value)1707 CallCapture CaptureUniform3uiv(const Context *context,
1708 bool isCallValid,
1709 GLint location,
1710 GLsizei count,
1711 const GLuint *value)
1712 {
1713 ParamBuffer paramBuffer;
1714
1715 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1716 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1717
1718 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1719 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1720 CaptureUniform3uiv_value(context, isCallValid, location, count, value, &valueParam);
1721 paramBuffer.addParam(std::move(valueParam));
1722
1723 return CallCapture(gl::EntryPoint::Uniform3uiv, std::move(paramBuffer));
1724 }
1725
CaptureUniform4ui(const Context * context,bool isCallValid,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)1726 CallCapture CaptureUniform4ui(const Context *context,
1727 bool isCallValid,
1728 GLint location,
1729 GLuint v0,
1730 GLuint v1,
1731 GLuint v2,
1732 GLuint v3)
1733 {
1734 ParamBuffer paramBuffer;
1735
1736 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1737 paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
1738 paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
1739 paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
1740 paramBuffer.addValueParam("v3", ParamType::TGLuint, v3);
1741
1742 return CallCapture(gl::EntryPoint::Uniform4ui, std::move(paramBuffer));
1743 }
1744
CaptureUniform4uiv(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLuint * value)1745 CallCapture CaptureUniform4uiv(const Context *context,
1746 bool isCallValid,
1747 GLint location,
1748 GLsizei count,
1749 const GLuint *value)
1750 {
1751 ParamBuffer paramBuffer;
1752
1753 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1754 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1755
1756 ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1757 InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1758 CaptureUniform4uiv_value(context, isCallValid, location, count, value, &valueParam);
1759 paramBuffer.addParam(std::move(valueParam));
1760
1761 return CallCapture(gl::EntryPoint::Uniform4uiv, std::move(paramBuffer));
1762 }
1763
CaptureUniformBlockBinding(const Context * context,bool isCallValid,GLuint program,GLuint uniformBlockIndex,GLuint uniformBlockBinding)1764 CallCapture CaptureUniformBlockBinding(const Context *context,
1765 bool isCallValid,
1766 GLuint program,
1767 GLuint uniformBlockIndex,
1768 GLuint uniformBlockBinding)
1769 {
1770 ParamBuffer paramBuffer;
1771
1772 paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1773 paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
1774 paramBuffer.addValueParam("uniformBlockBinding", ParamType::TGLuint, uniformBlockBinding);
1775
1776 return CallCapture(gl::EntryPoint::UniformBlockBinding, std::move(paramBuffer));
1777 }
1778
CaptureUniformMatrix2x3fv(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1779 CallCapture CaptureUniformMatrix2x3fv(const Context *context,
1780 bool isCallValid,
1781 GLint location,
1782 GLsizei count,
1783 GLboolean transpose,
1784 const GLfloat *value)
1785 {
1786 ParamBuffer paramBuffer;
1787
1788 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1789 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1790 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1791
1792 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1793 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1794 CaptureUniformMatrix2x3fv_value(context, isCallValid, location, count, transpose, value,
1795 &valueParam);
1796 paramBuffer.addParam(std::move(valueParam));
1797
1798 return CallCapture(gl::EntryPoint::UniformMatrix2x3fv, std::move(paramBuffer));
1799 }
1800
CaptureUniformMatrix2x4fv(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1801 CallCapture CaptureUniformMatrix2x4fv(const Context *context,
1802 bool isCallValid,
1803 GLint location,
1804 GLsizei count,
1805 GLboolean transpose,
1806 const GLfloat *value)
1807 {
1808 ParamBuffer paramBuffer;
1809
1810 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1811 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1812 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1813
1814 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1815 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1816 CaptureUniformMatrix2x4fv_value(context, isCallValid, location, count, transpose, value,
1817 &valueParam);
1818 paramBuffer.addParam(std::move(valueParam));
1819
1820 return CallCapture(gl::EntryPoint::UniformMatrix2x4fv, std::move(paramBuffer));
1821 }
1822
CaptureUniformMatrix3x2fv(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1823 CallCapture CaptureUniformMatrix3x2fv(const Context *context,
1824 bool isCallValid,
1825 GLint location,
1826 GLsizei count,
1827 GLboolean transpose,
1828 const GLfloat *value)
1829 {
1830 ParamBuffer paramBuffer;
1831
1832 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1833 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1834 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1835
1836 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1837 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1838 CaptureUniformMatrix3x2fv_value(context, isCallValid, location, count, transpose, value,
1839 &valueParam);
1840 paramBuffer.addParam(std::move(valueParam));
1841
1842 return CallCapture(gl::EntryPoint::UniformMatrix3x2fv, std::move(paramBuffer));
1843 }
1844
CaptureUniformMatrix3x4fv(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1845 CallCapture CaptureUniformMatrix3x4fv(const Context *context,
1846 bool isCallValid,
1847 GLint location,
1848 GLsizei count,
1849 GLboolean transpose,
1850 const GLfloat *value)
1851 {
1852 ParamBuffer paramBuffer;
1853
1854 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1855 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1856 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1857
1858 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1859 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1860 CaptureUniformMatrix3x4fv_value(context, isCallValid, location, count, transpose, value,
1861 &valueParam);
1862 paramBuffer.addParam(std::move(valueParam));
1863
1864 return CallCapture(gl::EntryPoint::UniformMatrix3x4fv, std::move(paramBuffer));
1865 }
1866
CaptureUniformMatrix4x2fv(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1867 CallCapture CaptureUniformMatrix4x2fv(const Context *context,
1868 bool isCallValid,
1869 GLint location,
1870 GLsizei count,
1871 GLboolean transpose,
1872 const GLfloat *value)
1873 {
1874 ParamBuffer paramBuffer;
1875
1876 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1877 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1878 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1879
1880 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1881 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1882 CaptureUniformMatrix4x2fv_value(context, isCallValid, location, count, transpose, value,
1883 &valueParam);
1884 paramBuffer.addParam(std::move(valueParam));
1885
1886 return CallCapture(gl::EntryPoint::UniformMatrix4x2fv, std::move(paramBuffer));
1887 }
1888
CaptureUniformMatrix4x3fv(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1889 CallCapture CaptureUniformMatrix4x3fv(const Context *context,
1890 bool isCallValid,
1891 GLint location,
1892 GLsizei count,
1893 GLboolean transpose,
1894 const GLfloat *value)
1895 {
1896 ParamBuffer paramBuffer;
1897
1898 paramBuffer.addValueParam("location", ParamType::TGLint, location);
1899 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1900 paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1901
1902 ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1903 InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1904 CaptureUniformMatrix4x3fv_value(context, isCallValid, location, count, transpose, value,
1905 &valueParam);
1906 paramBuffer.addParam(std::move(valueParam));
1907
1908 return CallCapture(gl::EntryPoint::UniformMatrix4x3fv, std::move(paramBuffer));
1909 }
1910
CaptureUnmapBuffer(const Context * context,bool isCallValid,BufferBinding targetPacked,GLboolean returnValue)1911 CallCapture CaptureUnmapBuffer(const Context *context,
1912 bool isCallValid,
1913 BufferBinding targetPacked,
1914 GLboolean returnValue)
1915 {
1916 ParamBuffer paramBuffer;
1917
1918 paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
1919
1920 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
1921 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
1922 paramBuffer.addReturnValue(std::move(returnValueCapture));
1923
1924 return CallCapture(gl::EntryPoint::UnmapBuffer, std::move(paramBuffer));
1925 }
1926
CaptureVertexAttribDivisor(const Context * context,bool isCallValid,GLuint index,GLuint divisor)1927 CallCapture CaptureVertexAttribDivisor(const Context *context,
1928 bool isCallValid,
1929 GLuint index,
1930 GLuint divisor)
1931 {
1932 ParamBuffer paramBuffer;
1933
1934 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1935 paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
1936
1937 return CallCapture(gl::EntryPoint::VertexAttribDivisor, std::move(paramBuffer));
1938 }
1939
CaptureVertexAttribI4i(const Context * context,bool isCallValid,GLuint index,GLint x,GLint y,GLint z,GLint w)1940 CallCapture CaptureVertexAttribI4i(const Context *context,
1941 bool isCallValid,
1942 GLuint index,
1943 GLint x,
1944 GLint y,
1945 GLint z,
1946 GLint w)
1947 {
1948 ParamBuffer paramBuffer;
1949
1950 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1951 paramBuffer.addValueParam("x", ParamType::TGLint, x);
1952 paramBuffer.addValueParam("y", ParamType::TGLint, y);
1953 paramBuffer.addValueParam("z", ParamType::TGLint, z);
1954 paramBuffer.addValueParam("w", ParamType::TGLint, w);
1955
1956 return CallCapture(gl::EntryPoint::VertexAttribI4i, std::move(paramBuffer));
1957 }
1958
CaptureVertexAttribI4iv(const Context * context,bool isCallValid,GLuint index,const GLint * v)1959 CallCapture CaptureVertexAttribI4iv(const Context *context,
1960 bool isCallValid,
1961 GLuint index,
1962 const GLint *v)
1963 {
1964 ParamBuffer paramBuffer;
1965
1966 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1967
1968 ParamCapture vParam("v", ParamType::TGLintConstPointer);
1969 InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
1970 CaptureVertexAttribI4iv_v(context, isCallValid, index, v, &vParam);
1971 paramBuffer.addParam(std::move(vParam));
1972
1973 return CallCapture(gl::EntryPoint::VertexAttribI4iv, std::move(paramBuffer));
1974 }
1975
CaptureVertexAttribI4ui(const Context * context,bool isCallValid,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)1976 CallCapture CaptureVertexAttribI4ui(const Context *context,
1977 bool isCallValid,
1978 GLuint index,
1979 GLuint x,
1980 GLuint y,
1981 GLuint z,
1982 GLuint w)
1983 {
1984 ParamBuffer paramBuffer;
1985
1986 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
1987 paramBuffer.addValueParam("x", ParamType::TGLuint, x);
1988 paramBuffer.addValueParam("y", ParamType::TGLuint, y);
1989 paramBuffer.addValueParam("z", ParamType::TGLuint, z);
1990 paramBuffer.addValueParam("w", ParamType::TGLuint, w);
1991
1992 return CallCapture(gl::EntryPoint::VertexAttribI4ui, std::move(paramBuffer));
1993 }
1994
CaptureVertexAttribI4uiv(const Context * context,bool isCallValid,GLuint index,const GLuint * v)1995 CallCapture CaptureVertexAttribI4uiv(const Context *context,
1996 bool isCallValid,
1997 GLuint index,
1998 const GLuint *v)
1999 {
2000 ParamBuffer paramBuffer;
2001
2002 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2003
2004 ParamCapture vParam("v", ParamType::TGLuintConstPointer);
2005 InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
2006 CaptureVertexAttribI4uiv_v(context, isCallValid, index, v, &vParam);
2007 paramBuffer.addParam(std::move(vParam));
2008
2009 return CallCapture(gl::EntryPoint::VertexAttribI4uiv, std::move(paramBuffer));
2010 }
2011
CaptureVertexAttribIPointer(const Context * context,bool isCallValid,GLuint index,GLint size,VertexAttribType typePacked,GLsizei stride,const void * pointer)2012 CallCapture CaptureVertexAttribIPointer(const Context *context,
2013 bool isCallValid,
2014 GLuint index,
2015 GLint size,
2016 VertexAttribType typePacked,
2017 GLsizei stride,
2018 const void *pointer)
2019 {
2020 ParamBuffer paramBuffer;
2021
2022 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
2023 paramBuffer.addValueParam("size", ParamType::TGLint, size);
2024 paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
2025 paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
2026
2027 ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
2028 InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
2029 CaptureVertexAttribIPointer_pointer(context, isCallValid, index, size, typePacked, stride,
2030 pointer, &pointerParam);
2031 paramBuffer.addParam(std::move(pointerParam));
2032
2033 return CallCapture(gl::EntryPoint::VertexAttribIPointer, std::move(paramBuffer));
2034 }
2035
CaptureWaitSync(const Context * context,bool isCallValid,GLsync sync,GLbitfield flags,GLuint64 timeout)2036 CallCapture CaptureWaitSync(const Context *context,
2037 bool isCallValid,
2038 GLsync sync,
2039 GLbitfield flags,
2040 GLuint64 timeout)
2041 {
2042 ParamBuffer paramBuffer;
2043
2044 paramBuffer.addValueParam("sync", ParamType::TGLsync, sync);
2045 paramBuffer.addEnumParam("flags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, flags);
2046 paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout);
2047
2048 return CallCapture(gl::EntryPoint::WaitSync, std::move(paramBuffer));
2049 }
2050
2051 } // namespace gl
2052