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