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_gl_2_autogen.cpp:
9 // Capture functions for the OpenGL ES Desktop GL 2.x entry points.
10
11 #include "libANGLE/capture/capture_gl_2_autogen.h"
12
13 #include "common/gl_enum_utils.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 #include "libANGLE/validationGL2_autogen.h"
17
18 using namespace angle;
19
20 namespace gl
21 {
22
23 // GL 2.0
CaptureGetVertexAttribdv(const State & glState,bool isCallValid,GLuint index,GLenum pname,GLdouble * params)24 CallCapture CaptureGetVertexAttribdv(const State &glState,
25 bool isCallValid,
26 GLuint index,
27 GLenum pname,
28 GLdouble *params)
29 {
30 ParamBuffer paramBuffer;
31
32 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
33 paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname);
34
35 if (isCallValid)
36 {
37 ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
38 InitParamValue(ParamType::TGLdoublePointer, params, ¶msParam.value);
39 CaptureGetVertexAttribdv_params(glState, isCallValid, index, pname, params, ¶msParam);
40 paramBuffer.addParam(std::move(paramsParam));
41 }
42 else
43 {
44 ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
45 InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr),
46 ¶msParam.value);
47 paramBuffer.addParam(std::move(paramsParam));
48 }
49
50 return CallCapture(angle::EntryPoint::GLGetVertexAttribdv, std::move(paramBuffer));
51 }
52
CaptureVertexAttrib1d(const State & glState,bool isCallValid,GLuint index,GLdouble x)53 CallCapture CaptureVertexAttrib1d(const State &glState, bool isCallValid, GLuint index, GLdouble x)
54 {
55 ParamBuffer paramBuffer;
56
57 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
58 paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
59
60 return CallCapture(angle::EntryPoint::GLVertexAttrib1d, std::move(paramBuffer));
61 }
62
CaptureVertexAttrib1dv(const State & glState,bool isCallValid,GLuint index,const GLdouble * v)63 CallCapture CaptureVertexAttrib1dv(const State &glState,
64 bool isCallValid,
65 GLuint index,
66 const GLdouble *v)
67 {
68 ParamBuffer paramBuffer;
69
70 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
71
72 if (isCallValid)
73 {
74 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
75 InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
76 CaptureVertexAttrib1dv_v(glState, isCallValid, index, v, &vParam);
77 paramBuffer.addParam(std::move(vParam));
78 }
79 else
80 {
81 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
82 InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
83 &vParam.value);
84 paramBuffer.addParam(std::move(vParam));
85 }
86
87 return CallCapture(angle::EntryPoint::GLVertexAttrib1dv, std::move(paramBuffer));
88 }
89
CaptureVertexAttrib1s(const State & glState,bool isCallValid,GLuint index,GLshort x)90 CallCapture CaptureVertexAttrib1s(const State &glState, bool isCallValid, GLuint index, GLshort x)
91 {
92 ParamBuffer paramBuffer;
93
94 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
95 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
96
97 return CallCapture(angle::EntryPoint::GLVertexAttrib1s, std::move(paramBuffer));
98 }
99
CaptureVertexAttrib1sv(const State & glState,bool isCallValid,GLuint index,const GLshort * v)100 CallCapture CaptureVertexAttrib1sv(const State &glState,
101 bool isCallValid,
102 GLuint index,
103 const GLshort *v)
104 {
105 ParamBuffer paramBuffer;
106
107 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
108
109 if (isCallValid)
110 {
111 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
112 InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
113 CaptureVertexAttrib1sv_v(glState, isCallValid, index, v, &vParam);
114 paramBuffer.addParam(std::move(vParam));
115 }
116 else
117 {
118 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
119 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
120 &vParam.value);
121 paramBuffer.addParam(std::move(vParam));
122 }
123
124 return CallCapture(angle::EntryPoint::GLVertexAttrib1sv, std::move(paramBuffer));
125 }
126
CaptureVertexAttrib2d(const State & glState,bool isCallValid,GLuint index,GLdouble x,GLdouble y)127 CallCapture CaptureVertexAttrib2d(const State &glState,
128 bool isCallValid,
129 GLuint index,
130 GLdouble x,
131 GLdouble y)
132 {
133 ParamBuffer paramBuffer;
134
135 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
136 paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
137 paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
138
139 return CallCapture(angle::EntryPoint::GLVertexAttrib2d, std::move(paramBuffer));
140 }
141
CaptureVertexAttrib2dv(const State & glState,bool isCallValid,GLuint index,const GLdouble * v)142 CallCapture CaptureVertexAttrib2dv(const State &glState,
143 bool isCallValid,
144 GLuint index,
145 const GLdouble *v)
146 {
147 ParamBuffer paramBuffer;
148
149 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
150
151 if (isCallValid)
152 {
153 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
154 InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
155 CaptureVertexAttrib2dv_v(glState, isCallValid, index, v, &vParam);
156 paramBuffer.addParam(std::move(vParam));
157 }
158 else
159 {
160 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
161 InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
162 &vParam.value);
163 paramBuffer.addParam(std::move(vParam));
164 }
165
166 return CallCapture(angle::EntryPoint::GLVertexAttrib2dv, std::move(paramBuffer));
167 }
168
CaptureVertexAttrib2s(const State & glState,bool isCallValid,GLuint index,GLshort x,GLshort y)169 CallCapture CaptureVertexAttrib2s(const State &glState,
170 bool isCallValid,
171 GLuint index,
172 GLshort x,
173 GLshort y)
174 {
175 ParamBuffer paramBuffer;
176
177 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
178 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
179 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
180
181 return CallCapture(angle::EntryPoint::GLVertexAttrib2s, std::move(paramBuffer));
182 }
183
CaptureVertexAttrib2sv(const State & glState,bool isCallValid,GLuint index,const GLshort * v)184 CallCapture CaptureVertexAttrib2sv(const State &glState,
185 bool isCallValid,
186 GLuint index,
187 const GLshort *v)
188 {
189 ParamBuffer paramBuffer;
190
191 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
192
193 if (isCallValid)
194 {
195 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
196 InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
197 CaptureVertexAttrib2sv_v(glState, isCallValid, index, v, &vParam);
198 paramBuffer.addParam(std::move(vParam));
199 }
200 else
201 {
202 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
203 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
204 &vParam.value);
205 paramBuffer.addParam(std::move(vParam));
206 }
207
208 return CallCapture(angle::EntryPoint::GLVertexAttrib2sv, std::move(paramBuffer));
209 }
210
CaptureVertexAttrib3d(const State & glState,bool isCallValid,GLuint index,GLdouble x,GLdouble y,GLdouble z)211 CallCapture CaptureVertexAttrib3d(const State &glState,
212 bool isCallValid,
213 GLuint index,
214 GLdouble x,
215 GLdouble y,
216 GLdouble z)
217 {
218 ParamBuffer paramBuffer;
219
220 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
221 paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
222 paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
223 paramBuffer.addValueParam("z", ParamType::TGLdouble, z);
224
225 return CallCapture(angle::EntryPoint::GLVertexAttrib3d, std::move(paramBuffer));
226 }
227
CaptureVertexAttrib3dv(const State & glState,bool isCallValid,GLuint index,const GLdouble * v)228 CallCapture CaptureVertexAttrib3dv(const State &glState,
229 bool isCallValid,
230 GLuint index,
231 const GLdouble *v)
232 {
233 ParamBuffer paramBuffer;
234
235 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
236
237 if (isCallValid)
238 {
239 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
240 InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
241 CaptureVertexAttrib3dv_v(glState, isCallValid, index, v, &vParam);
242 paramBuffer.addParam(std::move(vParam));
243 }
244 else
245 {
246 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
247 InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
248 &vParam.value);
249 paramBuffer.addParam(std::move(vParam));
250 }
251
252 return CallCapture(angle::EntryPoint::GLVertexAttrib3dv, std::move(paramBuffer));
253 }
254
CaptureVertexAttrib3s(const State & glState,bool isCallValid,GLuint index,GLshort x,GLshort y,GLshort z)255 CallCapture CaptureVertexAttrib3s(const State &glState,
256 bool isCallValid,
257 GLuint index,
258 GLshort x,
259 GLshort y,
260 GLshort z)
261 {
262 ParamBuffer paramBuffer;
263
264 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
265 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
266 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
267 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
268
269 return CallCapture(angle::EntryPoint::GLVertexAttrib3s, std::move(paramBuffer));
270 }
271
CaptureVertexAttrib3sv(const State & glState,bool isCallValid,GLuint index,const GLshort * v)272 CallCapture CaptureVertexAttrib3sv(const State &glState,
273 bool isCallValid,
274 GLuint index,
275 const GLshort *v)
276 {
277 ParamBuffer paramBuffer;
278
279 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
280
281 if (isCallValid)
282 {
283 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
284 InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
285 CaptureVertexAttrib3sv_v(glState, isCallValid, index, v, &vParam);
286 paramBuffer.addParam(std::move(vParam));
287 }
288 else
289 {
290 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
291 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
292 &vParam.value);
293 paramBuffer.addParam(std::move(vParam));
294 }
295
296 return CallCapture(angle::EntryPoint::GLVertexAttrib3sv, std::move(paramBuffer));
297 }
298
CaptureVertexAttrib4Nbv(const State & glState,bool isCallValid,GLuint index,const GLbyte * v)299 CallCapture CaptureVertexAttrib4Nbv(const State &glState,
300 bool isCallValid,
301 GLuint index,
302 const GLbyte *v)
303 {
304 ParamBuffer paramBuffer;
305
306 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
307
308 if (isCallValid)
309 {
310 ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
311 InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value);
312 CaptureVertexAttrib4Nbv_v(glState, isCallValid, index, v, &vParam);
313 paramBuffer.addParam(std::move(vParam));
314 }
315 else
316 {
317 ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
318 InitParamValue(ParamType::TGLbyteConstPointer, static_cast<const GLbyte *>(nullptr),
319 &vParam.value);
320 paramBuffer.addParam(std::move(vParam));
321 }
322
323 return CallCapture(angle::EntryPoint::GLVertexAttrib4Nbv, std::move(paramBuffer));
324 }
325
CaptureVertexAttrib4Niv(const State & glState,bool isCallValid,GLuint index,const GLint * v)326 CallCapture CaptureVertexAttrib4Niv(const State &glState,
327 bool isCallValid,
328 GLuint index,
329 const GLint *v)
330 {
331 ParamBuffer paramBuffer;
332
333 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
334
335 if (isCallValid)
336 {
337 ParamCapture vParam("v", ParamType::TGLintConstPointer);
338 InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
339 CaptureVertexAttrib4Niv_v(glState, isCallValid, index, v, &vParam);
340 paramBuffer.addParam(std::move(vParam));
341 }
342 else
343 {
344 ParamCapture vParam("v", ParamType::TGLintConstPointer);
345 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
346 &vParam.value);
347 paramBuffer.addParam(std::move(vParam));
348 }
349
350 return CallCapture(angle::EntryPoint::GLVertexAttrib4Niv, std::move(paramBuffer));
351 }
352
CaptureVertexAttrib4Nsv(const State & glState,bool isCallValid,GLuint index,const GLshort * v)353 CallCapture CaptureVertexAttrib4Nsv(const State &glState,
354 bool isCallValid,
355 GLuint index,
356 const GLshort *v)
357 {
358 ParamBuffer paramBuffer;
359
360 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
361
362 if (isCallValid)
363 {
364 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
365 InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
366 CaptureVertexAttrib4Nsv_v(glState, isCallValid, index, v, &vParam);
367 paramBuffer.addParam(std::move(vParam));
368 }
369 else
370 {
371 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
372 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
373 &vParam.value);
374 paramBuffer.addParam(std::move(vParam));
375 }
376
377 return CallCapture(angle::EntryPoint::GLVertexAttrib4Nsv, std::move(paramBuffer));
378 }
379
CaptureVertexAttrib4Nub(const State & glState,bool isCallValid,GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)380 CallCapture CaptureVertexAttrib4Nub(const State &glState,
381 bool isCallValid,
382 GLuint index,
383 GLubyte x,
384 GLubyte y,
385 GLubyte z,
386 GLubyte w)
387 {
388 ParamBuffer paramBuffer;
389
390 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
391 paramBuffer.addValueParam("x", ParamType::TGLubyte, x);
392 paramBuffer.addValueParam("y", ParamType::TGLubyte, y);
393 paramBuffer.addValueParam("z", ParamType::TGLubyte, z);
394 paramBuffer.addValueParam("w", ParamType::TGLubyte, w);
395
396 return CallCapture(angle::EntryPoint::GLVertexAttrib4Nub, std::move(paramBuffer));
397 }
398
CaptureVertexAttrib4Nubv(const State & glState,bool isCallValid,GLuint index,const GLubyte * v)399 CallCapture CaptureVertexAttrib4Nubv(const State &glState,
400 bool isCallValid,
401 GLuint index,
402 const GLubyte *v)
403 {
404 ParamBuffer paramBuffer;
405
406 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
407
408 if (isCallValid)
409 {
410 ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
411 InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value);
412 CaptureVertexAttrib4Nubv_v(glState, isCallValid, index, v, &vParam);
413 paramBuffer.addParam(std::move(vParam));
414 }
415 else
416 {
417 ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
418 InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr),
419 &vParam.value);
420 paramBuffer.addParam(std::move(vParam));
421 }
422
423 return CallCapture(angle::EntryPoint::GLVertexAttrib4Nubv, std::move(paramBuffer));
424 }
425
CaptureVertexAttrib4Nuiv(const State & glState,bool isCallValid,GLuint index,const GLuint * v)426 CallCapture CaptureVertexAttrib4Nuiv(const State &glState,
427 bool isCallValid,
428 GLuint index,
429 const GLuint *v)
430 {
431 ParamBuffer paramBuffer;
432
433 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
434
435 if (isCallValid)
436 {
437 ParamCapture vParam("v", ParamType::TGLuintConstPointer);
438 InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
439 CaptureVertexAttrib4Nuiv_v(glState, isCallValid, index, v, &vParam);
440 paramBuffer.addParam(std::move(vParam));
441 }
442 else
443 {
444 ParamCapture vParam("v", ParamType::TGLuintConstPointer);
445 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
446 &vParam.value);
447 paramBuffer.addParam(std::move(vParam));
448 }
449
450 return CallCapture(angle::EntryPoint::GLVertexAttrib4Nuiv, std::move(paramBuffer));
451 }
452
CaptureVertexAttrib4Nusv(const State & glState,bool isCallValid,GLuint index,const GLushort * v)453 CallCapture CaptureVertexAttrib4Nusv(const State &glState,
454 bool isCallValid,
455 GLuint index,
456 const GLushort *v)
457 {
458 ParamBuffer paramBuffer;
459
460 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
461
462 if (isCallValid)
463 {
464 ParamCapture vParam("v", ParamType::TGLushortConstPointer);
465 InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value);
466 CaptureVertexAttrib4Nusv_v(glState, isCallValid, index, v, &vParam);
467 paramBuffer.addParam(std::move(vParam));
468 }
469 else
470 {
471 ParamCapture vParam("v", ParamType::TGLushortConstPointer);
472 InitParamValue(ParamType::TGLushortConstPointer, static_cast<const GLushort *>(nullptr),
473 &vParam.value);
474 paramBuffer.addParam(std::move(vParam));
475 }
476
477 return CallCapture(angle::EntryPoint::GLVertexAttrib4Nusv, std::move(paramBuffer));
478 }
479
CaptureVertexAttrib4bv(const State & glState,bool isCallValid,GLuint index,const GLbyte * v)480 CallCapture CaptureVertexAttrib4bv(const State &glState,
481 bool isCallValid,
482 GLuint index,
483 const GLbyte *v)
484 {
485 ParamBuffer paramBuffer;
486
487 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
488
489 if (isCallValid)
490 {
491 ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
492 InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value);
493 CaptureVertexAttrib4bv_v(glState, isCallValid, index, v, &vParam);
494 paramBuffer.addParam(std::move(vParam));
495 }
496 else
497 {
498 ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
499 InitParamValue(ParamType::TGLbyteConstPointer, static_cast<const GLbyte *>(nullptr),
500 &vParam.value);
501 paramBuffer.addParam(std::move(vParam));
502 }
503
504 return CallCapture(angle::EntryPoint::GLVertexAttrib4bv, std::move(paramBuffer));
505 }
506
CaptureVertexAttrib4d(const State & glState,bool isCallValid,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)507 CallCapture CaptureVertexAttrib4d(const State &glState,
508 bool isCallValid,
509 GLuint index,
510 GLdouble x,
511 GLdouble y,
512 GLdouble z,
513 GLdouble w)
514 {
515 ParamBuffer paramBuffer;
516
517 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
518 paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
519 paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
520 paramBuffer.addValueParam("z", ParamType::TGLdouble, z);
521 paramBuffer.addValueParam("w", ParamType::TGLdouble, w);
522
523 return CallCapture(angle::EntryPoint::GLVertexAttrib4d, std::move(paramBuffer));
524 }
525
CaptureVertexAttrib4dv(const State & glState,bool isCallValid,GLuint index,const GLdouble * v)526 CallCapture CaptureVertexAttrib4dv(const State &glState,
527 bool isCallValid,
528 GLuint index,
529 const GLdouble *v)
530 {
531 ParamBuffer paramBuffer;
532
533 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
534
535 if (isCallValid)
536 {
537 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
538 InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
539 CaptureVertexAttrib4dv_v(glState, isCallValid, index, v, &vParam);
540 paramBuffer.addParam(std::move(vParam));
541 }
542 else
543 {
544 ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
545 InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
546 &vParam.value);
547 paramBuffer.addParam(std::move(vParam));
548 }
549
550 return CallCapture(angle::EntryPoint::GLVertexAttrib4dv, std::move(paramBuffer));
551 }
552
CaptureVertexAttrib4iv(const State & glState,bool isCallValid,GLuint index,const GLint * v)553 CallCapture CaptureVertexAttrib4iv(const State &glState,
554 bool isCallValid,
555 GLuint index,
556 const GLint *v)
557 {
558 ParamBuffer paramBuffer;
559
560 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
561
562 if (isCallValid)
563 {
564 ParamCapture vParam("v", ParamType::TGLintConstPointer);
565 InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
566 CaptureVertexAttrib4iv_v(glState, isCallValid, index, v, &vParam);
567 paramBuffer.addParam(std::move(vParam));
568 }
569 else
570 {
571 ParamCapture vParam("v", ParamType::TGLintConstPointer);
572 InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
573 &vParam.value);
574 paramBuffer.addParam(std::move(vParam));
575 }
576
577 return CallCapture(angle::EntryPoint::GLVertexAttrib4iv, std::move(paramBuffer));
578 }
579
CaptureVertexAttrib4s(const State & glState,bool isCallValid,GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)580 CallCapture CaptureVertexAttrib4s(const State &glState,
581 bool isCallValid,
582 GLuint index,
583 GLshort x,
584 GLshort y,
585 GLshort z,
586 GLshort w)
587 {
588 ParamBuffer paramBuffer;
589
590 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
591 paramBuffer.addValueParam("x", ParamType::TGLshort, x);
592 paramBuffer.addValueParam("y", ParamType::TGLshort, y);
593 paramBuffer.addValueParam("z", ParamType::TGLshort, z);
594 paramBuffer.addValueParam("w", ParamType::TGLshort, w);
595
596 return CallCapture(angle::EntryPoint::GLVertexAttrib4s, std::move(paramBuffer));
597 }
598
CaptureVertexAttrib4sv(const State & glState,bool isCallValid,GLuint index,const GLshort * v)599 CallCapture CaptureVertexAttrib4sv(const State &glState,
600 bool isCallValid,
601 GLuint index,
602 const GLshort *v)
603 {
604 ParamBuffer paramBuffer;
605
606 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
607
608 if (isCallValid)
609 {
610 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
611 InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
612 CaptureVertexAttrib4sv_v(glState, isCallValid, index, v, &vParam);
613 paramBuffer.addParam(std::move(vParam));
614 }
615 else
616 {
617 ParamCapture vParam("v", ParamType::TGLshortConstPointer);
618 InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
619 &vParam.value);
620 paramBuffer.addParam(std::move(vParam));
621 }
622
623 return CallCapture(angle::EntryPoint::GLVertexAttrib4sv, std::move(paramBuffer));
624 }
625
CaptureVertexAttrib4ubv(const State & glState,bool isCallValid,GLuint index,const GLubyte * v)626 CallCapture CaptureVertexAttrib4ubv(const State &glState,
627 bool isCallValid,
628 GLuint index,
629 const GLubyte *v)
630 {
631 ParamBuffer paramBuffer;
632
633 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
634
635 if (isCallValid)
636 {
637 ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
638 InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value);
639 CaptureVertexAttrib4ubv_v(glState, isCallValid, index, v, &vParam);
640 paramBuffer.addParam(std::move(vParam));
641 }
642 else
643 {
644 ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
645 InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr),
646 &vParam.value);
647 paramBuffer.addParam(std::move(vParam));
648 }
649
650 return CallCapture(angle::EntryPoint::GLVertexAttrib4ubv, std::move(paramBuffer));
651 }
652
CaptureVertexAttrib4uiv(const State & glState,bool isCallValid,GLuint index,const GLuint * v)653 CallCapture CaptureVertexAttrib4uiv(const State &glState,
654 bool isCallValid,
655 GLuint index,
656 const GLuint *v)
657 {
658 ParamBuffer paramBuffer;
659
660 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
661
662 if (isCallValid)
663 {
664 ParamCapture vParam("v", ParamType::TGLuintConstPointer);
665 InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
666 CaptureVertexAttrib4uiv_v(glState, isCallValid, index, v, &vParam);
667 paramBuffer.addParam(std::move(vParam));
668 }
669 else
670 {
671 ParamCapture vParam("v", ParamType::TGLuintConstPointer);
672 InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
673 &vParam.value);
674 paramBuffer.addParam(std::move(vParam));
675 }
676
677 return CallCapture(angle::EntryPoint::GLVertexAttrib4uiv, std::move(paramBuffer));
678 }
679
CaptureVertexAttrib4usv(const State & glState,bool isCallValid,GLuint index,const GLushort * v)680 CallCapture CaptureVertexAttrib4usv(const State &glState,
681 bool isCallValid,
682 GLuint index,
683 const GLushort *v)
684 {
685 ParamBuffer paramBuffer;
686
687 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
688
689 if (isCallValid)
690 {
691 ParamCapture vParam("v", ParamType::TGLushortConstPointer);
692 InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value);
693 CaptureVertexAttrib4usv_v(glState, isCallValid, index, v, &vParam);
694 paramBuffer.addParam(std::move(vParam));
695 }
696 else
697 {
698 ParamCapture vParam("v", ParamType::TGLushortConstPointer);
699 InitParamValue(ParamType::TGLushortConstPointer, static_cast<const GLushort *>(nullptr),
700 &vParam.value);
701 paramBuffer.addParam(std::move(vParam));
702 }
703
704 return CallCapture(angle::EntryPoint::GLVertexAttrib4usv, std::move(paramBuffer));
705 }
706
707 // GL 2.1
708 } // namespace gl
709