1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.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 // entry_points_gl_3_autogen.cpp:
9 // Defines the Desktop GL 3.x entry points.
10
11 #include "libGLESv2/entry_points_gl_3_autogen.h"
12
13 #include "common/gl_enum_utils.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/Context.inl.h"
16 #include "libANGLE/capture/capture_gl_3_autogen.h"
17 #include "libANGLE/context_private_call_gl_autogen.h"
18 #include "libANGLE/context_private_call_gles_autogen.h"
19 #include "libANGLE/entry_points_utils.h"
20 #include "libANGLE/validationEGL.h"
21 #include "libANGLE/validationES.h"
22 #include "libANGLE/validationES1.h"
23 #include "libANGLE/validationES2.h"
24 #include "libANGLE/validationES3.h"
25 #include "libANGLE/validationES31.h"
26 #include "libANGLE/validationES32.h"
27 #include "libANGLE/validationESEXT.h"
28 #include "libANGLE/validationGL3_autogen.h"
29 #include "libGLESv2/global_state.h"
30
31 using namespace gl;
32
33 extern "C" {
34
35 // GL 3.0
GL_BeginConditionalRender(GLuint id,GLenum mode)36 void GL_APIENTRY GL_BeginConditionalRender(GLuint id, GLenum mode)
37 {
38 Context *context = GetValidGlobalContext();
39 EVENT(context, GLBeginConditionalRender, "context = %d, id = %u, mode = %s", CID(context), id,
40 GLenumToString(BigGLEnum::ConditionalRenderMode, mode));
41
42 if (context)
43 {
44 SCOPED_SHARE_CONTEXT_LOCK(context);
45 bool isCallValid =
46 (context->skipValidation() ||
47 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
48 context->getMutableErrorSetForValidation(),
49 angle::EntryPoint::GLBeginConditionalRender) &&
50 ValidateBeginConditionalRender(context, angle::EntryPoint::GLBeginConditionalRender,
51 id, mode)));
52 if (isCallValid)
53 {
54 context->beginConditionalRender(id, mode);
55 }
56 ANGLE_CAPTURE_GL(BeginConditionalRender, isCallValid, context, id, mode);
57 }
58 else
59 {
60 GenerateContextLostErrorOnCurrentGlobalContext();
61 }
62 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
63 }
64
GL_BindFragDataLocation(GLuint program,GLuint color,const GLchar * name)65 void GL_APIENTRY GL_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
66 {
67 Context *context = GetValidGlobalContext();
68 EVENT(context, GLBindFragDataLocation,
69 "context = %d, program = %u, color = %u, name = 0x%016" PRIxPTR "", CID(context), program,
70 color, (uintptr_t)name);
71
72 if (context)
73 {
74 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
75 SCOPED_SHARE_CONTEXT_LOCK(context);
76 bool isCallValid =
77 (context->skipValidation() ||
78 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
79 context->getMutableErrorSetForValidation(),
80 angle::EntryPoint::GLBindFragDataLocation) &&
81 ValidateBindFragDataLocation(context, angle::EntryPoint::GLBindFragDataLocation,
82 programPacked, color, name)));
83 if (isCallValid)
84 {
85 context->bindFragDataLocation(programPacked, color, name);
86 }
87 ANGLE_CAPTURE_GL(BindFragDataLocation, isCallValid, context, programPacked, color, name);
88 }
89 else
90 {
91 GenerateContextLostErrorOnCurrentGlobalContext();
92 }
93 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
94 }
95
GL_ClampColor(GLenum target,GLenum clamp)96 void GL_APIENTRY GL_ClampColor(GLenum target, GLenum clamp)
97 {
98 Context *context = GetValidGlobalContext();
99 EVENT(context, GLClampColor, "context = %d, target = %s, clamp = %s", CID(context),
100 GLenumToString(BigGLEnum::AllEnums, target), GLenumToString(BigGLEnum::AllEnums, clamp));
101
102 if (context)
103 {
104 SCOPED_SHARE_CONTEXT_LOCK(context);
105 bool isCallValid =
106 (context->skipValidation() ||
107 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
108 context->getMutableErrorSetForValidation(),
109 angle::EntryPoint::GLClampColor) &&
110 ValidateClampColor(context, angle::EntryPoint::GLClampColor, target, clamp)));
111 if (isCallValid)
112 {
113 context->clampColor(target, clamp);
114 }
115 ANGLE_CAPTURE_GL(ClampColor, isCallValid, context, target, clamp);
116 }
117 else
118 {
119 GenerateContextLostErrorOnCurrentGlobalContext();
120 }
121 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
122 }
123
GL_EndConditionalRender()124 void GL_APIENTRY GL_EndConditionalRender()
125 {
126 Context *context = GetValidGlobalContext();
127 EVENT(context, GLEndConditionalRender, "context = %d", CID(context));
128
129 if (context)
130 {
131 SCOPED_SHARE_CONTEXT_LOCK(context);
132 bool isCallValid =
133 (context->skipValidation() ||
134 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
135 context->getMutableErrorSetForValidation(),
136 angle::EntryPoint::GLEndConditionalRender) &&
137 ValidateEndConditionalRender(context, angle::EntryPoint::GLEndConditionalRender)));
138 if (isCallValid)
139 {
140 context->endConditionalRender();
141 }
142 ANGLE_CAPTURE_GL(EndConditionalRender, isCallValid, context);
143 }
144 else
145 {
146 GenerateContextLostErrorOnCurrentGlobalContext();
147 }
148 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
149 }
150
GL_FramebufferTexture1D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)151 void GL_APIENTRY GL_FramebufferTexture1D(GLenum target,
152 GLenum attachment,
153 GLenum textarget,
154 GLuint texture,
155 GLint level)
156 {
157 Context *context = GetValidGlobalContext();
158 EVENT(context, GLFramebufferTexture1D,
159 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
160 CID(context), GLenumToString(BigGLEnum::FramebufferTarget, target),
161 GLenumToString(BigGLEnum::FramebufferAttachment, attachment),
162 GLenumToString(BigGLEnum::TextureTarget, textarget), texture, level);
163
164 if (context)
165 {
166 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
167 TextureID texturePacked = PackParam<TextureID>(texture);
168 SCOPED_SHARE_CONTEXT_LOCK(context);
169 bool isCallValid =
170 (context->skipValidation() ||
171 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
172 context->getMutableErrorSetForValidation(),
173 angle::EntryPoint::GLFramebufferTexture1D) &&
174 ValidateFramebufferTexture1D(context, angle::EntryPoint::GLFramebufferTexture1D,
175 target, attachment, textargetPacked, texturePacked,
176 level)));
177 if (isCallValid)
178 {
179 context->framebufferTexture1D(target, attachment, textargetPacked, texturePacked,
180 level);
181 }
182 ANGLE_CAPTURE_GL(FramebufferTexture1D, isCallValid, context, target, attachment,
183 textargetPacked, texturePacked, level);
184 }
185 else
186 {
187 GenerateContextLostErrorOnCurrentGlobalContext();
188 }
189 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
190 }
191
GL_FramebufferTexture3D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)192 void GL_APIENTRY GL_FramebufferTexture3D(GLenum target,
193 GLenum attachment,
194 GLenum textarget,
195 GLuint texture,
196 GLint level,
197 GLint zoffset)
198 {
199 Context *context = GetValidGlobalContext();
200 EVENT(context, GLFramebufferTexture3D,
201 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
202 "zoffset = %d",
203 CID(context), GLenumToString(BigGLEnum::FramebufferTarget, target),
204 GLenumToString(BigGLEnum::FramebufferAttachment, attachment),
205 GLenumToString(BigGLEnum::TextureTarget, textarget), texture, level, zoffset);
206
207 if (context)
208 {
209 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
210 TextureID texturePacked = PackParam<TextureID>(texture);
211 SCOPED_SHARE_CONTEXT_LOCK(context);
212 bool isCallValid =
213 (context->skipValidation() ||
214 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
215 context->getMutableErrorSetForValidation(),
216 angle::EntryPoint::GLFramebufferTexture3D) &&
217 ValidateFramebufferTexture3D(context, angle::EntryPoint::GLFramebufferTexture3D,
218 target, attachment, textargetPacked, texturePacked,
219 level, zoffset)));
220 if (isCallValid)
221 {
222 context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
223 zoffset);
224 }
225 ANGLE_CAPTURE_GL(FramebufferTexture3D, isCallValid, context, target, attachment,
226 textargetPacked, texturePacked, level, zoffset);
227 }
228 else
229 {
230 GenerateContextLostErrorOnCurrentGlobalContext();
231 }
232 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
233 }
234
GL_VertexAttribI1i(GLuint index,GLint x)235 void GL_APIENTRY GL_VertexAttribI1i(GLuint index, GLint x)
236 {
237 Context *context = GetValidGlobalContext();
238 EVENT(context, GLVertexAttribI1i, "context = %d, index = %u, x = %d", CID(context), index, x);
239
240 if (context)
241 {
242 bool isCallValid =
243 (context->skipValidation() ||
244 ValidateVertexAttribI1i(context->getPrivateState(),
245 context->getMutableErrorSetForValidation(),
246 angle::EntryPoint::GLVertexAttribI1i, index, x));
247 if (isCallValid)
248 {
249 ContextPrivateVertexAttribI1i(context->getMutablePrivateState(),
250 context->getMutablePrivateStateCache(), index, x);
251 }
252 ANGLE_CAPTURE_GL(VertexAttribI1i, isCallValid, context, index, x);
253 }
254 else
255 {
256 GenerateContextLostErrorOnCurrentGlobalContext();
257 }
258 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
259 }
260
GL_VertexAttribI1iv(GLuint index,const GLint * v)261 void GL_APIENTRY GL_VertexAttribI1iv(GLuint index, const GLint *v)
262 {
263 Context *context = GetValidGlobalContext();
264 EVENT(context, GLVertexAttribI1iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
265 CID(context), index, (uintptr_t)v);
266
267 if (context)
268 {
269 bool isCallValid =
270 (context->skipValidation() ||
271 ValidateVertexAttribI1iv(context->getPrivateState(),
272 context->getMutableErrorSetForValidation(),
273 angle::EntryPoint::GLVertexAttribI1iv, index, v));
274 if (isCallValid)
275 {
276 ContextPrivateVertexAttribI1iv(context->getMutablePrivateState(),
277 context->getMutablePrivateStateCache(), index, v);
278 }
279 ANGLE_CAPTURE_GL(VertexAttribI1iv, isCallValid, context, index, v);
280 }
281 else
282 {
283 GenerateContextLostErrorOnCurrentGlobalContext();
284 }
285 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
286 }
287
GL_VertexAttribI1ui(GLuint index,GLuint x)288 void GL_APIENTRY GL_VertexAttribI1ui(GLuint index, GLuint x)
289 {
290 Context *context = GetValidGlobalContext();
291 EVENT(context, GLVertexAttribI1ui, "context = %d, index = %u, x = %u", CID(context), index, x);
292
293 if (context)
294 {
295 bool isCallValid =
296 (context->skipValidation() ||
297 ValidateVertexAttribI1ui(context->getPrivateState(),
298 context->getMutableErrorSetForValidation(),
299 angle::EntryPoint::GLVertexAttribI1ui, index, x));
300 if (isCallValid)
301 {
302 ContextPrivateVertexAttribI1ui(context->getMutablePrivateState(),
303 context->getMutablePrivateStateCache(), index, x);
304 }
305 ANGLE_CAPTURE_GL(VertexAttribI1ui, isCallValid, context, index, x);
306 }
307 else
308 {
309 GenerateContextLostErrorOnCurrentGlobalContext();
310 }
311 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
312 }
313
GL_VertexAttribI1uiv(GLuint index,const GLuint * v)314 void GL_APIENTRY GL_VertexAttribI1uiv(GLuint index, const GLuint *v)
315 {
316 Context *context = GetValidGlobalContext();
317 EVENT(context, GLVertexAttribI1uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
318 CID(context), index, (uintptr_t)v);
319
320 if (context)
321 {
322 bool isCallValid =
323 (context->skipValidation() ||
324 ValidateVertexAttribI1uiv(context->getPrivateState(),
325 context->getMutableErrorSetForValidation(),
326 angle::EntryPoint::GLVertexAttribI1uiv, index, v));
327 if (isCallValid)
328 {
329 ContextPrivateVertexAttribI1uiv(context->getMutablePrivateState(),
330 context->getMutablePrivateStateCache(), index, v);
331 }
332 ANGLE_CAPTURE_GL(VertexAttribI1uiv, isCallValid, context, index, v);
333 }
334 else
335 {
336 GenerateContextLostErrorOnCurrentGlobalContext();
337 }
338 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
339 }
340
GL_VertexAttribI2i(GLuint index,GLint x,GLint y)341 void GL_APIENTRY GL_VertexAttribI2i(GLuint index, GLint x, GLint y)
342 {
343 Context *context = GetValidGlobalContext();
344 EVENT(context, GLVertexAttribI2i, "context = %d, index = %u, x = %d, y = %d", CID(context),
345 index, x, y);
346
347 if (context)
348 {
349 bool isCallValid =
350 (context->skipValidation() ||
351 ValidateVertexAttribI2i(context->getPrivateState(),
352 context->getMutableErrorSetForValidation(),
353 angle::EntryPoint::GLVertexAttribI2i, index, x, y));
354 if (isCallValid)
355 {
356 ContextPrivateVertexAttribI2i(context->getMutablePrivateState(),
357 context->getMutablePrivateStateCache(), index, x, y);
358 }
359 ANGLE_CAPTURE_GL(VertexAttribI2i, isCallValid, context, index, x, y);
360 }
361 else
362 {
363 GenerateContextLostErrorOnCurrentGlobalContext();
364 }
365 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
366 }
367
GL_VertexAttribI2iv(GLuint index,const GLint * v)368 void GL_APIENTRY GL_VertexAttribI2iv(GLuint index, const GLint *v)
369 {
370 Context *context = GetValidGlobalContext();
371 EVENT(context, GLVertexAttribI2iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
372 CID(context), index, (uintptr_t)v);
373
374 if (context)
375 {
376 bool isCallValid =
377 (context->skipValidation() ||
378 ValidateVertexAttribI2iv(context->getPrivateState(),
379 context->getMutableErrorSetForValidation(),
380 angle::EntryPoint::GLVertexAttribI2iv, index, v));
381 if (isCallValid)
382 {
383 ContextPrivateVertexAttribI2iv(context->getMutablePrivateState(),
384 context->getMutablePrivateStateCache(), index, v);
385 }
386 ANGLE_CAPTURE_GL(VertexAttribI2iv, isCallValid, context, index, v);
387 }
388 else
389 {
390 GenerateContextLostErrorOnCurrentGlobalContext();
391 }
392 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
393 }
394
GL_VertexAttribI2ui(GLuint index,GLuint x,GLuint y)395 void GL_APIENTRY GL_VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
396 {
397 Context *context = GetValidGlobalContext();
398 EVENT(context, GLVertexAttribI2ui, "context = %d, index = %u, x = %u, y = %u", CID(context),
399 index, x, y);
400
401 if (context)
402 {
403 bool isCallValid =
404 (context->skipValidation() ||
405 ValidateVertexAttribI2ui(context->getPrivateState(),
406 context->getMutableErrorSetForValidation(),
407 angle::EntryPoint::GLVertexAttribI2ui, index, x, y));
408 if (isCallValid)
409 {
410 ContextPrivateVertexAttribI2ui(context->getMutablePrivateState(),
411 context->getMutablePrivateStateCache(), index, x, y);
412 }
413 ANGLE_CAPTURE_GL(VertexAttribI2ui, isCallValid, context, index, x, y);
414 }
415 else
416 {
417 GenerateContextLostErrorOnCurrentGlobalContext();
418 }
419 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
420 }
421
GL_VertexAttribI2uiv(GLuint index,const GLuint * v)422 void GL_APIENTRY GL_VertexAttribI2uiv(GLuint index, const GLuint *v)
423 {
424 Context *context = GetValidGlobalContext();
425 EVENT(context, GLVertexAttribI2uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
426 CID(context), index, (uintptr_t)v);
427
428 if (context)
429 {
430 bool isCallValid =
431 (context->skipValidation() ||
432 ValidateVertexAttribI2uiv(context->getPrivateState(),
433 context->getMutableErrorSetForValidation(),
434 angle::EntryPoint::GLVertexAttribI2uiv, index, v));
435 if (isCallValid)
436 {
437 ContextPrivateVertexAttribI2uiv(context->getMutablePrivateState(),
438 context->getMutablePrivateStateCache(), index, v);
439 }
440 ANGLE_CAPTURE_GL(VertexAttribI2uiv, isCallValid, context, index, v);
441 }
442 else
443 {
444 GenerateContextLostErrorOnCurrentGlobalContext();
445 }
446 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
447 }
448
GL_VertexAttribI3i(GLuint index,GLint x,GLint y,GLint z)449 void GL_APIENTRY GL_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
450 {
451 Context *context = GetValidGlobalContext();
452 EVENT(context, GLVertexAttribI3i, "context = %d, index = %u, x = %d, y = %d, z = %d",
453 CID(context), index, x, y, z);
454
455 if (context)
456 {
457 bool isCallValid =
458 (context->skipValidation() ||
459 ValidateVertexAttribI3i(context->getPrivateState(),
460 context->getMutableErrorSetForValidation(),
461 angle::EntryPoint::GLVertexAttribI3i, index, x, y, z));
462 if (isCallValid)
463 {
464 ContextPrivateVertexAttribI3i(context->getMutablePrivateState(),
465 context->getMutablePrivateStateCache(), index, x, y, z);
466 }
467 ANGLE_CAPTURE_GL(VertexAttribI3i, isCallValid, context, index, x, y, z);
468 }
469 else
470 {
471 GenerateContextLostErrorOnCurrentGlobalContext();
472 }
473 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
474 }
475
GL_VertexAttribI3iv(GLuint index,const GLint * v)476 void GL_APIENTRY GL_VertexAttribI3iv(GLuint index, const GLint *v)
477 {
478 Context *context = GetValidGlobalContext();
479 EVENT(context, GLVertexAttribI3iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
480 CID(context), index, (uintptr_t)v);
481
482 if (context)
483 {
484 bool isCallValid =
485 (context->skipValidation() ||
486 ValidateVertexAttribI3iv(context->getPrivateState(),
487 context->getMutableErrorSetForValidation(),
488 angle::EntryPoint::GLVertexAttribI3iv, index, v));
489 if (isCallValid)
490 {
491 ContextPrivateVertexAttribI3iv(context->getMutablePrivateState(),
492 context->getMutablePrivateStateCache(), index, v);
493 }
494 ANGLE_CAPTURE_GL(VertexAttribI3iv, isCallValid, context, index, v);
495 }
496 else
497 {
498 GenerateContextLostErrorOnCurrentGlobalContext();
499 }
500 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
501 }
502
GL_VertexAttribI3ui(GLuint index,GLuint x,GLuint y,GLuint z)503 void GL_APIENTRY GL_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
504 {
505 Context *context = GetValidGlobalContext();
506 EVENT(context, GLVertexAttribI3ui, "context = %d, index = %u, x = %u, y = %u, z = %u",
507 CID(context), index, x, y, z);
508
509 if (context)
510 {
511 bool isCallValid =
512 (context->skipValidation() ||
513 ValidateVertexAttribI3ui(context->getPrivateState(),
514 context->getMutableErrorSetForValidation(),
515 angle::EntryPoint::GLVertexAttribI3ui, index, x, y, z));
516 if (isCallValid)
517 {
518 ContextPrivateVertexAttribI3ui(context->getMutablePrivateState(),
519 context->getMutablePrivateStateCache(), index, x, y, z);
520 }
521 ANGLE_CAPTURE_GL(VertexAttribI3ui, isCallValid, context, index, x, y, z);
522 }
523 else
524 {
525 GenerateContextLostErrorOnCurrentGlobalContext();
526 }
527 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
528 }
529
GL_VertexAttribI3uiv(GLuint index,const GLuint * v)530 void GL_APIENTRY GL_VertexAttribI3uiv(GLuint index, const GLuint *v)
531 {
532 Context *context = GetValidGlobalContext();
533 EVENT(context, GLVertexAttribI3uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
534 CID(context), index, (uintptr_t)v);
535
536 if (context)
537 {
538 bool isCallValid =
539 (context->skipValidation() ||
540 ValidateVertexAttribI3uiv(context->getPrivateState(),
541 context->getMutableErrorSetForValidation(),
542 angle::EntryPoint::GLVertexAttribI3uiv, index, v));
543 if (isCallValid)
544 {
545 ContextPrivateVertexAttribI3uiv(context->getMutablePrivateState(),
546 context->getMutablePrivateStateCache(), index, v);
547 }
548 ANGLE_CAPTURE_GL(VertexAttribI3uiv, isCallValid, context, index, v);
549 }
550 else
551 {
552 GenerateContextLostErrorOnCurrentGlobalContext();
553 }
554 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
555 }
556
GL_VertexAttribI4bv(GLuint index,const GLbyte * v)557 void GL_APIENTRY GL_VertexAttribI4bv(GLuint index, const GLbyte *v)
558 {
559 Context *context = GetValidGlobalContext();
560 EVENT(context, GLVertexAttribI4bv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
561 CID(context), index, (uintptr_t)v);
562
563 if (context)
564 {
565 bool isCallValid =
566 (context->skipValidation() ||
567 ValidateVertexAttribI4bv(context->getPrivateState(),
568 context->getMutableErrorSetForValidation(),
569 angle::EntryPoint::GLVertexAttribI4bv, index, v));
570 if (isCallValid)
571 {
572 ContextPrivateVertexAttribI4bv(context->getMutablePrivateState(),
573 context->getMutablePrivateStateCache(), index, v);
574 }
575 ANGLE_CAPTURE_GL(VertexAttribI4bv, isCallValid, context, index, v);
576 }
577 else
578 {
579 GenerateContextLostErrorOnCurrentGlobalContext();
580 }
581 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
582 }
583
GL_VertexAttribI4sv(GLuint index,const GLshort * v)584 void GL_APIENTRY GL_VertexAttribI4sv(GLuint index, const GLshort *v)
585 {
586 Context *context = GetValidGlobalContext();
587 EVENT(context, GLVertexAttribI4sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
588 CID(context), index, (uintptr_t)v);
589
590 if (context)
591 {
592 bool isCallValid =
593 (context->skipValidation() ||
594 ValidateVertexAttribI4sv(context->getPrivateState(),
595 context->getMutableErrorSetForValidation(),
596 angle::EntryPoint::GLVertexAttribI4sv, index, v));
597 if (isCallValid)
598 {
599 ContextPrivateVertexAttribI4sv(context->getMutablePrivateState(),
600 context->getMutablePrivateStateCache(), index, v);
601 }
602 ANGLE_CAPTURE_GL(VertexAttribI4sv, isCallValid, context, index, v);
603 }
604 else
605 {
606 GenerateContextLostErrorOnCurrentGlobalContext();
607 }
608 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
609 }
610
GL_VertexAttribI4ubv(GLuint index,const GLubyte * v)611 void GL_APIENTRY GL_VertexAttribI4ubv(GLuint index, const GLubyte *v)
612 {
613 Context *context = GetValidGlobalContext();
614 EVENT(context, GLVertexAttribI4ubv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
615 CID(context), index, (uintptr_t)v);
616
617 if (context)
618 {
619 bool isCallValid =
620 (context->skipValidation() ||
621 ValidateVertexAttribI4ubv(context->getPrivateState(),
622 context->getMutableErrorSetForValidation(),
623 angle::EntryPoint::GLVertexAttribI4ubv, index, v));
624 if (isCallValid)
625 {
626 ContextPrivateVertexAttribI4ubv(context->getMutablePrivateState(),
627 context->getMutablePrivateStateCache(), index, v);
628 }
629 ANGLE_CAPTURE_GL(VertexAttribI4ubv, isCallValid, context, index, v);
630 }
631 else
632 {
633 GenerateContextLostErrorOnCurrentGlobalContext();
634 }
635 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
636 }
637
GL_VertexAttribI4usv(GLuint index,const GLushort * v)638 void GL_APIENTRY GL_VertexAttribI4usv(GLuint index, const GLushort *v)
639 {
640 Context *context = GetValidGlobalContext();
641 EVENT(context, GLVertexAttribI4usv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
642 CID(context), index, (uintptr_t)v);
643
644 if (context)
645 {
646 bool isCallValid =
647 (context->skipValidation() ||
648 ValidateVertexAttribI4usv(context->getPrivateState(),
649 context->getMutableErrorSetForValidation(),
650 angle::EntryPoint::GLVertexAttribI4usv, index, v));
651 if (isCallValid)
652 {
653 ContextPrivateVertexAttribI4usv(context->getMutablePrivateState(),
654 context->getMutablePrivateStateCache(), index, v);
655 }
656 ANGLE_CAPTURE_GL(VertexAttribI4usv, isCallValid, context, index, v);
657 }
658 else
659 {
660 GenerateContextLostErrorOnCurrentGlobalContext();
661 }
662 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
663 }
664
665 // GL 3.1
GL_GetActiveUniformName(GLuint program,GLuint uniformIndex,GLsizei bufSize,GLsizei * length,GLchar * uniformName)666 void GL_APIENTRY GL_GetActiveUniformName(GLuint program,
667 GLuint uniformIndex,
668 GLsizei bufSize,
669 GLsizei *length,
670 GLchar *uniformName)
671 {
672 Context *context = GetValidGlobalContext();
673 EVENT(context, GLGetActiveUniformName,
674 "context = %d, program = %u, uniformIndex = %u, bufSize = %d, length = 0x%016" PRIxPTR
675 ", uniformName = 0x%016" PRIxPTR "",
676 CID(context), program, uniformIndex, bufSize, (uintptr_t)length, (uintptr_t)uniformName);
677
678 if (context)
679 {
680 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
681 SCOPED_SHARE_CONTEXT_LOCK(context);
682 bool isCallValid = (context->skipValidation() ||
683 ValidateGetActiveUniformName(
684 context, angle::EntryPoint::GLGetActiveUniformName, programPacked,
685 uniformIndex, bufSize, length, uniformName));
686 if (isCallValid)
687 {
688 context->getActiveUniformName(programPacked, uniformIndex, bufSize, length,
689 uniformName);
690 }
691 ANGLE_CAPTURE_GL(GetActiveUniformName, isCallValid, context, programPacked, uniformIndex,
692 bufSize, length, uniformName);
693 }
694 else
695 {
696 GenerateContextLostErrorOnCurrentGlobalContext();
697 }
698 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
699 }
700
GL_PrimitiveRestartIndex(GLuint index)701 void GL_APIENTRY GL_PrimitiveRestartIndex(GLuint index)
702 {
703 Context *context = GetValidGlobalContext();
704 EVENT(context, GLPrimitiveRestartIndex, "context = %d, index = %u", CID(context), index);
705
706 if (context)
707 {
708 SCOPED_SHARE_CONTEXT_LOCK(context);
709 bool isCallValid =
710 (context->skipValidation() ||
711 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
712 context->getMutableErrorSetForValidation(),
713 angle::EntryPoint::GLPrimitiveRestartIndex) &&
714 ValidatePrimitiveRestartIndex(context, angle::EntryPoint::GLPrimitiveRestartIndex,
715 index)));
716 if (isCallValid)
717 {
718 context->primitiveRestartIndex(index);
719 }
720 ANGLE_CAPTURE_GL(PrimitiveRestartIndex, isCallValid, context, index);
721 }
722 else
723 {
724 GenerateContextLostErrorOnCurrentGlobalContext();
725 }
726 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
727 }
728
729 // GL 3.2
GL_MultiDrawElementsBaseVertex(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei drawcount,const GLint * basevertex)730 void GL_APIENTRY GL_MultiDrawElementsBaseVertex(GLenum mode,
731 const GLsizei *count,
732 GLenum type,
733 const void *const *indices,
734 GLsizei drawcount,
735 const GLint *basevertex)
736 {
737 Context *context = GetValidGlobalContext();
738 EVENT(context, GLMultiDrawElementsBaseVertex,
739 "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
740 ", drawcount = %d, basevertex = 0x%016" PRIxPTR "",
741 CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)count,
742 GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indices, drawcount,
743 (uintptr_t)basevertex);
744
745 if (context)
746 {
747 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
748 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
749 SCOPED_SHARE_CONTEXT_LOCK(context);
750 bool isCallValid =
751 (context->skipValidation() ||
752 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
753 context->getMutableErrorSetForValidation(),
754 angle::EntryPoint::GLMultiDrawElementsBaseVertex) &&
755 ValidateMultiDrawElementsBaseVertex(
756 context, angle::EntryPoint::GLMultiDrawElementsBaseVertex, modePacked, count,
757 typePacked, indices, drawcount, basevertex)));
758 if (isCallValid)
759 {
760 context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount,
761 basevertex);
762 }
763 ANGLE_CAPTURE_GL(MultiDrawElementsBaseVertex, isCallValid, context, modePacked, count,
764 typePacked, indices, drawcount, basevertex);
765 }
766 else
767 {
768 GenerateContextLostErrorOnCurrentGlobalContext();
769 }
770 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
771 }
772
GL_ProvokingVertex(GLenum mode)773 void GL_APIENTRY GL_ProvokingVertex(GLenum mode)
774 {
775 Context *context = GetValidGlobalContext();
776 EVENT(context, GLProvokingVertex, "context = %d, mode = %s", CID(context),
777 GLenumToString(BigGLEnum::VertexProvokingMode, mode));
778
779 if (context)
780 {
781 ProvokingVertexConvention modePacked = PackParam<ProvokingVertexConvention>(mode);
782 bool isCallValid =
783 (context->skipValidation() ||
784 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
785 context->getMutableErrorSetForValidation(),
786 angle::EntryPoint::GLProvokingVertex) &&
787 ValidateProvokingVertex(context->getPrivateState(),
788 context->getMutableErrorSetForValidation(),
789 angle::EntryPoint::GLProvokingVertex, modePacked)));
790 if (isCallValid)
791 {
792 ContextPrivateProvokingVertex(context->getMutablePrivateState(),
793 context->getMutablePrivateStateCache(), modePacked);
794 }
795 ANGLE_CAPTURE_GL(ProvokingVertex, isCallValid, context, modePacked);
796 }
797 else
798 {
799 GenerateContextLostErrorOnCurrentGlobalContext();
800 }
801 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
802 }
803
GL_TexImage2DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)804 void GL_APIENTRY GL_TexImage2DMultisample(GLenum target,
805 GLsizei samples,
806 GLenum internalformat,
807 GLsizei width,
808 GLsizei height,
809 GLboolean fixedsamplelocations)
810 {
811 Context *context = GetValidGlobalContext();
812 EVENT(context, GLTexImage2DMultisample,
813 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
814 "fixedsamplelocations = %s",
815 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), samples,
816 GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height,
817 GLbooleanToString(fixedsamplelocations));
818
819 if (context)
820 {
821 SCOPED_SHARE_CONTEXT_LOCK(context);
822 bool isCallValid =
823 (context->skipValidation() ||
824 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
825 context->getMutableErrorSetForValidation(),
826 angle::EntryPoint::GLTexImage2DMultisample) &&
827 ValidateTexImage2DMultisample(context, angle::EntryPoint::GLTexImage2DMultisample,
828 target, samples, internalformat, width, height,
829 fixedsamplelocations)));
830 if (isCallValid)
831 {
832 context->texImage2DMultisample(target, samples, internalformat, width, height,
833 fixedsamplelocations);
834 }
835 ANGLE_CAPTURE_GL(TexImage2DMultisample, isCallValid, context, target, samples,
836 internalformat, width, height, fixedsamplelocations);
837 }
838 else
839 {
840 GenerateContextLostErrorOnCurrentGlobalContext();
841 }
842 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
843 }
844
GL_TexImage3DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)845 void GL_APIENTRY GL_TexImage3DMultisample(GLenum target,
846 GLsizei samples,
847 GLenum internalformat,
848 GLsizei width,
849 GLsizei height,
850 GLsizei depth,
851 GLboolean fixedsamplelocations)
852 {
853 Context *context = GetValidGlobalContext();
854 EVENT(context, GLTexImage3DMultisample,
855 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
856 "depth = %d, fixedsamplelocations = %s",
857 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), samples,
858 GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height, depth,
859 GLbooleanToString(fixedsamplelocations));
860
861 if (context)
862 {
863 SCOPED_SHARE_CONTEXT_LOCK(context);
864 bool isCallValid =
865 (context->skipValidation() ||
866 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
867 context->getMutableErrorSetForValidation(),
868 angle::EntryPoint::GLTexImage3DMultisample) &&
869 ValidateTexImage3DMultisample(context, angle::EntryPoint::GLTexImage3DMultisample,
870 target, samples, internalformat, width, height, depth,
871 fixedsamplelocations)));
872 if (isCallValid)
873 {
874 context->texImage3DMultisample(target, samples, internalformat, width, height, depth,
875 fixedsamplelocations);
876 }
877 ANGLE_CAPTURE_GL(TexImage3DMultisample, isCallValid, context, target, samples,
878 internalformat, width, height, depth, fixedsamplelocations);
879 }
880 else
881 {
882 GenerateContextLostErrorOnCurrentGlobalContext();
883 }
884 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
885 }
886
887 // GL 3.3
GL_BindFragDataLocationIndexed(GLuint program,GLuint colorNumber,GLuint index,const GLchar * name)888 void GL_APIENTRY GL_BindFragDataLocationIndexed(GLuint program,
889 GLuint colorNumber,
890 GLuint index,
891 const GLchar *name)
892 {
893 Context *context = GetValidGlobalContext();
894 EVENT(context, GLBindFragDataLocationIndexed,
895 "context = %d, program = %u, colorNumber = %u, index = %u, name = 0x%016" PRIxPTR "",
896 CID(context), program, colorNumber, index, (uintptr_t)name);
897
898 if (context)
899 {
900 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
901 SCOPED_SHARE_CONTEXT_LOCK(context);
902 bool isCallValid =
903 (context->skipValidation() ||
904 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
905 context->getMutableErrorSetForValidation(),
906 angle::EntryPoint::GLBindFragDataLocationIndexed) &&
907 ValidateBindFragDataLocationIndexed(context,
908 angle::EntryPoint::GLBindFragDataLocationIndexed,
909 programPacked, colorNumber, index, name)));
910 if (isCallValid)
911 {
912 context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
913 }
914 ANGLE_CAPTURE_GL(BindFragDataLocationIndexed, isCallValid, context, programPacked,
915 colorNumber, index, name);
916 }
917 else
918 {
919 GenerateContextLostErrorOnCurrentGlobalContext();
920 }
921 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
922 }
923
GL_ColorP3ui(GLenum type,GLuint color)924 void GL_APIENTRY GL_ColorP3ui(GLenum type, GLuint color)
925 {
926 Context *context = GetValidGlobalContext();
927 EVENT(context, GLColorP3ui, "context = %d, type = %s, color = %u", CID(context),
928 GLenumToString(BigGLEnum::ColorPointerType, type), color);
929
930 if (context)
931 {
932 SCOPED_SHARE_CONTEXT_LOCK(context);
933 bool isCallValid =
934 (context->skipValidation() ||
935 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
936 context->getMutableErrorSetForValidation(),
937 angle::EntryPoint::GLColorP3ui) &&
938 ValidateColorP3ui(context, angle::EntryPoint::GLColorP3ui, type, color)));
939 if (isCallValid)
940 {
941 context->colorP3ui(type, color);
942 }
943 ANGLE_CAPTURE_GL(ColorP3ui, isCallValid, context, type, color);
944 }
945 else
946 {
947 GenerateContextLostErrorOnCurrentGlobalContext();
948 }
949 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
950 }
951
GL_ColorP3uiv(GLenum type,const GLuint * color)952 void GL_APIENTRY GL_ColorP3uiv(GLenum type, const GLuint *color)
953 {
954 Context *context = GetValidGlobalContext();
955 EVENT(context, GLColorP3uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", CID(context),
956 GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color);
957
958 if (context)
959 {
960 SCOPED_SHARE_CONTEXT_LOCK(context);
961 bool isCallValid =
962 (context->skipValidation() ||
963 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
964 context->getMutableErrorSetForValidation(),
965 angle::EntryPoint::GLColorP3uiv) &&
966 ValidateColorP3uiv(context, angle::EntryPoint::GLColorP3uiv, type, color)));
967 if (isCallValid)
968 {
969 context->colorP3uiv(type, color);
970 }
971 ANGLE_CAPTURE_GL(ColorP3uiv, isCallValid, context, type, color);
972 }
973 else
974 {
975 GenerateContextLostErrorOnCurrentGlobalContext();
976 }
977 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
978 }
979
GL_ColorP4ui(GLenum type,GLuint color)980 void GL_APIENTRY GL_ColorP4ui(GLenum type, GLuint color)
981 {
982 Context *context = GetValidGlobalContext();
983 EVENT(context, GLColorP4ui, "context = %d, type = %s, color = %u", CID(context),
984 GLenumToString(BigGLEnum::ColorPointerType, type), color);
985
986 if (context)
987 {
988 SCOPED_SHARE_CONTEXT_LOCK(context);
989 bool isCallValid =
990 (context->skipValidation() ||
991 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
992 context->getMutableErrorSetForValidation(),
993 angle::EntryPoint::GLColorP4ui) &&
994 ValidateColorP4ui(context, angle::EntryPoint::GLColorP4ui, type, color)));
995 if (isCallValid)
996 {
997 context->colorP4ui(type, color);
998 }
999 ANGLE_CAPTURE_GL(ColorP4ui, isCallValid, context, type, color);
1000 }
1001 else
1002 {
1003 GenerateContextLostErrorOnCurrentGlobalContext();
1004 }
1005 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1006 }
1007
GL_ColorP4uiv(GLenum type,const GLuint * color)1008 void GL_APIENTRY GL_ColorP4uiv(GLenum type, const GLuint *color)
1009 {
1010 Context *context = GetValidGlobalContext();
1011 EVENT(context, GLColorP4uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", CID(context),
1012 GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color);
1013
1014 if (context)
1015 {
1016 SCOPED_SHARE_CONTEXT_LOCK(context);
1017 bool isCallValid =
1018 (context->skipValidation() ||
1019 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1020 context->getMutableErrorSetForValidation(),
1021 angle::EntryPoint::GLColorP4uiv) &&
1022 ValidateColorP4uiv(context, angle::EntryPoint::GLColorP4uiv, type, color)));
1023 if (isCallValid)
1024 {
1025 context->colorP4uiv(type, color);
1026 }
1027 ANGLE_CAPTURE_GL(ColorP4uiv, isCallValid, context, type, color);
1028 }
1029 else
1030 {
1031 GenerateContextLostErrorOnCurrentGlobalContext();
1032 }
1033 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1034 }
1035
GL_GetFragDataIndex(GLuint program,const GLchar * name)1036 GLint GL_APIENTRY GL_GetFragDataIndex(GLuint program, const GLchar *name)
1037 {
1038 Context *context = GetValidGlobalContext();
1039 EVENT(context, GLGetFragDataIndex, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
1040 CID(context), program, (uintptr_t)name);
1041
1042 GLint returnValue;
1043 if (context)
1044 {
1045 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1046 SCOPED_SHARE_CONTEXT_LOCK(context);
1047 bool isCallValid = (context->skipValidation() ||
1048 ValidateGetFragDataIndex(context, angle::EntryPoint::GLGetFragDataIndex,
1049 programPacked, name));
1050 if (isCallValid)
1051 {
1052 returnValue = context->getFragDataIndex(programPacked, name);
1053 }
1054 else
1055 {
1056 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndex, GLint>();
1057 }
1058 ANGLE_CAPTURE_GL(GetFragDataIndex, isCallValid, context, programPacked, name, returnValue);
1059 }
1060 else
1061 {
1062 GenerateContextLostErrorOnCurrentGlobalContext();
1063 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndex, GLint>();
1064 }
1065 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1066 return returnValue;
1067 }
1068
GL_GetQueryObjecti64v(GLuint id,GLenum pname,GLint64 * params)1069 void GL_APIENTRY GL_GetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
1070 {
1071 Context *context = GetGlobalContext();
1072 EVENT(context, GLGetQueryObjecti64v,
1073 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
1074 GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params);
1075
1076 if (context)
1077 {
1078 QueryID idPacked = PackParam<QueryID>(id);
1079 SCOPED_SHARE_CONTEXT_LOCK(context);
1080 bool isCallValid =
1081 (context->skipValidation() ||
1082 ValidateGetQueryObjecti64v(context, angle::EntryPoint::GLGetQueryObjecti64v, idPacked,
1083 pname, params));
1084 if (isCallValid)
1085 {
1086 context->getQueryObjecti64v(idPacked, pname, params);
1087 }
1088 ANGLE_CAPTURE_GL(GetQueryObjecti64v, isCallValid, context, idPacked, pname, params);
1089 }
1090 else
1091 {
1092 }
1093 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1094 }
1095
GL_GetQueryObjectui64v(GLuint id,GLenum pname,GLuint64 * params)1096 void GL_APIENTRY GL_GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
1097 {
1098 Context *context = GetValidGlobalContext();
1099 EVENT(context, GLGetQueryObjectui64v,
1100 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
1101 GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params);
1102
1103 if (context)
1104 {
1105 QueryID idPacked = PackParam<QueryID>(id);
1106 SCOPED_SHARE_CONTEXT_LOCK(context);
1107 bool isCallValid =
1108 (context->skipValidation() ||
1109 ValidateGetQueryObjectui64v(context, angle::EntryPoint::GLGetQueryObjectui64v,
1110 idPacked, pname, params));
1111 if (isCallValid)
1112 {
1113 context->getQueryObjectui64v(idPacked, pname, params);
1114 }
1115 ANGLE_CAPTURE_GL(GetQueryObjectui64v, isCallValid, context, idPacked, pname, params);
1116 }
1117 else
1118 {
1119 GenerateContextLostErrorOnCurrentGlobalContext();
1120 }
1121 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1122 }
1123
GL_MultiTexCoordP1ui(GLenum texture,GLenum type,GLuint coords)1124 void GL_APIENTRY GL_MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
1125 {
1126 Context *context = GetValidGlobalContext();
1127 EVENT(context, GLMultiTexCoordP1ui, "context = %d, texture = %s, type = %s, coords = %u",
1128 CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
1129 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1130
1131 if (context)
1132 {
1133 SCOPED_SHARE_CONTEXT_LOCK(context);
1134 bool isCallValid =
1135 (context->skipValidation() ||
1136 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1137 context->getMutableErrorSetForValidation(),
1138 angle::EntryPoint::GLMultiTexCoordP1ui) &&
1139 ValidateMultiTexCoordP1ui(context, angle::EntryPoint::GLMultiTexCoordP1ui, texture,
1140 type, coords)));
1141 if (isCallValid)
1142 {
1143 context->multiTexCoordP1ui(texture, type, coords);
1144 }
1145 ANGLE_CAPTURE_GL(MultiTexCoordP1ui, isCallValid, context, texture, type, coords);
1146 }
1147 else
1148 {
1149 GenerateContextLostErrorOnCurrentGlobalContext();
1150 }
1151 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1152 }
1153
GL_MultiTexCoordP1uiv(GLenum texture,GLenum type,const GLuint * coords)1154 void GL_APIENTRY GL_MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
1155 {
1156 Context *context = GetValidGlobalContext();
1157 EVENT(context, GLMultiTexCoordP1uiv,
1158 "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
1159 GLenumToString(BigGLEnum::TextureUnit, texture),
1160 GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1161
1162 if (context)
1163 {
1164 SCOPED_SHARE_CONTEXT_LOCK(context);
1165 bool isCallValid =
1166 (context->skipValidation() ||
1167 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1168 context->getMutableErrorSetForValidation(),
1169 angle::EntryPoint::GLMultiTexCoordP1uiv) &&
1170 ValidateMultiTexCoordP1uiv(context, angle::EntryPoint::GLMultiTexCoordP1uiv, texture,
1171 type, coords)));
1172 if (isCallValid)
1173 {
1174 context->multiTexCoordP1uiv(texture, type, coords);
1175 }
1176 ANGLE_CAPTURE_GL(MultiTexCoordP1uiv, isCallValid, context, texture, type, coords);
1177 }
1178 else
1179 {
1180 GenerateContextLostErrorOnCurrentGlobalContext();
1181 }
1182 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1183 }
1184
GL_MultiTexCoordP2ui(GLenum texture,GLenum type,GLuint coords)1185 void GL_APIENTRY GL_MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
1186 {
1187 Context *context = GetValidGlobalContext();
1188 EVENT(context, GLMultiTexCoordP2ui, "context = %d, texture = %s, type = %s, coords = %u",
1189 CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
1190 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1191
1192 if (context)
1193 {
1194 SCOPED_SHARE_CONTEXT_LOCK(context);
1195 bool isCallValid =
1196 (context->skipValidation() ||
1197 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1198 context->getMutableErrorSetForValidation(),
1199 angle::EntryPoint::GLMultiTexCoordP2ui) &&
1200 ValidateMultiTexCoordP2ui(context, angle::EntryPoint::GLMultiTexCoordP2ui, texture,
1201 type, coords)));
1202 if (isCallValid)
1203 {
1204 context->multiTexCoordP2ui(texture, type, coords);
1205 }
1206 ANGLE_CAPTURE_GL(MultiTexCoordP2ui, isCallValid, context, texture, type, coords);
1207 }
1208 else
1209 {
1210 GenerateContextLostErrorOnCurrentGlobalContext();
1211 }
1212 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1213 }
1214
GL_MultiTexCoordP2uiv(GLenum texture,GLenum type,const GLuint * coords)1215 void GL_APIENTRY GL_MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
1216 {
1217 Context *context = GetValidGlobalContext();
1218 EVENT(context, GLMultiTexCoordP2uiv,
1219 "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
1220 GLenumToString(BigGLEnum::TextureUnit, texture),
1221 GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1222
1223 if (context)
1224 {
1225 SCOPED_SHARE_CONTEXT_LOCK(context);
1226 bool isCallValid =
1227 (context->skipValidation() ||
1228 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1229 context->getMutableErrorSetForValidation(),
1230 angle::EntryPoint::GLMultiTexCoordP2uiv) &&
1231 ValidateMultiTexCoordP2uiv(context, angle::EntryPoint::GLMultiTexCoordP2uiv, texture,
1232 type, coords)));
1233 if (isCallValid)
1234 {
1235 context->multiTexCoordP2uiv(texture, type, coords);
1236 }
1237 ANGLE_CAPTURE_GL(MultiTexCoordP2uiv, isCallValid, context, texture, type, coords);
1238 }
1239 else
1240 {
1241 GenerateContextLostErrorOnCurrentGlobalContext();
1242 }
1243 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1244 }
1245
GL_MultiTexCoordP3ui(GLenum texture,GLenum type,GLuint coords)1246 void GL_APIENTRY GL_MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
1247 {
1248 Context *context = GetValidGlobalContext();
1249 EVENT(context, GLMultiTexCoordP3ui, "context = %d, texture = %s, type = %s, coords = %u",
1250 CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
1251 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1252
1253 if (context)
1254 {
1255 SCOPED_SHARE_CONTEXT_LOCK(context);
1256 bool isCallValid =
1257 (context->skipValidation() ||
1258 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1259 context->getMutableErrorSetForValidation(),
1260 angle::EntryPoint::GLMultiTexCoordP3ui) &&
1261 ValidateMultiTexCoordP3ui(context, angle::EntryPoint::GLMultiTexCoordP3ui, texture,
1262 type, coords)));
1263 if (isCallValid)
1264 {
1265 context->multiTexCoordP3ui(texture, type, coords);
1266 }
1267 ANGLE_CAPTURE_GL(MultiTexCoordP3ui, isCallValid, context, texture, type, coords);
1268 }
1269 else
1270 {
1271 GenerateContextLostErrorOnCurrentGlobalContext();
1272 }
1273 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1274 }
1275
GL_MultiTexCoordP3uiv(GLenum texture,GLenum type,const GLuint * coords)1276 void GL_APIENTRY GL_MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
1277 {
1278 Context *context = GetValidGlobalContext();
1279 EVENT(context, GLMultiTexCoordP3uiv,
1280 "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
1281 GLenumToString(BigGLEnum::TextureUnit, texture),
1282 GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1283
1284 if (context)
1285 {
1286 SCOPED_SHARE_CONTEXT_LOCK(context);
1287 bool isCallValid =
1288 (context->skipValidation() ||
1289 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1290 context->getMutableErrorSetForValidation(),
1291 angle::EntryPoint::GLMultiTexCoordP3uiv) &&
1292 ValidateMultiTexCoordP3uiv(context, angle::EntryPoint::GLMultiTexCoordP3uiv, texture,
1293 type, coords)));
1294 if (isCallValid)
1295 {
1296 context->multiTexCoordP3uiv(texture, type, coords);
1297 }
1298 ANGLE_CAPTURE_GL(MultiTexCoordP3uiv, isCallValid, context, texture, type, coords);
1299 }
1300 else
1301 {
1302 GenerateContextLostErrorOnCurrentGlobalContext();
1303 }
1304 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1305 }
1306
GL_MultiTexCoordP4ui(GLenum texture,GLenum type,GLuint coords)1307 void GL_APIENTRY GL_MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
1308 {
1309 Context *context = GetValidGlobalContext();
1310 EVENT(context, GLMultiTexCoordP4ui, "context = %d, texture = %s, type = %s, coords = %u",
1311 CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
1312 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1313
1314 if (context)
1315 {
1316 SCOPED_SHARE_CONTEXT_LOCK(context);
1317 bool isCallValid =
1318 (context->skipValidation() ||
1319 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1320 context->getMutableErrorSetForValidation(),
1321 angle::EntryPoint::GLMultiTexCoordP4ui) &&
1322 ValidateMultiTexCoordP4ui(context, angle::EntryPoint::GLMultiTexCoordP4ui, texture,
1323 type, coords)));
1324 if (isCallValid)
1325 {
1326 context->multiTexCoordP4ui(texture, type, coords);
1327 }
1328 ANGLE_CAPTURE_GL(MultiTexCoordP4ui, isCallValid, context, texture, type, coords);
1329 }
1330 else
1331 {
1332 GenerateContextLostErrorOnCurrentGlobalContext();
1333 }
1334 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1335 }
1336
GL_MultiTexCoordP4uiv(GLenum texture,GLenum type,const GLuint * coords)1337 void GL_APIENTRY GL_MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
1338 {
1339 Context *context = GetValidGlobalContext();
1340 EVENT(context, GLMultiTexCoordP4uiv,
1341 "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
1342 GLenumToString(BigGLEnum::TextureUnit, texture),
1343 GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1344
1345 if (context)
1346 {
1347 SCOPED_SHARE_CONTEXT_LOCK(context);
1348 bool isCallValid =
1349 (context->skipValidation() ||
1350 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1351 context->getMutableErrorSetForValidation(),
1352 angle::EntryPoint::GLMultiTexCoordP4uiv) &&
1353 ValidateMultiTexCoordP4uiv(context, angle::EntryPoint::GLMultiTexCoordP4uiv, texture,
1354 type, coords)));
1355 if (isCallValid)
1356 {
1357 context->multiTexCoordP4uiv(texture, type, coords);
1358 }
1359 ANGLE_CAPTURE_GL(MultiTexCoordP4uiv, isCallValid, context, texture, type, coords);
1360 }
1361 else
1362 {
1363 GenerateContextLostErrorOnCurrentGlobalContext();
1364 }
1365 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1366 }
1367
GL_NormalP3ui(GLenum type,GLuint coords)1368 void GL_APIENTRY GL_NormalP3ui(GLenum type, GLuint coords)
1369 {
1370 Context *context = GetValidGlobalContext();
1371 EVENT(context, GLNormalP3ui, "context = %d, type = %s, coords = %u", CID(context),
1372 GLenumToString(BigGLEnum::NormalPointerType, type), coords);
1373
1374 if (context)
1375 {
1376 SCOPED_SHARE_CONTEXT_LOCK(context);
1377 bool isCallValid =
1378 (context->skipValidation() ||
1379 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1380 context->getMutableErrorSetForValidation(),
1381 angle::EntryPoint::GLNormalP3ui) &&
1382 ValidateNormalP3ui(context, angle::EntryPoint::GLNormalP3ui, type, coords)));
1383 if (isCallValid)
1384 {
1385 context->normalP3ui(type, coords);
1386 }
1387 ANGLE_CAPTURE_GL(NormalP3ui, isCallValid, context, type, coords);
1388 }
1389 else
1390 {
1391 GenerateContextLostErrorOnCurrentGlobalContext();
1392 }
1393 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1394 }
1395
GL_NormalP3uiv(GLenum type,const GLuint * coords)1396 void GL_APIENTRY GL_NormalP3uiv(GLenum type, const GLuint *coords)
1397 {
1398 Context *context = GetValidGlobalContext();
1399 EVENT(context, GLNormalP3uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
1400 CID(context), GLenumToString(BigGLEnum::NormalPointerType, type), (uintptr_t)coords);
1401
1402 if (context)
1403 {
1404 SCOPED_SHARE_CONTEXT_LOCK(context);
1405 bool isCallValid =
1406 (context->skipValidation() ||
1407 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1408 context->getMutableErrorSetForValidation(),
1409 angle::EntryPoint::GLNormalP3uiv) &&
1410 ValidateNormalP3uiv(context, angle::EntryPoint::GLNormalP3uiv, type, coords)));
1411 if (isCallValid)
1412 {
1413 context->normalP3uiv(type, coords);
1414 }
1415 ANGLE_CAPTURE_GL(NormalP3uiv, isCallValid, context, type, coords);
1416 }
1417 else
1418 {
1419 GenerateContextLostErrorOnCurrentGlobalContext();
1420 }
1421 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1422 }
1423
GL_QueryCounter(GLuint id,GLenum target)1424 void GL_APIENTRY GL_QueryCounter(GLuint id, GLenum target)
1425 {
1426 Context *context = GetValidGlobalContext();
1427 EVENT(context, GLQueryCounter, "context = %d, id = %u, target = %s", CID(context), id,
1428 GLenumToString(BigGLEnum::QueryCounterTarget, target));
1429
1430 if (context)
1431 {
1432 QueryID idPacked = PackParam<QueryID>(id);
1433 QueryType targetPacked = PackParam<QueryType>(target);
1434 SCOPED_SHARE_CONTEXT_LOCK(context);
1435 bool isCallValid =
1436 (context->skipValidation() ||
1437 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1438 context->getMutableErrorSetForValidation(),
1439 angle::EntryPoint::GLQueryCounter) &&
1440 ValidateQueryCounter(context, angle::EntryPoint::GLQueryCounter, idPacked,
1441 targetPacked)));
1442 if (isCallValid)
1443 {
1444 context->queryCounter(idPacked, targetPacked);
1445 }
1446 ANGLE_CAPTURE_GL(QueryCounter, isCallValid, context, idPacked, targetPacked);
1447 }
1448 else
1449 {
1450 GenerateContextLostErrorOnCurrentGlobalContext();
1451 }
1452 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1453 }
1454
GL_SecondaryColorP3ui(GLenum type,GLuint color)1455 void GL_APIENTRY GL_SecondaryColorP3ui(GLenum type, GLuint color)
1456 {
1457 Context *context = GetValidGlobalContext();
1458 EVENT(context, GLSecondaryColorP3ui, "context = %d, type = %s, color = %u", CID(context),
1459 GLenumToString(BigGLEnum::ColorPointerType, type), color);
1460
1461 if (context)
1462 {
1463 SCOPED_SHARE_CONTEXT_LOCK(context);
1464 bool isCallValid =
1465 (context->skipValidation() ||
1466 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1467 context->getMutableErrorSetForValidation(),
1468 angle::EntryPoint::GLSecondaryColorP3ui) &&
1469 ValidateSecondaryColorP3ui(context, angle::EntryPoint::GLSecondaryColorP3ui, type,
1470 color)));
1471 if (isCallValid)
1472 {
1473 context->secondaryColorP3ui(type, color);
1474 }
1475 ANGLE_CAPTURE_GL(SecondaryColorP3ui, isCallValid, context, type, color);
1476 }
1477 else
1478 {
1479 GenerateContextLostErrorOnCurrentGlobalContext();
1480 }
1481 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1482 }
1483
GL_SecondaryColorP3uiv(GLenum type,const GLuint * color)1484 void GL_APIENTRY GL_SecondaryColorP3uiv(GLenum type, const GLuint *color)
1485 {
1486 Context *context = GetValidGlobalContext();
1487 EVENT(context, GLSecondaryColorP3uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "",
1488 CID(context), GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color);
1489
1490 if (context)
1491 {
1492 SCOPED_SHARE_CONTEXT_LOCK(context);
1493 bool isCallValid =
1494 (context->skipValidation() ||
1495 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1496 context->getMutableErrorSetForValidation(),
1497 angle::EntryPoint::GLSecondaryColorP3uiv) &&
1498 ValidateSecondaryColorP3uiv(context, angle::EntryPoint::GLSecondaryColorP3uiv, type,
1499 color)));
1500 if (isCallValid)
1501 {
1502 context->secondaryColorP3uiv(type, color);
1503 }
1504 ANGLE_CAPTURE_GL(SecondaryColorP3uiv, isCallValid, context, type, color);
1505 }
1506 else
1507 {
1508 GenerateContextLostErrorOnCurrentGlobalContext();
1509 }
1510 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1511 }
1512
GL_TexCoordP1ui(GLenum type,GLuint coords)1513 void GL_APIENTRY GL_TexCoordP1ui(GLenum type, GLuint coords)
1514 {
1515 Context *context = GetValidGlobalContext();
1516 EVENT(context, GLTexCoordP1ui, "context = %d, type = %s, coords = %u", CID(context),
1517 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1518
1519 if (context)
1520 {
1521 SCOPED_SHARE_CONTEXT_LOCK(context);
1522 bool isCallValid =
1523 (context->skipValidation() ||
1524 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1525 context->getMutableErrorSetForValidation(),
1526 angle::EntryPoint::GLTexCoordP1ui) &&
1527 ValidateTexCoordP1ui(context, angle::EntryPoint::GLTexCoordP1ui, type, coords)));
1528 if (isCallValid)
1529 {
1530 context->texCoordP1ui(type, coords);
1531 }
1532 ANGLE_CAPTURE_GL(TexCoordP1ui, isCallValid, context, type, coords);
1533 }
1534 else
1535 {
1536 GenerateContextLostErrorOnCurrentGlobalContext();
1537 }
1538 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1539 }
1540
GL_TexCoordP1uiv(GLenum type,const GLuint * coords)1541 void GL_APIENTRY GL_TexCoordP1uiv(GLenum type, const GLuint *coords)
1542 {
1543 Context *context = GetValidGlobalContext();
1544 EVENT(context, GLTexCoordP1uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
1545 CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1546
1547 if (context)
1548 {
1549 SCOPED_SHARE_CONTEXT_LOCK(context);
1550 bool isCallValid =
1551 (context->skipValidation() ||
1552 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1553 context->getMutableErrorSetForValidation(),
1554 angle::EntryPoint::GLTexCoordP1uiv) &&
1555 ValidateTexCoordP1uiv(context, angle::EntryPoint::GLTexCoordP1uiv, type, coords)));
1556 if (isCallValid)
1557 {
1558 context->texCoordP1uiv(type, coords);
1559 }
1560 ANGLE_CAPTURE_GL(TexCoordP1uiv, isCallValid, context, type, coords);
1561 }
1562 else
1563 {
1564 GenerateContextLostErrorOnCurrentGlobalContext();
1565 }
1566 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1567 }
1568
GL_TexCoordP2ui(GLenum type,GLuint coords)1569 void GL_APIENTRY GL_TexCoordP2ui(GLenum type, GLuint coords)
1570 {
1571 Context *context = GetValidGlobalContext();
1572 EVENT(context, GLTexCoordP2ui, "context = %d, type = %s, coords = %u", CID(context),
1573 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1574
1575 if (context)
1576 {
1577 SCOPED_SHARE_CONTEXT_LOCK(context);
1578 bool isCallValid =
1579 (context->skipValidation() ||
1580 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1581 context->getMutableErrorSetForValidation(),
1582 angle::EntryPoint::GLTexCoordP2ui) &&
1583 ValidateTexCoordP2ui(context, angle::EntryPoint::GLTexCoordP2ui, type, coords)));
1584 if (isCallValid)
1585 {
1586 context->texCoordP2ui(type, coords);
1587 }
1588 ANGLE_CAPTURE_GL(TexCoordP2ui, isCallValid, context, type, coords);
1589 }
1590 else
1591 {
1592 GenerateContextLostErrorOnCurrentGlobalContext();
1593 }
1594 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1595 }
1596
GL_TexCoordP2uiv(GLenum type,const GLuint * coords)1597 void GL_APIENTRY GL_TexCoordP2uiv(GLenum type, const GLuint *coords)
1598 {
1599 Context *context = GetValidGlobalContext();
1600 EVENT(context, GLTexCoordP2uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
1601 CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1602
1603 if (context)
1604 {
1605 SCOPED_SHARE_CONTEXT_LOCK(context);
1606 bool isCallValid =
1607 (context->skipValidation() ||
1608 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1609 context->getMutableErrorSetForValidation(),
1610 angle::EntryPoint::GLTexCoordP2uiv) &&
1611 ValidateTexCoordP2uiv(context, angle::EntryPoint::GLTexCoordP2uiv, type, coords)));
1612 if (isCallValid)
1613 {
1614 context->texCoordP2uiv(type, coords);
1615 }
1616 ANGLE_CAPTURE_GL(TexCoordP2uiv, isCallValid, context, type, coords);
1617 }
1618 else
1619 {
1620 GenerateContextLostErrorOnCurrentGlobalContext();
1621 }
1622 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1623 }
1624
GL_TexCoordP3ui(GLenum type,GLuint coords)1625 void GL_APIENTRY GL_TexCoordP3ui(GLenum type, GLuint coords)
1626 {
1627 Context *context = GetValidGlobalContext();
1628 EVENT(context, GLTexCoordP3ui, "context = %d, type = %s, coords = %u", CID(context),
1629 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1630
1631 if (context)
1632 {
1633 SCOPED_SHARE_CONTEXT_LOCK(context);
1634 bool isCallValid =
1635 (context->skipValidation() ||
1636 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1637 context->getMutableErrorSetForValidation(),
1638 angle::EntryPoint::GLTexCoordP3ui) &&
1639 ValidateTexCoordP3ui(context, angle::EntryPoint::GLTexCoordP3ui, type, coords)));
1640 if (isCallValid)
1641 {
1642 context->texCoordP3ui(type, coords);
1643 }
1644 ANGLE_CAPTURE_GL(TexCoordP3ui, isCallValid, context, type, coords);
1645 }
1646 else
1647 {
1648 GenerateContextLostErrorOnCurrentGlobalContext();
1649 }
1650 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1651 }
1652
GL_TexCoordP3uiv(GLenum type,const GLuint * coords)1653 void GL_APIENTRY GL_TexCoordP3uiv(GLenum type, const GLuint *coords)
1654 {
1655 Context *context = GetValidGlobalContext();
1656 EVENT(context, GLTexCoordP3uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
1657 CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1658
1659 if (context)
1660 {
1661 SCOPED_SHARE_CONTEXT_LOCK(context);
1662 bool isCallValid =
1663 (context->skipValidation() ||
1664 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1665 context->getMutableErrorSetForValidation(),
1666 angle::EntryPoint::GLTexCoordP3uiv) &&
1667 ValidateTexCoordP3uiv(context, angle::EntryPoint::GLTexCoordP3uiv, type, coords)));
1668 if (isCallValid)
1669 {
1670 context->texCoordP3uiv(type, coords);
1671 }
1672 ANGLE_CAPTURE_GL(TexCoordP3uiv, isCallValid, context, type, coords);
1673 }
1674 else
1675 {
1676 GenerateContextLostErrorOnCurrentGlobalContext();
1677 }
1678 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1679 }
1680
GL_TexCoordP4ui(GLenum type,GLuint coords)1681 void GL_APIENTRY GL_TexCoordP4ui(GLenum type, GLuint coords)
1682 {
1683 Context *context = GetValidGlobalContext();
1684 EVENT(context, GLTexCoordP4ui, "context = %d, type = %s, coords = %u", CID(context),
1685 GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
1686
1687 if (context)
1688 {
1689 SCOPED_SHARE_CONTEXT_LOCK(context);
1690 bool isCallValid =
1691 (context->skipValidation() ||
1692 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1693 context->getMutableErrorSetForValidation(),
1694 angle::EntryPoint::GLTexCoordP4ui) &&
1695 ValidateTexCoordP4ui(context, angle::EntryPoint::GLTexCoordP4ui, type, coords)));
1696 if (isCallValid)
1697 {
1698 context->texCoordP4ui(type, coords);
1699 }
1700 ANGLE_CAPTURE_GL(TexCoordP4ui, isCallValid, context, type, coords);
1701 }
1702 else
1703 {
1704 GenerateContextLostErrorOnCurrentGlobalContext();
1705 }
1706 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1707 }
1708
GL_TexCoordP4uiv(GLenum type,const GLuint * coords)1709 void GL_APIENTRY GL_TexCoordP4uiv(GLenum type, const GLuint *coords)
1710 {
1711 Context *context = GetValidGlobalContext();
1712 EVENT(context, GLTexCoordP4uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
1713 CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
1714
1715 if (context)
1716 {
1717 SCOPED_SHARE_CONTEXT_LOCK(context);
1718 bool isCallValid =
1719 (context->skipValidation() ||
1720 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1721 context->getMutableErrorSetForValidation(),
1722 angle::EntryPoint::GLTexCoordP4uiv) &&
1723 ValidateTexCoordP4uiv(context, angle::EntryPoint::GLTexCoordP4uiv, type, coords)));
1724 if (isCallValid)
1725 {
1726 context->texCoordP4uiv(type, coords);
1727 }
1728 ANGLE_CAPTURE_GL(TexCoordP4uiv, isCallValid, context, type, coords);
1729 }
1730 else
1731 {
1732 GenerateContextLostErrorOnCurrentGlobalContext();
1733 }
1734 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1735 }
1736
GL_VertexAttribP1ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1737 void GL_APIENTRY GL_VertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1738 {
1739 Context *context = GetValidGlobalContext();
1740 EVENT(context, GLVertexAttribP1ui,
1741 "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
1742 GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
1743 value);
1744
1745 if (context)
1746 {
1747 bool isCallValid =
1748 (context->skipValidation() ||
1749 ValidateVertexAttribP1ui(
1750 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1751 angle::EntryPoint::GLVertexAttribP1ui, index, type, normalized, value));
1752 if (isCallValid)
1753 {
1754 ContextPrivateVertexAttribP1ui(context->getMutablePrivateState(),
1755 context->getMutablePrivateStateCache(), index, type,
1756 normalized, value);
1757 }
1758 ANGLE_CAPTURE_GL(VertexAttribP1ui, isCallValid, context, index, type, normalized, value);
1759 }
1760 else
1761 {
1762 GenerateContextLostErrorOnCurrentGlobalContext();
1763 }
1764 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1765 }
1766
GL_VertexAttribP1uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1767 void GL_APIENTRY GL_VertexAttribP1uiv(GLuint index,
1768 GLenum type,
1769 GLboolean normalized,
1770 const GLuint *value)
1771 {
1772 Context *context = GetValidGlobalContext();
1773 EVENT(context, GLVertexAttribP1uiv,
1774 "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
1775 CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
1776 GLbooleanToString(normalized), (uintptr_t)value);
1777
1778 if (context)
1779 {
1780 bool isCallValid =
1781 (context->skipValidation() ||
1782 ValidateVertexAttribP1uiv(
1783 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1784 angle::EntryPoint::GLVertexAttribP1uiv, index, type, normalized, value));
1785 if (isCallValid)
1786 {
1787 ContextPrivateVertexAttribP1uiv(context->getMutablePrivateState(),
1788 context->getMutablePrivateStateCache(), index, type,
1789 normalized, value);
1790 }
1791 ANGLE_CAPTURE_GL(VertexAttribP1uiv, isCallValid, context, index, type, normalized, value);
1792 }
1793 else
1794 {
1795 GenerateContextLostErrorOnCurrentGlobalContext();
1796 }
1797 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1798 }
1799
GL_VertexAttribP2ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1800 void GL_APIENTRY GL_VertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1801 {
1802 Context *context = GetValidGlobalContext();
1803 EVENT(context, GLVertexAttribP2ui,
1804 "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
1805 GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
1806 value);
1807
1808 if (context)
1809 {
1810 bool isCallValid =
1811 (context->skipValidation() ||
1812 ValidateVertexAttribP2ui(
1813 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1814 angle::EntryPoint::GLVertexAttribP2ui, index, type, normalized, value));
1815 if (isCallValid)
1816 {
1817 ContextPrivateVertexAttribP2ui(context->getMutablePrivateState(),
1818 context->getMutablePrivateStateCache(), index, type,
1819 normalized, value);
1820 }
1821 ANGLE_CAPTURE_GL(VertexAttribP2ui, isCallValid, context, index, type, normalized, value);
1822 }
1823 else
1824 {
1825 GenerateContextLostErrorOnCurrentGlobalContext();
1826 }
1827 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1828 }
1829
GL_VertexAttribP2uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1830 void GL_APIENTRY GL_VertexAttribP2uiv(GLuint index,
1831 GLenum type,
1832 GLboolean normalized,
1833 const GLuint *value)
1834 {
1835 Context *context = GetValidGlobalContext();
1836 EVENT(context, GLVertexAttribP2uiv,
1837 "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
1838 CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
1839 GLbooleanToString(normalized), (uintptr_t)value);
1840
1841 if (context)
1842 {
1843 bool isCallValid =
1844 (context->skipValidation() ||
1845 ValidateVertexAttribP2uiv(
1846 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1847 angle::EntryPoint::GLVertexAttribP2uiv, index, type, normalized, value));
1848 if (isCallValid)
1849 {
1850 ContextPrivateVertexAttribP2uiv(context->getMutablePrivateState(),
1851 context->getMutablePrivateStateCache(), index, type,
1852 normalized, value);
1853 }
1854 ANGLE_CAPTURE_GL(VertexAttribP2uiv, isCallValid, context, index, type, normalized, value);
1855 }
1856 else
1857 {
1858 GenerateContextLostErrorOnCurrentGlobalContext();
1859 }
1860 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1861 }
1862
GL_VertexAttribP3ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1863 void GL_APIENTRY GL_VertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1864 {
1865 Context *context = GetValidGlobalContext();
1866 EVENT(context, GLVertexAttribP3ui,
1867 "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
1868 GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
1869 value);
1870
1871 if (context)
1872 {
1873 bool isCallValid =
1874 (context->skipValidation() ||
1875 ValidateVertexAttribP3ui(
1876 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1877 angle::EntryPoint::GLVertexAttribP3ui, index, type, normalized, value));
1878 if (isCallValid)
1879 {
1880 ContextPrivateVertexAttribP3ui(context->getMutablePrivateState(),
1881 context->getMutablePrivateStateCache(), index, type,
1882 normalized, value);
1883 }
1884 ANGLE_CAPTURE_GL(VertexAttribP3ui, isCallValid, context, index, type, normalized, value);
1885 }
1886 else
1887 {
1888 GenerateContextLostErrorOnCurrentGlobalContext();
1889 }
1890 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1891 }
1892
GL_VertexAttribP3uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1893 void GL_APIENTRY GL_VertexAttribP3uiv(GLuint index,
1894 GLenum type,
1895 GLboolean normalized,
1896 const GLuint *value)
1897 {
1898 Context *context = GetValidGlobalContext();
1899 EVENT(context, GLVertexAttribP3uiv,
1900 "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
1901 CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
1902 GLbooleanToString(normalized), (uintptr_t)value);
1903
1904 if (context)
1905 {
1906 bool isCallValid =
1907 (context->skipValidation() ||
1908 ValidateVertexAttribP3uiv(
1909 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1910 angle::EntryPoint::GLVertexAttribP3uiv, index, type, normalized, value));
1911 if (isCallValid)
1912 {
1913 ContextPrivateVertexAttribP3uiv(context->getMutablePrivateState(),
1914 context->getMutablePrivateStateCache(), index, type,
1915 normalized, value);
1916 }
1917 ANGLE_CAPTURE_GL(VertexAttribP3uiv, isCallValid, context, index, type, normalized, value);
1918 }
1919 else
1920 {
1921 GenerateContextLostErrorOnCurrentGlobalContext();
1922 }
1923 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1924 }
1925
GL_VertexAttribP4ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1926 void GL_APIENTRY GL_VertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1927 {
1928 Context *context = GetValidGlobalContext();
1929 EVENT(context, GLVertexAttribP4ui,
1930 "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
1931 GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
1932 value);
1933
1934 if (context)
1935 {
1936 bool isCallValid =
1937 (context->skipValidation() ||
1938 ValidateVertexAttribP4ui(
1939 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1940 angle::EntryPoint::GLVertexAttribP4ui, index, type, normalized, value));
1941 if (isCallValid)
1942 {
1943 ContextPrivateVertexAttribP4ui(context->getMutablePrivateState(),
1944 context->getMutablePrivateStateCache(), index, type,
1945 normalized, value);
1946 }
1947 ANGLE_CAPTURE_GL(VertexAttribP4ui, isCallValid, context, index, type, normalized, value);
1948 }
1949 else
1950 {
1951 GenerateContextLostErrorOnCurrentGlobalContext();
1952 }
1953 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1954 }
1955
GL_VertexAttribP4uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1956 void GL_APIENTRY GL_VertexAttribP4uiv(GLuint index,
1957 GLenum type,
1958 GLboolean normalized,
1959 const GLuint *value)
1960 {
1961 Context *context = GetValidGlobalContext();
1962 EVENT(context, GLVertexAttribP4uiv,
1963 "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
1964 CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
1965 GLbooleanToString(normalized), (uintptr_t)value);
1966
1967 if (context)
1968 {
1969 bool isCallValid =
1970 (context->skipValidation() ||
1971 ValidateVertexAttribP4uiv(
1972 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1973 angle::EntryPoint::GLVertexAttribP4uiv, index, type, normalized, value));
1974 if (isCallValid)
1975 {
1976 ContextPrivateVertexAttribP4uiv(context->getMutablePrivateState(),
1977 context->getMutablePrivateStateCache(), index, type,
1978 normalized, value);
1979 }
1980 ANGLE_CAPTURE_GL(VertexAttribP4uiv, isCallValid, context, index, type, normalized, value);
1981 }
1982 else
1983 {
1984 GenerateContextLostErrorOnCurrentGlobalContext();
1985 }
1986 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1987 }
1988
GL_VertexP2ui(GLenum type,GLuint value)1989 void GL_APIENTRY GL_VertexP2ui(GLenum type, GLuint value)
1990 {
1991 Context *context = GetValidGlobalContext();
1992 EVENT(context, GLVertexP2ui, "context = %d, type = %s, value = %u", CID(context),
1993 GLenumToString(BigGLEnum::VertexPointerType, type), value);
1994
1995 if (context)
1996 {
1997 SCOPED_SHARE_CONTEXT_LOCK(context);
1998 bool isCallValid =
1999 (context->skipValidation() ||
2000 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2001 context->getMutableErrorSetForValidation(),
2002 angle::EntryPoint::GLVertexP2ui) &&
2003 ValidateVertexP2ui(context, angle::EntryPoint::GLVertexP2ui, type, value)));
2004 if (isCallValid)
2005 {
2006 context->vertexP2ui(type, value);
2007 }
2008 ANGLE_CAPTURE_GL(VertexP2ui, isCallValid, context, type, value);
2009 }
2010 else
2011 {
2012 GenerateContextLostErrorOnCurrentGlobalContext();
2013 }
2014 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2015 }
2016
GL_VertexP2uiv(GLenum type,const GLuint * value)2017 void GL_APIENTRY GL_VertexP2uiv(GLenum type, const GLuint *value)
2018 {
2019 Context *context = GetValidGlobalContext();
2020 EVENT(context, GLVertexP2uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "",
2021 CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value);
2022
2023 if (context)
2024 {
2025 SCOPED_SHARE_CONTEXT_LOCK(context);
2026 bool isCallValid =
2027 (context->skipValidation() ||
2028 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2029 context->getMutableErrorSetForValidation(),
2030 angle::EntryPoint::GLVertexP2uiv) &&
2031 ValidateVertexP2uiv(context, angle::EntryPoint::GLVertexP2uiv, type, value)));
2032 if (isCallValid)
2033 {
2034 context->vertexP2uiv(type, value);
2035 }
2036 ANGLE_CAPTURE_GL(VertexP2uiv, isCallValid, context, type, value);
2037 }
2038 else
2039 {
2040 GenerateContextLostErrorOnCurrentGlobalContext();
2041 }
2042 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2043 }
2044
GL_VertexP3ui(GLenum type,GLuint value)2045 void GL_APIENTRY GL_VertexP3ui(GLenum type, GLuint value)
2046 {
2047 Context *context = GetValidGlobalContext();
2048 EVENT(context, GLVertexP3ui, "context = %d, type = %s, value = %u", CID(context),
2049 GLenumToString(BigGLEnum::VertexPointerType, type), value);
2050
2051 if (context)
2052 {
2053 SCOPED_SHARE_CONTEXT_LOCK(context);
2054 bool isCallValid =
2055 (context->skipValidation() ||
2056 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2057 context->getMutableErrorSetForValidation(),
2058 angle::EntryPoint::GLVertexP3ui) &&
2059 ValidateVertexP3ui(context, angle::EntryPoint::GLVertexP3ui, type, value)));
2060 if (isCallValid)
2061 {
2062 context->vertexP3ui(type, value);
2063 }
2064 ANGLE_CAPTURE_GL(VertexP3ui, isCallValid, context, type, value);
2065 }
2066 else
2067 {
2068 GenerateContextLostErrorOnCurrentGlobalContext();
2069 }
2070 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2071 }
2072
GL_VertexP3uiv(GLenum type,const GLuint * value)2073 void GL_APIENTRY GL_VertexP3uiv(GLenum type, const GLuint *value)
2074 {
2075 Context *context = GetValidGlobalContext();
2076 EVENT(context, GLVertexP3uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "",
2077 CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value);
2078
2079 if (context)
2080 {
2081 SCOPED_SHARE_CONTEXT_LOCK(context);
2082 bool isCallValid =
2083 (context->skipValidation() ||
2084 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2085 context->getMutableErrorSetForValidation(),
2086 angle::EntryPoint::GLVertexP3uiv) &&
2087 ValidateVertexP3uiv(context, angle::EntryPoint::GLVertexP3uiv, type, value)));
2088 if (isCallValid)
2089 {
2090 context->vertexP3uiv(type, value);
2091 }
2092 ANGLE_CAPTURE_GL(VertexP3uiv, isCallValid, context, type, value);
2093 }
2094 else
2095 {
2096 GenerateContextLostErrorOnCurrentGlobalContext();
2097 }
2098 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2099 }
2100
GL_VertexP4ui(GLenum type,GLuint value)2101 void GL_APIENTRY GL_VertexP4ui(GLenum type, GLuint value)
2102 {
2103 Context *context = GetValidGlobalContext();
2104 EVENT(context, GLVertexP4ui, "context = %d, type = %s, value = %u", CID(context),
2105 GLenumToString(BigGLEnum::VertexPointerType, type), value);
2106
2107 if (context)
2108 {
2109 SCOPED_SHARE_CONTEXT_LOCK(context);
2110 bool isCallValid =
2111 (context->skipValidation() ||
2112 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2113 context->getMutableErrorSetForValidation(),
2114 angle::EntryPoint::GLVertexP4ui) &&
2115 ValidateVertexP4ui(context, angle::EntryPoint::GLVertexP4ui, type, value)));
2116 if (isCallValid)
2117 {
2118 context->vertexP4ui(type, value);
2119 }
2120 ANGLE_CAPTURE_GL(VertexP4ui, isCallValid, context, type, value);
2121 }
2122 else
2123 {
2124 GenerateContextLostErrorOnCurrentGlobalContext();
2125 }
2126 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2127 }
2128
GL_VertexP4uiv(GLenum type,const GLuint * value)2129 void GL_APIENTRY GL_VertexP4uiv(GLenum type, const GLuint *value)
2130 {
2131 Context *context = GetValidGlobalContext();
2132 EVENT(context, GLVertexP4uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "",
2133 CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value);
2134
2135 if (context)
2136 {
2137 SCOPED_SHARE_CONTEXT_LOCK(context);
2138 bool isCallValid =
2139 (context->skipValidation() ||
2140 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2141 context->getMutableErrorSetForValidation(),
2142 angle::EntryPoint::GLVertexP4uiv) &&
2143 ValidateVertexP4uiv(context, angle::EntryPoint::GLVertexP4uiv, type, value)));
2144 if (isCallValid)
2145 {
2146 context->vertexP4uiv(type, value);
2147 }
2148 ANGLE_CAPTURE_GL(VertexP4uiv, isCallValid, context, type, value);
2149 }
2150 else
2151 {
2152 GenerateContextLostErrorOnCurrentGlobalContext();
2153 }
2154 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2155 }
2156
2157 } // extern "C"
2158