• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_1_autogen.cpp:
9 //   Capture functions for the OpenGL ES 3.1 entry points.
10 
11 #include "libANGLE/capture_gles_3_1_autogen.h"
12 
13 #include "libANGLE/Context.h"
14 #include "libANGLE/FrameCapture.h"
15 #include "libANGLE/gl_enum_utils_autogen.h"
16 #include "libANGLE/validationES31.h"
17 
18 using namespace angle;
19 
20 namespace gl
21 {
22 
CaptureActiveShaderProgram(const Context * context,bool isCallValid,GLuint pipeline,GLuint program)23 CallCapture CaptureActiveShaderProgram(const Context *context,
24                                        bool isCallValid,
25                                        GLuint pipeline,
26                                        GLuint program)
27 {
28     ParamBuffer paramBuffer;
29 
30     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
31     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
32 
33     return CallCapture(gl::EntryPoint::ActiveShaderProgram, std::move(paramBuffer));
34 }
35 
CaptureBindImageTexture(const Context * context,bool isCallValid,GLuint unit,TextureID texturePacked,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)36 CallCapture CaptureBindImageTexture(const Context *context,
37                                     bool isCallValid,
38                                     GLuint unit,
39                                     TextureID texturePacked,
40                                     GLint level,
41                                     GLboolean layered,
42                                     GLint layer,
43                                     GLenum access,
44                                     GLenum format)
45 {
46     ParamBuffer paramBuffer;
47 
48     paramBuffer.addValueParam("unit", ParamType::TGLuint, unit);
49     paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
50     paramBuffer.addValueParam("level", ParamType::TGLint, level);
51     paramBuffer.addValueParam("layered", ParamType::TGLboolean, layered);
52     paramBuffer.addValueParam("layer", ParamType::TGLint, layer);
53     paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access);
54     paramBuffer.addEnumParam("format", GLenumGroup::InternalFormat, ParamType::TGLenum, format);
55 
56     return CallCapture(gl::EntryPoint::BindImageTexture, std::move(paramBuffer));
57 }
58 
CaptureBindProgramPipeline(const Context * context,bool isCallValid,GLuint pipeline)59 CallCapture CaptureBindProgramPipeline(const Context *context, bool isCallValid, GLuint pipeline)
60 {
61     ParamBuffer paramBuffer;
62 
63     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
64 
65     return CallCapture(gl::EntryPoint::BindProgramPipeline, std::move(paramBuffer));
66 }
67 
CaptureBindVertexBuffer(const Context * context,bool isCallValid,GLuint bindingindex,BufferID bufferPacked,GLintptr offset,GLsizei stride)68 CallCapture CaptureBindVertexBuffer(const Context *context,
69                                     bool isCallValid,
70                                     GLuint bindingindex,
71                                     BufferID bufferPacked,
72                                     GLintptr offset,
73                                     GLsizei stride)
74 {
75     ParamBuffer paramBuffer;
76 
77     paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
78     paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
79     paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
80     paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
81 
82     return CallCapture(gl::EntryPoint::BindVertexBuffer, std::move(paramBuffer));
83 }
84 
CaptureCreateShaderProgramv(const Context * context,bool isCallValid,ShaderType typePacked,GLsizei count,const GLchar * const * strings,GLuint returnValue)85 CallCapture CaptureCreateShaderProgramv(const Context *context,
86                                         bool isCallValid,
87                                         ShaderType typePacked,
88                                         GLsizei count,
89                                         const GLchar *const *strings,
90                                         GLuint returnValue)
91 {
92     ParamBuffer paramBuffer;
93 
94     paramBuffer.addValueParam("typePacked", ParamType::TShaderType, typePacked);
95     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
96 
97     ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
98     InitParamValue(ParamType::TGLcharConstPointerPointer, strings, &stringsParam.value);
99     CaptureCreateShaderProgramv_strings(context, isCallValid, typePacked, count, strings,
100                                         &stringsParam);
101     paramBuffer.addParam(std::move(stringsParam));
102 
103     ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
104     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
105     paramBuffer.addReturnValue(std::move(returnValueCapture));
106 
107     return CallCapture(gl::EntryPoint::CreateShaderProgramv, std::move(paramBuffer));
108 }
109 
CaptureDeleteProgramPipelines(const Context * context,bool isCallValid,GLsizei n,const GLuint * pipelines)110 CallCapture CaptureDeleteProgramPipelines(const Context *context,
111                                           bool isCallValid,
112                                           GLsizei n,
113                                           const GLuint *pipelines)
114 {
115     ParamBuffer paramBuffer;
116 
117     paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
118 
119     ParamCapture pipelinesParam("pipelines", ParamType::TGLuintConstPointer);
120     InitParamValue(ParamType::TGLuintConstPointer, pipelines, &pipelinesParam.value);
121     CaptureDeleteProgramPipelines_pipelines(context, isCallValid, n, pipelines, &pipelinesParam);
122     paramBuffer.addParam(std::move(pipelinesParam));
123 
124     return CallCapture(gl::EntryPoint::DeleteProgramPipelines, std::move(paramBuffer));
125 }
126 
CaptureDispatchCompute(const Context * context,bool isCallValid,GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z)127 CallCapture CaptureDispatchCompute(const Context *context,
128                                    bool isCallValid,
129                                    GLuint num_groups_x,
130                                    GLuint num_groups_y,
131                                    GLuint num_groups_z)
132 {
133     ParamBuffer paramBuffer;
134 
135     paramBuffer.addValueParam("num_groups_x", ParamType::TGLuint, num_groups_x);
136     paramBuffer.addValueParam("num_groups_y", ParamType::TGLuint, num_groups_y);
137     paramBuffer.addValueParam("num_groups_z", ParamType::TGLuint, num_groups_z);
138 
139     return CallCapture(gl::EntryPoint::DispatchCompute, std::move(paramBuffer));
140 }
141 
CaptureDispatchComputeIndirect(const Context * context,bool isCallValid,GLintptr indirect)142 CallCapture CaptureDispatchComputeIndirect(const Context *context,
143                                            bool isCallValid,
144                                            GLintptr indirect)
145 {
146     ParamBuffer paramBuffer;
147 
148     paramBuffer.addValueParam("indirect", ParamType::TGLintptr, indirect);
149 
150     return CallCapture(gl::EntryPoint::DispatchComputeIndirect, std::move(paramBuffer));
151 }
152 
CaptureDrawArraysIndirect(const Context * context,bool isCallValid,PrimitiveMode modePacked,const void * indirect)153 CallCapture CaptureDrawArraysIndirect(const Context *context,
154                                       bool isCallValid,
155                                       PrimitiveMode modePacked,
156                                       const void *indirect)
157 {
158     ParamBuffer paramBuffer;
159 
160     paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
161 
162     ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
163     InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
164     CaptureDrawArraysIndirect_indirect(context, isCallValid, modePacked, indirect, &indirectParam);
165     paramBuffer.addParam(std::move(indirectParam));
166 
167     return CallCapture(gl::EntryPoint::DrawArraysIndirect, std::move(paramBuffer));
168 }
169 
CaptureDrawElementsIndirect(const Context * context,bool isCallValid,PrimitiveMode modePacked,DrawElementsType typePacked,const void * indirect)170 CallCapture CaptureDrawElementsIndirect(const Context *context,
171                                         bool isCallValid,
172                                         PrimitiveMode modePacked,
173                                         DrawElementsType typePacked,
174                                         const void *indirect)
175 {
176     ParamBuffer paramBuffer;
177 
178     paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
179     paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
180 
181     ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
182     InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
183     CaptureDrawElementsIndirect_indirect(context, isCallValid, modePacked, typePacked, indirect,
184                                          &indirectParam);
185     paramBuffer.addParam(std::move(indirectParam));
186 
187     return CallCapture(gl::EntryPoint::DrawElementsIndirect, std::move(paramBuffer));
188 }
189 
CaptureFramebufferParameteri(const Context * context,bool isCallValid,GLenum target,GLenum pname,GLint param)190 CallCapture CaptureFramebufferParameteri(const Context *context,
191                                          bool isCallValid,
192                                          GLenum target,
193                                          GLenum pname,
194                                          GLint param)
195 {
196     ParamBuffer paramBuffer;
197 
198     paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
199     paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferParameterName, ParamType::TGLenum,
200                              pname);
201     paramBuffer.addValueParam("param", ParamType::TGLint, param);
202 
203     return CallCapture(gl::EntryPoint::FramebufferParameteri, std::move(paramBuffer));
204 }
205 
CaptureGenProgramPipelines(const Context * context,bool isCallValid,GLsizei n,GLuint * pipelines)206 CallCapture CaptureGenProgramPipelines(const Context *context,
207                                        bool isCallValid,
208                                        GLsizei n,
209                                        GLuint *pipelines)
210 {
211     ParamBuffer paramBuffer;
212 
213     paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
214 
215     ParamCapture pipelinesParam("pipelines", ParamType::TGLuintPointer);
216     InitParamValue(ParamType::TGLuintPointer, pipelines, &pipelinesParam.value);
217     CaptureGenProgramPipelines_pipelines(context, isCallValid, n, pipelines, &pipelinesParam);
218     paramBuffer.addParam(std::move(pipelinesParam));
219 
220     return CallCapture(gl::EntryPoint::GenProgramPipelines, std::move(paramBuffer));
221 }
222 
CaptureGetBooleani_v(const Context * context,bool isCallValid,GLenum target,GLuint index,GLboolean * data)223 CallCapture CaptureGetBooleani_v(const Context *context,
224                                  bool isCallValid,
225                                  GLenum target,
226                                  GLuint index,
227                                  GLboolean *data)
228 {
229     ParamBuffer paramBuffer;
230 
231     paramBuffer.addEnumParam("target", GLenumGroup::BufferTargetARB, ParamType::TGLenum, target);
232     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
233 
234     ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
235     InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
236     CaptureGetBooleani_v_data(context, isCallValid, target, index, data, &dataParam);
237     paramBuffer.addParam(std::move(dataParam));
238 
239     return CallCapture(gl::EntryPoint::GetBooleani_v, std::move(paramBuffer));
240 }
241 
CaptureGetFramebufferParameteriv(const Context * context,bool isCallValid,GLenum target,GLenum pname,GLint * params)242 CallCapture CaptureGetFramebufferParameteriv(const Context *context,
243                                              bool isCallValid,
244                                              GLenum target,
245                                              GLenum pname,
246                                              GLint *params)
247 {
248     ParamBuffer paramBuffer;
249 
250     paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
251     paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName,
252                              ParamType::TGLenum, pname);
253 
254     ParamCapture paramsParam("params", ParamType::TGLintPointer);
255     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
256     CaptureGetFramebufferParameteriv_params(context, isCallValid, target, pname, params,
257                                             &paramsParam);
258     paramBuffer.addParam(std::move(paramsParam));
259 
260     return CallCapture(gl::EntryPoint::GetFramebufferParameteriv, std::move(paramBuffer));
261 }
262 
CaptureGetMultisamplefv(const Context * context,bool isCallValid,GLenum pname,GLuint index,GLfloat * val)263 CallCapture CaptureGetMultisamplefv(const Context *context,
264                                     bool isCallValid,
265                                     GLenum pname,
266                                     GLuint index,
267                                     GLfloat *val)
268 {
269     ParamBuffer paramBuffer;
270 
271     paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
272     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
273 
274     ParamCapture valParam("val", ParamType::TGLfloatPointer);
275     InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
276     CaptureGetMultisamplefv_val(context, isCallValid, pname, index, val, &valParam);
277     paramBuffer.addParam(std::move(valParam));
278 
279     return CallCapture(gl::EntryPoint::GetMultisamplefv, std::move(paramBuffer));
280 }
281 
CaptureGetProgramInterfaceiv(const Context * context,bool isCallValid,GLuint program,GLenum programInterface,GLenum pname,GLint * params)282 CallCapture CaptureGetProgramInterfaceiv(const Context *context,
283                                          bool isCallValid,
284                                          GLuint program,
285                                          GLenum programInterface,
286                                          GLenum pname,
287                                          GLint *params)
288 {
289     ParamBuffer paramBuffer;
290 
291     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
292     paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
293                              programInterface);
294     paramBuffer.addEnumParam("pname", GLenumGroup::ProgramInterfacePName, ParamType::TGLenum,
295                              pname);
296 
297     ParamCapture paramsParam("params", ParamType::TGLintPointer);
298     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
299     CaptureGetProgramInterfaceiv_params(context, isCallValid, program, programInterface, pname,
300                                         params, &paramsParam);
301     paramBuffer.addParam(std::move(paramsParam));
302 
303     return CallCapture(gl::EntryPoint::GetProgramInterfaceiv, std::move(paramBuffer));
304 }
305 
CaptureGetProgramPipelineInfoLog(const Context * context,bool isCallValid,GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)306 CallCapture CaptureGetProgramPipelineInfoLog(const Context *context,
307                                              bool isCallValid,
308                                              GLuint pipeline,
309                                              GLsizei bufSize,
310                                              GLsizei *length,
311                                              GLchar *infoLog)
312 {
313     ParamBuffer paramBuffer;
314 
315     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
316     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
317 
318     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
319     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
320     CaptureGetProgramPipelineInfoLog_length(context, isCallValid, pipeline, bufSize, length,
321                                             infoLog, &lengthParam);
322     paramBuffer.addParam(std::move(lengthParam));
323 
324     ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
325     InitParamValue(ParamType::TGLcharPointer, infoLog, &infoLogParam.value);
326     CaptureGetProgramPipelineInfoLog_infoLog(context, isCallValid, pipeline, bufSize, length,
327                                              infoLog, &infoLogParam);
328     paramBuffer.addParam(std::move(infoLogParam));
329 
330     return CallCapture(gl::EntryPoint::GetProgramPipelineInfoLog, std::move(paramBuffer));
331 }
332 
CaptureGetProgramPipelineiv(const Context * context,bool isCallValid,GLuint pipeline,GLenum pname,GLint * params)333 CallCapture CaptureGetProgramPipelineiv(const Context *context,
334                                         bool isCallValid,
335                                         GLuint pipeline,
336                                         GLenum pname,
337                                         GLint *params)
338 {
339     ParamBuffer paramBuffer;
340 
341     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
342     paramBuffer.addEnumParam("pname", GLenumGroup::PipelineParameterName, ParamType::TGLenum,
343                              pname);
344 
345     ParamCapture paramsParam("params", ParamType::TGLintPointer);
346     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
347     CaptureGetProgramPipelineiv_params(context, isCallValid, pipeline, pname, params, &paramsParam);
348     paramBuffer.addParam(std::move(paramsParam));
349 
350     return CallCapture(gl::EntryPoint::GetProgramPipelineiv, std::move(paramBuffer));
351 }
352 
CaptureGetProgramResourceIndex(const Context * context,bool isCallValid,GLuint program,GLenum programInterface,const GLchar * name,GLuint returnValue)353 CallCapture CaptureGetProgramResourceIndex(const Context *context,
354                                            bool isCallValid,
355                                            GLuint program,
356                                            GLenum programInterface,
357                                            const GLchar *name,
358                                            GLuint returnValue)
359 {
360     ParamBuffer paramBuffer;
361 
362     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
363     paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
364                              programInterface);
365 
366     ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
367     InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
368     CaptureGetProgramResourceIndex_name(context, isCallValid, program, programInterface, name,
369                                         &nameParam);
370     paramBuffer.addParam(std::move(nameParam));
371 
372     ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
373     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
374     paramBuffer.addReturnValue(std::move(returnValueCapture));
375 
376     return CallCapture(gl::EntryPoint::GetProgramResourceIndex, std::move(paramBuffer));
377 }
378 
CaptureGetProgramResourceLocation(const Context * context,bool isCallValid,GLuint program,GLenum programInterface,const GLchar * name,GLint returnValue)379 CallCapture CaptureGetProgramResourceLocation(const Context *context,
380                                               bool isCallValid,
381                                               GLuint program,
382                                               GLenum programInterface,
383                                               const GLchar *name,
384                                               GLint returnValue)
385 {
386     ParamBuffer paramBuffer;
387 
388     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
389     paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
390                              programInterface);
391 
392     ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
393     InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
394     CaptureGetProgramResourceLocation_name(context, isCallValid, program, programInterface, name,
395                                            &nameParam);
396     paramBuffer.addParam(std::move(nameParam));
397 
398     ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
399     InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
400     paramBuffer.addReturnValue(std::move(returnValueCapture));
401 
402     return CallCapture(gl::EntryPoint::GetProgramResourceLocation, std::move(paramBuffer));
403 }
404 
CaptureGetProgramResourceName(const Context * context,bool isCallValid,GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei * length,GLchar * name)405 CallCapture CaptureGetProgramResourceName(const Context *context,
406                                           bool isCallValid,
407                                           GLuint program,
408                                           GLenum programInterface,
409                                           GLuint index,
410                                           GLsizei bufSize,
411                                           GLsizei *length,
412                                           GLchar *name)
413 {
414     ParamBuffer paramBuffer;
415 
416     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
417     paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
418                              programInterface);
419     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
420     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
421 
422     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
423     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
424     CaptureGetProgramResourceName_length(context, isCallValid, program, programInterface, index,
425                                          bufSize, length, name, &lengthParam);
426     paramBuffer.addParam(std::move(lengthParam));
427 
428     ParamCapture nameParam("name", ParamType::TGLcharPointer);
429     InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
430     CaptureGetProgramResourceName_name(context, isCallValid, program, programInterface, index,
431                                        bufSize, length, name, &nameParam);
432     paramBuffer.addParam(std::move(nameParam));
433 
434     return CallCapture(gl::EntryPoint::GetProgramResourceName, std::move(paramBuffer));
435 }
436 
CaptureGetProgramResourceiv(const Context * context,bool isCallValid,GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum * props,GLsizei bufSize,GLsizei * length,GLint * params)437 CallCapture CaptureGetProgramResourceiv(const Context *context,
438                                         bool isCallValid,
439                                         GLuint program,
440                                         GLenum programInterface,
441                                         GLuint index,
442                                         GLsizei propCount,
443                                         const GLenum *props,
444                                         GLsizei bufSize,
445                                         GLsizei *length,
446                                         GLint *params)
447 {
448     ParamBuffer paramBuffer;
449 
450     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
451     paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
452                              programInterface);
453     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
454     paramBuffer.addValueParam("propCount", ParamType::TGLsizei, propCount);
455 
456     ParamCapture propsParam("props", ParamType::TGLenumConstPointer);
457     InitParamValue(ParamType::TGLenumConstPointer, props, &propsParam.value);
458     CaptureGetProgramResourceiv_props(context, isCallValid, program, programInterface, index,
459                                       propCount, props, bufSize, length, params, &propsParam);
460     paramBuffer.addParam(std::move(propsParam));
461 
462     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
463 
464     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
465     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
466     CaptureGetProgramResourceiv_length(context, isCallValid, program, programInterface, index,
467                                        propCount, props, bufSize, length, params, &lengthParam);
468     paramBuffer.addParam(std::move(lengthParam));
469 
470     ParamCapture paramsParam("params", ParamType::TGLintPointer);
471     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
472     CaptureGetProgramResourceiv_params(context, isCallValid, program, programInterface, index,
473                                        propCount, props, bufSize, length, params, &paramsParam);
474     paramBuffer.addParam(std::move(paramsParam));
475 
476     return CallCapture(gl::EntryPoint::GetProgramResourceiv, std::move(paramBuffer));
477 }
478 
CaptureGetTexLevelParameterfv(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLfloat * params)479 CallCapture CaptureGetTexLevelParameterfv(const Context *context,
480                                           bool isCallValid,
481                                           TextureTarget targetPacked,
482                                           GLint level,
483                                           GLenum pname,
484                                           GLfloat *params)
485 {
486     ParamBuffer paramBuffer;
487 
488     paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
489     paramBuffer.addValueParam("level", ParamType::TGLint, level);
490     paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
491 
492     ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
493     InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
494     CaptureGetTexLevelParameterfv_params(context, isCallValid, targetPacked, level, pname, params,
495                                          &paramsParam);
496     paramBuffer.addParam(std::move(paramsParam));
497 
498     return CallCapture(gl::EntryPoint::GetTexLevelParameterfv, std::move(paramBuffer));
499 }
500 
CaptureGetTexLevelParameteriv(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum pname,GLint * params)501 CallCapture CaptureGetTexLevelParameteriv(const Context *context,
502                                           bool isCallValid,
503                                           TextureTarget targetPacked,
504                                           GLint level,
505                                           GLenum pname,
506                                           GLint *params)
507 {
508     ParamBuffer paramBuffer;
509 
510     paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked);
511     paramBuffer.addValueParam("level", ParamType::TGLint, level);
512     paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
513 
514     ParamCapture paramsParam("params", ParamType::TGLintPointer);
515     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
516     CaptureGetTexLevelParameteriv_params(context, isCallValid, targetPacked, level, pname, params,
517                                          &paramsParam);
518     paramBuffer.addParam(std::move(paramsParam));
519 
520     return CallCapture(gl::EntryPoint::GetTexLevelParameteriv, std::move(paramBuffer));
521 }
522 
CaptureIsProgramPipeline(const Context * context,bool isCallValid,GLuint pipeline,GLboolean returnValue)523 CallCapture CaptureIsProgramPipeline(const Context *context,
524                                      bool isCallValid,
525                                      GLuint pipeline,
526                                      GLboolean returnValue)
527 {
528     ParamBuffer paramBuffer;
529 
530     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
531 
532     ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
533     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
534     paramBuffer.addReturnValue(std::move(returnValueCapture));
535 
536     return CallCapture(gl::EntryPoint::IsProgramPipeline, std::move(paramBuffer));
537 }
538 
CaptureMemoryBarrier(const Context * context,bool isCallValid,GLbitfield barriers)539 CallCapture CaptureMemoryBarrier(const Context *context, bool isCallValid, GLbitfield barriers)
540 {
541     ParamBuffer paramBuffer;
542 
543     paramBuffer.addEnumParam("barriers", GLenumGroup::MemoryBarrierMask, ParamType::TGLbitfield,
544                              barriers);
545 
546     return CallCapture(gl::EntryPoint::MemoryBarrier, std::move(paramBuffer));
547 }
548 
CaptureMemoryBarrierByRegion(const Context * context,bool isCallValid,GLbitfield barriers)549 CallCapture CaptureMemoryBarrierByRegion(const Context *context,
550                                          bool isCallValid,
551                                          GLbitfield barriers)
552 {
553     ParamBuffer paramBuffer;
554 
555     paramBuffer.addEnumParam("barriers", GLenumGroup::MemoryBarrierMask, ParamType::TGLbitfield,
556                              barriers);
557 
558     return CallCapture(gl::EntryPoint::MemoryBarrierByRegion, std::move(paramBuffer));
559 }
560 
CaptureProgramUniform1f(const Context * context,bool isCallValid,GLuint program,GLint location,GLfloat v0)561 CallCapture CaptureProgramUniform1f(const Context *context,
562                                     bool isCallValid,
563                                     GLuint program,
564                                     GLint location,
565                                     GLfloat v0)
566 {
567     ParamBuffer paramBuffer;
568 
569     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
570     paramBuffer.addValueParam("location", ParamType::TGLint, location);
571     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
572 
573     return CallCapture(gl::EntryPoint::ProgramUniform1f, std::move(paramBuffer));
574 }
575 
CaptureProgramUniform1fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLfloat * value)576 CallCapture CaptureProgramUniform1fv(const Context *context,
577                                      bool isCallValid,
578                                      GLuint program,
579                                      GLint location,
580                                      GLsizei count,
581                                      const GLfloat *value)
582 {
583     ParamBuffer paramBuffer;
584 
585     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
586     paramBuffer.addValueParam("location", ParamType::TGLint, location);
587     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
588 
589     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
590     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
591     CaptureProgramUniform1fv_value(context, isCallValid, program, location, count, value,
592                                    &valueParam);
593     paramBuffer.addParam(std::move(valueParam));
594 
595     return CallCapture(gl::EntryPoint::ProgramUniform1fv, std::move(paramBuffer));
596 }
597 
CaptureProgramUniform1i(const Context * context,bool isCallValid,GLuint program,GLint location,GLint v0)598 CallCapture CaptureProgramUniform1i(const Context *context,
599                                     bool isCallValid,
600                                     GLuint program,
601                                     GLint location,
602                                     GLint v0)
603 {
604     ParamBuffer paramBuffer;
605 
606     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
607     paramBuffer.addValueParam("location", ParamType::TGLint, location);
608     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
609 
610     return CallCapture(gl::EntryPoint::ProgramUniform1i, std::move(paramBuffer));
611 }
612 
CaptureProgramUniform1iv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLint * value)613 CallCapture CaptureProgramUniform1iv(const Context *context,
614                                      bool isCallValid,
615                                      GLuint program,
616                                      GLint location,
617                                      GLsizei count,
618                                      const GLint *value)
619 {
620     ParamBuffer paramBuffer;
621 
622     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
623     paramBuffer.addValueParam("location", ParamType::TGLint, location);
624     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
625 
626     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
627     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
628     CaptureProgramUniform1iv_value(context, isCallValid, program, location, count, value,
629                                    &valueParam);
630     paramBuffer.addParam(std::move(valueParam));
631 
632     return CallCapture(gl::EntryPoint::ProgramUniform1iv, std::move(paramBuffer));
633 }
634 
CaptureProgramUniform1ui(const Context * context,bool isCallValid,GLuint program,GLint location,GLuint v0)635 CallCapture CaptureProgramUniform1ui(const Context *context,
636                                      bool isCallValid,
637                                      GLuint program,
638                                      GLint location,
639                                      GLuint v0)
640 {
641     ParamBuffer paramBuffer;
642 
643     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
644     paramBuffer.addValueParam("location", ParamType::TGLint, location);
645     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
646 
647     return CallCapture(gl::EntryPoint::ProgramUniform1ui, std::move(paramBuffer));
648 }
649 
CaptureProgramUniform1uiv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLuint * value)650 CallCapture CaptureProgramUniform1uiv(const Context *context,
651                                       bool isCallValid,
652                                       GLuint program,
653                                       GLint location,
654                                       GLsizei count,
655                                       const GLuint *value)
656 {
657     ParamBuffer paramBuffer;
658 
659     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
660     paramBuffer.addValueParam("location", ParamType::TGLint, location);
661     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
662 
663     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
664     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
665     CaptureProgramUniform1uiv_value(context, isCallValid, program, location, count, value,
666                                     &valueParam);
667     paramBuffer.addParam(std::move(valueParam));
668 
669     return CallCapture(gl::EntryPoint::ProgramUniform1uiv, std::move(paramBuffer));
670 }
671 
CaptureProgramUniform2f(const Context * context,bool isCallValid,GLuint program,GLint location,GLfloat v0,GLfloat v1)672 CallCapture CaptureProgramUniform2f(const Context *context,
673                                     bool isCallValid,
674                                     GLuint program,
675                                     GLint location,
676                                     GLfloat v0,
677                                     GLfloat v1)
678 {
679     ParamBuffer paramBuffer;
680 
681     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
682     paramBuffer.addValueParam("location", ParamType::TGLint, location);
683     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
684     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
685 
686     return CallCapture(gl::EntryPoint::ProgramUniform2f, std::move(paramBuffer));
687 }
688 
CaptureProgramUniform2fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLfloat * value)689 CallCapture CaptureProgramUniform2fv(const Context *context,
690                                      bool isCallValid,
691                                      GLuint program,
692                                      GLint location,
693                                      GLsizei count,
694                                      const GLfloat *value)
695 {
696     ParamBuffer paramBuffer;
697 
698     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
699     paramBuffer.addValueParam("location", ParamType::TGLint, location);
700     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
701 
702     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
703     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
704     CaptureProgramUniform2fv_value(context, isCallValid, program, location, count, value,
705                                    &valueParam);
706     paramBuffer.addParam(std::move(valueParam));
707 
708     return CallCapture(gl::EntryPoint::ProgramUniform2fv, std::move(paramBuffer));
709 }
710 
CaptureProgramUniform2i(const Context * context,bool isCallValid,GLuint program,GLint location,GLint v0,GLint v1)711 CallCapture CaptureProgramUniform2i(const Context *context,
712                                     bool isCallValid,
713                                     GLuint program,
714                                     GLint location,
715                                     GLint v0,
716                                     GLint v1)
717 {
718     ParamBuffer paramBuffer;
719 
720     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
721     paramBuffer.addValueParam("location", ParamType::TGLint, location);
722     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
723     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
724 
725     return CallCapture(gl::EntryPoint::ProgramUniform2i, std::move(paramBuffer));
726 }
727 
CaptureProgramUniform2iv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLint * value)728 CallCapture CaptureProgramUniform2iv(const Context *context,
729                                      bool isCallValid,
730                                      GLuint program,
731                                      GLint location,
732                                      GLsizei count,
733                                      const GLint *value)
734 {
735     ParamBuffer paramBuffer;
736 
737     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
738     paramBuffer.addValueParam("location", ParamType::TGLint, location);
739     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
740 
741     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
742     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
743     CaptureProgramUniform2iv_value(context, isCallValid, program, location, count, value,
744                                    &valueParam);
745     paramBuffer.addParam(std::move(valueParam));
746 
747     return CallCapture(gl::EntryPoint::ProgramUniform2iv, std::move(paramBuffer));
748 }
749 
CaptureProgramUniform2ui(const Context * context,bool isCallValid,GLuint program,GLint location,GLuint v0,GLuint v1)750 CallCapture CaptureProgramUniform2ui(const Context *context,
751                                      bool isCallValid,
752                                      GLuint program,
753                                      GLint location,
754                                      GLuint v0,
755                                      GLuint v1)
756 {
757     ParamBuffer paramBuffer;
758 
759     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
760     paramBuffer.addValueParam("location", ParamType::TGLint, location);
761     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
762     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
763 
764     return CallCapture(gl::EntryPoint::ProgramUniform2ui, std::move(paramBuffer));
765 }
766 
CaptureProgramUniform2uiv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLuint * value)767 CallCapture CaptureProgramUniform2uiv(const Context *context,
768                                       bool isCallValid,
769                                       GLuint program,
770                                       GLint location,
771                                       GLsizei count,
772                                       const GLuint *value)
773 {
774     ParamBuffer paramBuffer;
775 
776     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
777     paramBuffer.addValueParam("location", ParamType::TGLint, location);
778     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
779 
780     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
781     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
782     CaptureProgramUniform2uiv_value(context, isCallValid, program, location, count, value,
783                                     &valueParam);
784     paramBuffer.addParam(std::move(valueParam));
785 
786     return CallCapture(gl::EntryPoint::ProgramUniform2uiv, std::move(paramBuffer));
787 }
788 
CaptureProgramUniform3f(const Context * context,bool isCallValid,GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)789 CallCapture CaptureProgramUniform3f(const Context *context,
790                                     bool isCallValid,
791                                     GLuint program,
792                                     GLint location,
793                                     GLfloat v0,
794                                     GLfloat v1,
795                                     GLfloat v2)
796 {
797     ParamBuffer paramBuffer;
798 
799     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
800     paramBuffer.addValueParam("location", ParamType::TGLint, location);
801     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
802     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
803     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
804 
805     return CallCapture(gl::EntryPoint::ProgramUniform3f, std::move(paramBuffer));
806 }
807 
CaptureProgramUniform3fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLfloat * value)808 CallCapture CaptureProgramUniform3fv(const Context *context,
809                                      bool isCallValid,
810                                      GLuint program,
811                                      GLint location,
812                                      GLsizei count,
813                                      const GLfloat *value)
814 {
815     ParamBuffer paramBuffer;
816 
817     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
818     paramBuffer.addValueParam("location", ParamType::TGLint, location);
819     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
820 
821     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
822     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
823     CaptureProgramUniform3fv_value(context, isCallValid, program, location, count, value,
824                                    &valueParam);
825     paramBuffer.addParam(std::move(valueParam));
826 
827     return CallCapture(gl::EntryPoint::ProgramUniform3fv, std::move(paramBuffer));
828 }
829 
CaptureProgramUniform3i(const Context * context,bool isCallValid,GLuint program,GLint location,GLint v0,GLint v1,GLint v2)830 CallCapture CaptureProgramUniform3i(const Context *context,
831                                     bool isCallValid,
832                                     GLuint program,
833                                     GLint location,
834                                     GLint v0,
835                                     GLint v1,
836                                     GLint v2)
837 {
838     ParamBuffer paramBuffer;
839 
840     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
841     paramBuffer.addValueParam("location", ParamType::TGLint, location);
842     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
843     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
844     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
845 
846     return CallCapture(gl::EntryPoint::ProgramUniform3i, std::move(paramBuffer));
847 }
848 
CaptureProgramUniform3iv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLint * value)849 CallCapture CaptureProgramUniform3iv(const Context *context,
850                                      bool isCallValid,
851                                      GLuint program,
852                                      GLint location,
853                                      GLsizei count,
854                                      const GLint *value)
855 {
856     ParamBuffer paramBuffer;
857 
858     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
859     paramBuffer.addValueParam("location", ParamType::TGLint, location);
860     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
861 
862     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
863     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
864     CaptureProgramUniform3iv_value(context, isCallValid, program, location, count, value,
865                                    &valueParam);
866     paramBuffer.addParam(std::move(valueParam));
867 
868     return CallCapture(gl::EntryPoint::ProgramUniform3iv, std::move(paramBuffer));
869 }
870 
CaptureProgramUniform3ui(const Context * context,bool isCallValid,GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)871 CallCapture CaptureProgramUniform3ui(const Context *context,
872                                      bool isCallValid,
873                                      GLuint program,
874                                      GLint location,
875                                      GLuint v0,
876                                      GLuint v1,
877                                      GLuint v2)
878 {
879     ParamBuffer paramBuffer;
880 
881     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
882     paramBuffer.addValueParam("location", ParamType::TGLint, location);
883     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
884     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
885     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
886 
887     return CallCapture(gl::EntryPoint::ProgramUniform3ui, std::move(paramBuffer));
888 }
889 
CaptureProgramUniform3uiv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLuint * value)890 CallCapture CaptureProgramUniform3uiv(const Context *context,
891                                       bool isCallValid,
892                                       GLuint program,
893                                       GLint location,
894                                       GLsizei count,
895                                       const GLuint *value)
896 {
897     ParamBuffer paramBuffer;
898 
899     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
900     paramBuffer.addValueParam("location", ParamType::TGLint, location);
901     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
902 
903     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
904     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
905     CaptureProgramUniform3uiv_value(context, isCallValid, program, location, count, value,
906                                     &valueParam);
907     paramBuffer.addParam(std::move(valueParam));
908 
909     return CallCapture(gl::EntryPoint::ProgramUniform3uiv, std::move(paramBuffer));
910 }
911 
CaptureProgramUniform4f(const Context * context,bool isCallValid,GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)912 CallCapture CaptureProgramUniform4f(const Context *context,
913                                     bool isCallValid,
914                                     GLuint program,
915                                     GLint location,
916                                     GLfloat v0,
917                                     GLfloat v1,
918                                     GLfloat v2,
919                                     GLfloat v3)
920 {
921     ParamBuffer paramBuffer;
922 
923     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
924     paramBuffer.addValueParam("location", ParamType::TGLint, location);
925     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
926     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
927     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
928     paramBuffer.addValueParam("v3", ParamType::TGLfloat, v3);
929 
930     return CallCapture(gl::EntryPoint::ProgramUniform4f, std::move(paramBuffer));
931 }
932 
CaptureProgramUniform4fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLfloat * value)933 CallCapture CaptureProgramUniform4fv(const Context *context,
934                                      bool isCallValid,
935                                      GLuint program,
936                                      GLint location,
937                                      GLsizei count,
938                                      const GLfloat *value)
939 {
940     ParamBuffer paramBuffer;
941 
942     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
943     paramBuffer.addValueParam("location", ParamType::TGLint, location);
944     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
945 
946     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
947     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
948     CaptureProgramUniform4fv_value(context, isCallValid, program, location, count, value,
949                                    &valueParam);
950     paramBuffer.addParam(std::move(valueParam));
951 
952     return CallCapture(gl::EntryPoint::ProgramUniform4fv, std::move(paramBuffer));
953 }
954 
CaptureProgramUniform4i(const Context * context,bool isCallValid,GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)955 CallCapture CaptureProgramUniform4i(const Context *context,
956                                     bool isCallValid,
957                                     GLuint program,
958                                     GLint location,
959                                     GLint v0,
960                                     GLint v1,
961                                     GLint v2,
962                                     GLint v3)
963 {
964     ParamBuffer paramBuffer;
965 
966     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
967     paramBuffer.addValueParam("location", ParamType::TGLint, location);
968     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
969     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
970     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
971     paramBuffer.addValueParam("v3", ParamType::TGLint, v3);
972 
973     return CallCapture(gl::EntryPoint::ProgramUniform4i, std::move(paramBuffer));
974 }
975 
CaptureProgramUniform4iv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLint * value)976 CallCapture CaptureProgramUniform4iv(const Context *context,
977                                      bool isCallValid,
978                                      GLuint program,
979                                      GLint location,
980                                      GLsizei count,
981                                      const GLint *value)
982 {
983     ParamBuffer paramBuffer;
984 
985     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
986     paramBuffer.addValueParam("location", ParamType::TGLint, location);
987     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
988 
989     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
990     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
991     CaptureProgramUniform4iv_value(context, isCallValid, program, location, count, value,
992                                    &valueParam);
993     paramBuffer.addParam(std::move(valueParam));
994 
995     return CallCapture(gl::EntryPoint::ProgramUniform4iv, std::move(paramBuffer));
996 }
997 
CaptureProgramUniform4ui(const Context * context,bool isCallValid,GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)998 CallCapture CaptureProgramUniform4ui(const Context *context,
999                                      bool isCallValid,
1000                                      GLuint program,
1001                                      GLint location,
1002                                      GLuint v0,
1003                                      GLuint v1,
1004                                      GLuint v2,
1005                                      GLuint v3)
1006 {
1007     ParamBuffer paramBuffer;
1008 
1009     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1010     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1011     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
1012     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
1013     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
1014     paramBuffer.addValueParam("v3", ParamType::TGLuint, v3);
1015 
1016     return CallCapture(gl::EntryPoint::ProgramUniform4ui, std::move(paramBuffer));
1017 }
1018 
CaptureProgramUniform4uiv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,const GLuint * value)1019 CallCapture CaptureProgramUniform4uiv(const Context *context,
1020                                       bool isCallValid,
1021                                       GLuint program,
1022                                       GLint location,
1023                                       GLsizei count,
1024                                       const GLuint *value)
1025 {
1026     ParamBuffer paramBuffer;
1027 
1028     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1029     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1030     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1031 
1032     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
1033     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
1034     CaptureProgramUniform4uiv_value(context, isCallValid, program, location, count, value,
1035                                     &valueParam);
1036     paramBuffer.addParam(std::move(valueParam));
1037 
1038     return CallCapture(gl::EntryPoint::ProgramUniform4uiv, std::move(paramBuffer));
1039 }
1040 
CaptureProgramUniformMatrix2fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1041 CallCapture CaptureProgramUniformMatrix2fv(const Context *context,
1042                                            bool isCallValid,
1043                                            GLuint program,
1044                                            GLint location,
1045                                            GLsizei count,
1046                                            GLboolean transpose,
1047                                            const GLfloat *value)
1048 {
1049     ParamBuffer paramBuffer;
1050 
1051     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1052     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1053     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1054     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1055 
1056     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1057     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1058     CaptureProgramUniformMatrix2fv_value(context, isCallValid, program, location, count, transpose,
1059                                          value, &valueParam);
1060     paramBuffer.addParam(std::move(valueParam));
1061 
1062     return CallCapture(gl::EntryPoint::ProgramUniformMatrix2fv, std::move(paramBuffer));
1063 }
1064 
CaptureProgramUniformMatrix2x3fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1065 CallCapture CaptureProgramUniformMatrix2x3fv(const Context *context,
1066                                              bool isCallValid,
1067                                              GLuint program,
1068                                              GLint location,
1069                                              GLsizei count,
1070                                              GLboolean transpose,
1071                                              const GLfloat *value)
1072 {
1073     ParamBuffer paramBuffer;
1074 
1075     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1076     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1077     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1078     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1079 
1080     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1081     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1082     CaptureProgramUniformMatrix2x3fv_value(context, isCallValid, program, location, count,
1083                                            transpose, value, &valueParam);
1084     paramBuffer.addParam(std::move(valueParam));
1085 
1086     return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x3fv, std::move(paramBuffer));
1087 }
1088 
CaptureProgramUniformMatrix2x4fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1089 CallCapture CaptureProgramUniformMatrix2x4fv(const Context *context,
1090                                              bool isCallValid,
1091                                              GLuint program,
1092                                              GLint location,
1093                                              GLsizei count,
1094                                              GLboolean transpose,
1095                                              const GLfloat *value)
1096 {
1097     ParamBuffer paramBuffer;
1098 
1099     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1100     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1101     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1102     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1103 
1104     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1105     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1106     CaptureProgramUniformMatrix2x4fv_value(context, isCallValid, program, location, count,
1107                                            transpose, value, &valueParam);
1108     paramBuffer.addParam(std::move(valueParam));
1109 
1110     return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x4fv, std::move(paramBuffer));
1111 }
1112 
CaptureProgramUniformMatrix3fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1113 CallCapture CaptureProgramUniformMatrix3fv(const Context *context,
1114                                            bool isCallValid,
1115                                            GLuint program,
1116                                            GLint location,
1117                                            GLsizei count,
1118                                            GLboolean transpose,
1119                                            const GLfloat *value)
1120 {
1121     ParamBuffer paramBuffer;
1122 
1123     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1124     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1125     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1126     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1127 
1128     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1129     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1130     CaptureProgramUniformMatrix3fv_value(context, isCallValid, program, location, count, transpose,
1131                                          value, &valueParam);
1132     paramBuffer.addParam(std::move(valueParam));
1133 
1134     return CallCapture(gl::EntryPoint::ProgramUniformMatrix3fv, std::move(paramBuffer));
1135 }
1136 
CaptureProgramUniformMatrix3x2fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1137 CallCapture CaptureProgramUniformMatrix3x2fv(const Context *context,
1138                                              bool isCallValid,
1139                                              GLuint program,
1140                                              GLint location,
1141                                              GLsizei count,
1142                                              GLboolean transpose,
1143                                              const GLfloat *value)
1144 {
1145     ParamBuffer paramBuffer;
1146 
1147     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1148     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1149     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1150     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1151 
1152     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1153     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1154     CaptureProgramUniformMatrix3x2fv_value(context, isCallValid, program, location, count,
1155                                            transpose, value, &valueParam);
1156     paramBuffer.addParam(std::move(valueParam));
1157 
1158     return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x2fv, std::move(paramBuffer));
1159 }
1160 
CaptureProgramUniformMatrix3x4fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1161 CallCapture CaptureProgramUniformMatrix3x4fv(const Context *context,
1162                                              bool isCallValid,
1163                                              GLuint program,
1164                                              GLint location,
1165                                              GLsizei count,
1166                                              GLboolean transpose,
1167                                              const GLfloat *value)
1168 {
1169     ParamBuffer paramBuffer;
1170 
1171     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1172     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1173     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1174     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1175 
1176     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1177     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1178     CaptureProgramUniformMatrix3x4fv_value(context, isCallValid, program, location, count,
1179                                            transpose, value, &valueParam);
1180     paramBuffer.addParam(std::move(valueParam));
1181 
1182     return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x4fv, std::move(paramBuffer));
1183 }
1184 
CaptureProgramUniformMatrix4fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1185 CallCapture CaptureProgramUniformMatrix4fv(const Context *context,
1186                                            bool isCallValid,
1187                                            GLuint program,
1188                                            GLint location,
1189                                            GLsizei count,
1190                                            GLboolean transpose,
1191                                            const GLfloat *value)
1192 {
1193     ParamBuffer paramBuffer;
1194 
1195     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1196     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1197     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1198     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1199 
1200     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1201     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1202     CaptureProgramUniformMatrix4fv_value(context, isCallValid, program, location, count, transpose,
1203                                          value, &valueParam);
1204     paramBuffer.addParam(std::move(valueParam));
1205 
1206     return CallCapture(gl::EntryPoint::ProgramUniformMatrix4fv, std::move(paramBuffer));
1207 }
1208 
CaptureProgramUniformMatrix4x2fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1209 CallCapture CaptureProgramUniformMatrix4x2fv(const Context *context,
1210                                              bool isCallValid,
1211                                              GLuint program,
1212                                              GLint location,
1213                                              GLsizei count,
1214                                              GLboolean transpose,
1215                                              const GLfloat *value)
1216 {
1217     ParamBuffer paramBuffer;
1218 
1219     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1220     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1221     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1222     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1223 
1224     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1225     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1226     CaptureProgramUniformMatrix4x2fv_value(context, isCallValid, program, location, count,
1227                                            transpose, value, &valueParam);
1228     paramBuffer.addParam(std::move(valueParam));
1229 
1230     return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x2fv, std::move(paramBuffer));
1231 }
1232 
CaptureProgramUniformMatrix4x3fv(const Context * context,bool isCallValid,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1233 CallCapture CaptureProgramUniformMatrix4x3fv(const Context *context,
1234                                              bool isCallValid,
1235                                              GLuint program,
1236                                              GLint location,
1237                                              GLsizei count,
1238                                              GLboolean transpose,
1239                                              const GLfloat *value)
1240 {
1241     ParamBuffer paramBuffer;
1242 
1243     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1244     paramBuffer.addValueParam("location", ParamType::TGLint, location);
1245     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
1246     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
1247 
1248     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
1249     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
1250     CaptureProgramUniformMatrix4x3fv_value(context, isCallValid, program, location, count,
1251                                            transpose, value, &valueParam);
1252     paramBuffer.addParam(std::move(valueParam));
1253 
1254     return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x3fv, std::move(paramBuffer));
1255 }
1256 
CaptureSampleMaski(const Context * context,bool isCallValid,GLuint maskNumber,GLbitfield mask)1257 CallCapture CaptureSampleMaski(const Context *context,
1258                                bool isCallValid,
1259                                GLuint maskNumber,
1260                                GLbitfield mask)
1261 {
1262     ParamBuffer paramBuffer;
1263 
1264     paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber);
1265     paramBuffer.addEnumParam("mask", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, mask);
1266 
1267     return CallCapture(gl::EntryPoint::SampleMaski, std::move(paramBuffer));
1268 }
1269 
CaptureTexStorage2DMultisample(const Context * context,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)1270 CallCapture CaptureTexStorage2DMultisample(const Context *context,
1271                                            bool isCallValid,
1272                                            TextureType targetPacked,
1273                                            GLsizei samples,
1274                                            GLenum internalformat,
1275                                            GLsizei width,
1276                                            GLsizei height,
1277                                            GLboolean fixedsamplelocations)
1278 {
1279     ParamBuffer paramBuffer;
1280 
1281     paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
1282     paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
1283     paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
1284                              internalformat);
1285     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
1286     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
1287     paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
1288 
1289     return CallCapture(gl::EntryPoint::TexStorage2DMultisample, std::move(paramBuffer));
1290 }
1291 
CaptureUseProgramStages(const Context * context,bool isCallValid,GLuint pipeline,GLbitfield stages,GLuint program)1292 CallCapture CaptureUseProgramStages(const Context *context,
1293                                     bool isCallValid,
1294                                     GLuint pipeline,
1295                                     GLbitfield stages,
1296                                     GLuint program)
1297 {
1298     ParamBuffer paramBuffer;
1299 
1300     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
1301     paramBuffer.addEnumParam("stages", GLenumGroup::UseProgramStageMask, ParamType::TGLbitfield,
1302                              stages);
1303     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
1304 
1305     return CallCapture(gl::EntryPoint::UseProgramStages, std::move(paramBuffer));
1306 }
1307 
CaptureValidateProgramPipeline(const Context * context,bool isCallValid,GLuint pipeline)1308 CallCapture CaptureValidateProgramPipeline(const Context *context,
1309                                            bool isCallValid,
1310                                            GLuint pipeline)
1311 {
1312     ParamBuffer paramBuffer;
1313 
1314     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
1315 
1316     return CallCapture(gl::EntryPoint::ValidateProgramPipeline, std::move(paramBuffer));
1317 }
1318 
CaptureVertexAttribBinding(const Context * context,bool isCallValid,GLuint attribindex,GLuint bindingindex)1319 CallCapture CaptureVertexAttribBinding(const Context *context,
1320                                        bool isCallValid,
1321                                        GLuint attribindex,
1322                                        GLuint bindingindex)
1323 {
1324     ParamBuffer paramBuffer;
1325 
1326     paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
1327     paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
1328 
1329     return CallCapture(gl::EntryPoint::VertexAttribBinding, std::move(paramBuffer));
1330 }
1331 
CaptureVertexAttribFormat(const Context * context,bool isCallValid,GLuint attribindex,GLint size,VertexAttribType typePacked,GLboolean normalized,GLuint relativeoffset)1332 CallCapture CaptureVertexAttribFormat(const Context *context,
1333                                       bool isCallValid,
1334                                       GLuint attribindex,
1335                                       GLint size,
1336                                       VertexAttribType typePacked,
1337                                       GLboolean normalized,
1338                                       GLuint relativeoffset)
1339 {
1340     ParamBuffer paramBuffer;
1341 
1342     paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
1343     paramBuffer.addValueParam("size", ParamType::TGLint, size);
1344     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
1345     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
1346     paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
1347 
1348     return CallCapture(gl::EntryPoint::VertexAttribFormat, std::move(paramBuffer));
1349 }
1350 
CaptureVertexAttribIFormat(const Context * context,bool isCallValid,GLuint attribindex,GLint size,VertexAttribType typePacked,GLuint relativeoffset)1351 CallCapture CaptureVertexAttribIFormat(const Context *context,
1352                                        bool isCallValid,
1353                                        GLuint attribindex,
1354                                        GLint size,
1355                                        VertexAttribType typePacked,
1356                                        GLuint relativeoffset)
1357 {
1358     ParamBuffer paramBuffer;
1359 
1360     paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
1361     paramBuffer.addValueParam("size", ParamType::TGLint, size);
1362     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
1363     paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
1364 
1365     return CallCapture(gl::EntryPoint::VertexAttribIFormat, std::move(paramBuffer));
1366 }
1367 
CaptureVertexBindingDivisor(const Context * context,bool isCallValid,GLuint bindingindex,GLuint divisor)1368 CallCapture CaptureVertexBindingDivisor(const Context *context,
1369                                         bool isCallValid,
1370                                         GLuint bindingindex,
1371                                         GLuint divisor)
1372 {
1373     ParamBuffer paramBuffer;
1374 
1375     paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
1376     paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
1377 
1378     return CallCapture(gl::EntryPoint::VertexBindingDivisor, std::move(paramBuffer));
1379 }
1380 
1381 }  // namespace gl
1382