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_3_autogen.cpp:
9 //   Defines the GL 3.3 entry points.
10 
11 #include "libGL/entry_points_gl_3_3_autogen.h"
12 
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/entry_points_utils.h"
16 #include "libANGLE/gl_enum_utils.h"
17 #include "libANGLE/validationEGL.h"
18 #include "libANGLE/validationES.h"
19 #include "libANGLE/validationES1.h"
20 #include "libANGLE/validationES2.h"
21 #include "libANGLE/validationES3.h"
22 #include "libANGLE/validationES31.h"
23 #include "libANGLE/validationES32.h"
24 #include "libANGLE/validationESEXT.h"
25 #include "libANGLE/validationGL33_autogen.h"
26 #include "libGLESv2/global_state.h"
27 
28 namespace gl
29 {
BindFragDataLocationIndexed(GLuint program,GLuint colorNumber,GLuint index,const GLchar * name)30 void GL_APIENTRY BindFragDataLocationIndexed(GLuint program,
31                                              GLuint colorNumber,
32                                              GLuint index,
33                                              const GLchar *name)
34 {
35     Context *context = GetValidGlobalContext();
36     EVENT("glBindFragDataLocationIndexed",
37           "context = %d, GLuint program = %u, GLuint colorNumber = %u, GLuint index = %u, const "
38           "GLchar *name = 0x%016" PRIxPTR "",
39           CID(context), program, colorNumber, index, (uintptr_t)name);
40 
41     if (context)
42     {
43         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
44         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
45         bool isCallValid =
46             (context->skipValidation() ||
47              ValidateBindFragDataLocationIndexed(context, programPacked, colorNumber, index, name));
48         if (isCallValid)
49         {
50             context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
51         }
52         ANGLE_CAPTURE(BindFragDataLocationIndexed, isCallValid, context, programPacked, colorNumber,
53                       index, name);
54     }
55 }
56 
BindSampler(GLuint unit,GLuint sampler)57 void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler)
58 {
59     Context *context = GetValidGlobalContext();
60     EVENT("glBindSampler", "context = %d, GLuint unit = %u, GLuint sampler = %u", CID(context),
61           unit, sampler);
62 
63     if (context)
64     {
65         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
66         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
67         bool isCallValid =
68             (context->skipValidation() || ValidateBindSampler(context, unit, samplerPacked));
69         if (isCallValid)
70         {
71             context->bindSampler(unit, samplerPacked);
72         }
73         ANGLE_CAPTURE(BindSampler, isCallValid, context, unit, samplerPacked);
74     }
75 }
76 
ColorP3ui(GLenum type,GLuint color)77 void GL_APIENTRY ColorP3ui(GLenum type, GLuint color)
78 {
79     Context *context = GetValidGlobalContext();
80     EVENT("glColorP3ui", "context = %d, GLenum type = %s, GLuint color = %u", CID(context),
81           GLenumToString(GLenumGroup::ColorPointerType, type), color);
82 
83     if (context)
84     {
85         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
86         bool isCallValid = (context->skipValidation() || ValidateColorP3ui(context, type, color));
87         if (isCallValid)
88         {
89             context->colorP3ui(type, color);
90         }
91         ANGLE_CAPTURE(ColorP3ui, isCallValid, context, type, color);
92     }
93 }
94 
ColorP3uiv(GLenum type,const GLuint * color)95 void GL_APIENTRY ColorP3uiv(GLenum type, const GLuint *color)
96 {
97     Context *context = GetValidGlobalContext();
98     EVENT("glColorP3uiv", "context = %d, GLenum type = %s, const GLuint *color = 0x%016" PRIxPTR "",
99           CID(context), GLenumToString(GLenumGroup::ColorPointerType, type), (uintptr_t)color);
100 
101     if (context)
102     {
103         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
104         bool isCallValid = (context->skipValidation() || ValidateColorP3uiv(context, type, color));
105         if (isCallValid)
106         {
107             context->colorP3uiv(type, color);
108         }
109         ANGLE_CAPTURE(ColorP3uiv, isCallValid, context, type, color);
110     }
111 }
112 
ColorP4ui(GLenum type,GLuint color)113 void GL_APIENTRY ColorP4ui(GLenum type, GLuint color)
114 {
115     Context *context = GetValidGlobalContext();
116     EVENT("glColorP4ui", "context = %d, GLenum type = %s, GLuint color = %u", CID(context),
117           GLenumToString(GLenumGroup::ColorPointerType, type), color);
118 
119     if (context)
120     {
121         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
122         bool isCallValid = (context->skipValidation() || ValidateColorP4ui(context, type, color));
123         if (isCallValid)
124         {
125             context->colorP4ui(type, color);
126         }
127         ANGLE_CAPTURE(ColorP4ui, isCallValid, context, type, color);
128     }
129 }
130 
ColorP4uiv(GLenum type,const GLuint * color)131 void GL_APIENTRY ColorP4uiv(GLenum type, const GLuint *color)
132 {
133     Context *context = GetValidGlobalContext();
134     EVENT("glColorP4uiv", "context = %d, GLenum type = %s, const GLuint *color = 0x%016" PRIxPTR "",
135           CID(context), GLenumToString(GLenumGroup::ColorPointerType, type), (uintptr_t)color);
136 
137     if (context)
138     {
139         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
140         bool isCallValid = (context->skipValidation() || ValidateColorP4uiv(context, type, color));
141         if (isCallValid)
142         {
143             context->colorP4uiv(type, color);
144         }
145         ANGLE_CAPTURE(ColorP4uiv, isCallValid, context, type, color);
146     }
147 }
148 
DeleteSamplers(GLsizei count,const GLuint * samplers)149 void GL_APIENTRY DeleteSamplers(GLsizei count, const GLuint *samplers)
150 {
151     Context *context = GetValidGlobalContext();
152     EVENT("glDeleteSamplers",
153           "context = %d, GLsizei count = %d, const GLuint *samplers = 0x%016" PRIxPTR "",
154           CID(context), count, (uintptr_t)samplers);
155 
156     if (context)
157     {
158         const SamplerID *samplersPacked                       = FromGL<const SamplerID *>(samplers);
159         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
160         bool isCallValid =
161             (context->skipValidation() || ValidateDeleteSamplers(context, count, samplersPacked));
162         if (isCallValid)
163         {
164             context->deleteSamplers(count, samplersPacked);
165         }
166         ANGLE_CAPTURE(DeleteSamplers, isCallValid, context, count, samplersPacked);
167     }
168 }
169 
GenSamplers(GLsizei count,GLuint * samplers)170 void GL_APIENTRY GenSamplers(GLsizei count, GLuint *samplers)
171 {
172     Context *context = GetValidGlobalContext();
173     EVENT("glGenSamplers", "context = %d, GLsizei count = %d, GLuint *samplers = 0x%016" PRIxPTR "",
174           CID(context), count, (uintptr_t)samplers);
175 
176     if (context)
177     {
178         SamplerID *samplersPacked                             = FromGL<SamplerID *>(samplers);
179         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
180         bool isCallValid =
181             (context->skipValidation() || ValidateGenSamplers(context, count, samplersPacked));
182         if (isCallValid)
183         {
184             context->genSamplers(count, samplersPacked);
185         }
186         ANGLE_CAPTURE(GenSamplers, isCallValid, context, count, samplersPacked);
187     }
188 }
189 
GetFragDataIndex(GLuint program,const GLchar * name)190 GLint GL_APIENTRY GetFragDataIndex(GLuint program, const GLchar *name)
191 {
192     Context *context = GetValidGlobalContext();
193     EVENT("glGetFragDataIndex",
194           "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
195           program, (uintptr_t)name);
196 
197     GLint returnValue;
198     if (context)
199     {
200         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
201         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
202         bool isCallValid =
203             (context->skipValidation() || ValidateGetFragDataIndex(context, programPacked, name));
204         if (isCallValid)
205         {
206             returnValue = context->getFragDataIndex(programPacked, name);
207         }
208         else
209         {
210             returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataIndex, GLint>();
211         }
212         ANGLE_CAPTURE(GetFragDataIndex, isCallValid, context, programPacked, name, returnValue);
213     }
214     else
215     {
216         returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataIndex, GLint>();
217     }
218     return returnValue;
219 }
220 
GetQueryObjecti64v(GLuint id,GLenum pname,GLint64 * params)221 void GL_APIENTRY GetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
222 {
223     Context *context = GetGlobalContext();
224     EVENT("glGetQueryObjecti64v",
225           "context = %d, GLuint id = %u, GLenum pname = %s, GLint64 *params = 0x%016" PRIxPTR "",
226           CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
227           (uintptr_t)params);
228 
229     if (context)
230     {
231         QueryID idPacked                                      = FromGL<QueryID>(id);
232         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
233         bool isCallValid                                      = (context->skipValidation() ||
234                             ValidateGetQueryObjecti64v(context, idPacked, pname, params));
235         if (isCallValid)
236         {
237             context->getQueryObjecti64v(idPacked, pname, params);
238         }
239         ANGLE_CAPTURE(GetQueryObjecti64v, isCallValid, context, idPacked, pname, params);
240     }
241 }
242 
GetQueryObjectui64v(GLuint id,GLenum pname,GLuint64 * params)243 void GL_APIENTRY GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
244 {
245     Context *context = GetValidGlobalContext();
246     EVENT("glGetQueryObjectui64v",
247           "context = %d, GLuint id = %u, GLenum pname = %s, GLuint64 *params = 0x%016" PRIxPTR "",
248           CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
249           (uintptr_t)params);
250 
251     if (context)
252     {
253         QueryID idPacked                                      = FromGL<QueryID>(id);
254         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
255         bool isCallValid                                      = (context->skipValidation() ||
256                             ValidateGetQueryObjectui64v(context, idPacked, pname, params));
257         if (isCallValid)
258         {
259             context->getQueryObjectui64v(idPacked, pname, params);
260         }
261         ANGLE_CAPTURE(GetQueryObjectui64v, isCallValid, context, idPacked, pname, params);
262     }
263 }
264 
GetSamplerParameterIiv(GLuint sampler,GLenum pname,GLint * params)265 void GL_APIENTRY GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
266 {
267     Context *context = GetValidGlobalContext();
268     EVENT("glGetSamplerParameterIiv",
269           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
270           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
271           (uintptr_t)params);
272 
273     if (context)
274     {
275         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
276         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
277         bool isCallValid                                      = (context->skipValidation() ||
278                             ValidateGetSamplerParameterIiv(context, samplerPacked, pname, params));
279         if (isCallValid)
280         {
281             context->getSamplerParameterIiv(samplerPacked, pname, params);
282         }
283         ANGLE_CAPTURE(GetSamplerParameterIiv, isCallValid, context, samplerPacked, pname, params);
284     }
285 }
286 
GetSamplerParameterIuiv(GLuint sampler,GLenum pname,GLuint * params)287 void GL_APIENTRY GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
288 {
289     Context *context = GetValidGlobalContext();
290     EVENT("glGetSamplerParameterIuiv",
291           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR
292           "",
293           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
294           (uintptr_t)params);
295 
296     if (context)
297     {
298         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
299         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
300         bool isCallValid                                      = (context->skipValidation() ||
301                             ValidateGetSamplerParameterIuiv(context, samplerPacked, pname, params));
302         if (isCallValid)
303         {
304             context->getSamplerParameterIuiv(samplerPacked, pname, params);
305         }
306         ANGLE_CAPTURE(GetSamplerParameterIuiv, isCallValid, context, samplerPacked, pname, params);
307     }
308 }
309 
GetSamplerParameterfv(GLuint sampler,GLenum pname,GLfloat * params)310 void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
311 {
312     Context *context = GetValidGlobalContext();
313     EVENT("glGetSamplerParameterfv",
314           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
315           "",
316           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
317           (uintptr_t)params);
318 
319     if (context)
320     {
321         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
322         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
323         bool isCallValid                                      = (context->skipValidation() ||
324                             ValidateGetSamplerParameterfv(context, samplerPacked, pname, params));
325         if (isCallValid)
326         {
327             context->getSamplerParameterfv(samplerPacked, pname, params);
328         }
329         ANGLE_CAPTURE(GetSamplerParameterfv, isCallValid, context, samplerPacked, pname, params);
330     }
331 }
332 
GetSamplerParameteriv(GLuint sampler,GLenum pname,GLint * params)333 void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
334 {
335     Context *context = GetValidGlobalContext();
336     EVENT("glGetSamplerParameteriv",
337           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
338           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
339           (uintptr_t)params);
340 
341     if (context)
342     {
343         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
344         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
345         bool isCallValid                                      = (context->skipValidation() ||
346                             ValidateGetSamplerParameteriv(context, samplerPacked, pname, params));
347         if (isCallValid)
348         {
349             context->getSamplerParameteriv(samplerPacked, pname, params);
350         }
351         ANGLE_CAPTURE(GetSamplerParameteriv, isCallValid, context, samplerPacked, pname, params);
352     }
353 }
354 
IsSampler(GLuint sampler)355 GLboolean GL_APIENTRY IsSampler(GLuint sampler)
356 {
357     Context *context = GetValidGlobalContext();
358     EVENT("glIsSampler", "context = %d, GLuint sampler = %u", CID(context), sampler);
359 
360     GLboolean returnValue;
361     if (context)
362     {
363         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
364         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
365         bool isCallValid = (context->skipValidation() || ValidateIsSampler(context, samplerPacked));
366         if (isCallValid)
367         {
368             returnValue = context->isSampler(samplerPacked);
369         }
370         else
371         {
372             returnValue = GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
373         }
374         ANGLE_CAPTURE(IsSampler, isCallValid, context, samplerPacked, returnValue);
375     }
376     else
377     {
378         returnValue = GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
379     }
380     return returnValue;
381 }
382 
MultiTexCoordP1ui(GLenum texture,GLenum type,GLuint coords)383 void GL_APIENTRY MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
384 {
385     Context *context = GetValidGlobalContext();
386     EVENT("glMultiTexCoordP1ui",
387           "context = %d, GLenum texture = %s, GLenum type = %s, GLuint coords = %u", CID(context),
388           GLenumToString(GLenumGroup::TextureUnit, texture),
389           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
390 
391     if (context)
392     {
393         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
394         bool isCallValid                                      = (context->skipValidation() ||
395                             ValidateMultiTexCoordP1ui(context, texture, type, coords));
396         if (isCallValid)
397         {
398             context->multiTexCoordP1ui(texture, type, coords);
399         }
400         ANGLE_CAPTURE(MultiTexCoordP1ui, isCallValid, context, texture, type, coords);
401     }
402 }
403 
MultiTexCoordP1uiv(GLenum texture,GLenum type,const GLuint * coords)404 void GL_APIENTRY MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
405 {
406     Context *context = GetValidGlobalContext();
407     EVENT(
408         "glMultiTexCoordP1uiv",
409         "context = %d, GLenum texture = %s, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR
410         "",
411         CID(context), GLenumToString(GLenumGroup::TextureUnit, texture),
412         GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
413 
414     if (context)
415     {
416         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
417         bool isCallValid                                      = (context->skipValidation() ||
418                             ValidateMultiTexCoordP1uiv(context, texture, type, coords));
419         if (isCallValid)
420         {
421             context->multiTexCoordP1uiv(texture, type, coords);
422         }
423         ANGLE_CAPTURE(MultiTexCoordP1uiv, isCallValid, context, texture, type, coords);
424     }
425 }
426 
MultiTexCoordP2ui(GLenum texture,GLenum type,GLuint coords)427 void GL_APIENTRY MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
428 {
429     Context *context = GetValidGlobalContext();
430     EVENT("glMultiTexCoordP2ui",
431           "context = %d, GLenum texture = %s, GLenum type = %s, GLuint coords = %u", CID(context),
432           GLenumToString(GLenumGroup::TextureUnit, texture),
433           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
434 
435     if (context)
436     {
437         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
438         bool isCallValid                                      = (context->skipValidation() ||
439                             ValidateMultiTexCoordP2ui(context, texture, type, coords));
440         if (isCallValid)
441         {
442             context->multiTexCoordP2ui(texture, type, coords);
443         }
444         ANGLE_CAPTURE(MultiTexCoordP2ui, isCallValid, context, texture, type, coords);
445     }
446 }
447 
MultiTexCoordP2uiv(GLenum texture,GLenum type,const GLuint * coords)448 void GL_APIENTRY MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
449 {
450     Context *context = GetValidGlobalContext();
451     EVENT(
452         "glMultiTexCoordP2uiv",
453         "context = %d, GLenum texture = %s, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR
454         "",
455         CID(context), GLenumToString(GLenumGroup::TextureUnit, texture),
456         GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
457 
458     if (context)
459     {
460         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
461         bool isCallValid                                      = (context->skipValidation() ||
462                             ValidateMultiTexCoordP2uiv(context, texture, type, coords));
463         if (isCallValid)
464         {
465             context->multiTexCoordP2uiv(texture, type, coords);
466         }
467         ANGLE_CAPTURE(MultiTexCoordP2uiv, isCallValid, context, texture, type, coords);
468     }
469 }
470 
MultiTexCoordP3ui(GLenum texture,GLenum type,GLuint coords)471 void GL_APIENTRY MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
472 {
473     Context *context = GetValidGlobalContext();
474     EVENT("glMultiTexCoordP3ui",
475           "context = %d, GLenum texture = %s, GLenum type = %s, GLuint coords = %u", CID(context),
476           GLenumToString(GLenumGroup::TextureUnit, texture),
477           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
478 
479     if (context)
480     {
481         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
482         bool isCallValid                                      = (context->skipValidation() ||
483                             ValidateMultiTexCoordP3ui(context, texture, type, coords));
484         if (isCallValid)
485         {
486             context->multiTexCoordP3ui(texture, type, coords);
487         }
488         ANGLE_CAPTURE(MultiTexCoordP3ui, isCallValid, context, texture, type, coords);
489     }
490 }
491 
MultiTexCoordP3uiv(GLenum texture,GLenum type,const GLuint * coords)492 void GL_APIENTRY MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
493 {
494     Context *context = GetValidGlobalContext();
495     EVENT(
496         "glMultiTexCoordP3uiv",
497         "context = %d, GLenum texture = %s, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR
498         "",
499         CID(context), GLenumToString(GLenumGroup::TextureUnit, texture),
500         GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
501 
502     if (context)
503     {
504         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
505         bool isCallValid                                      = (context->skipValidation() ||
506                             ValidateMultiTexCoordP3uiv(context, texture, type, coords));
507         if (isCallValid)
508         {
509             context->multiTexCoordP3uiv(texture, type, coords);
510         }
511         ANGLE_CAPTURE(MultiTexCoordP3uiv, isCallValid, context, texture, type, coords);
512     }
513 }
514 
MultiTexCoordP4ui(GLenum texture,GLenum type,GLuint coords)515 void GL_APIENTRY MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
516 {
517     Context *context = GetValidGlobalContext();
518     EVENT("glMultiTexCoordP4ui",
519           "context = %d, GLenum texture = %s, GLenum type = %s, GLuint coords = %u", CID(context),
520           GLenumToString(GLenumGroup::TextureUnit, texture),
521           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
522 
523     if (context)
524     {
525         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
526         bool isCallValid                                      = (context->skipValidation() ||
527                             ValidateMultiTexCoordP4ui(context, texture, type, coords));
528         if (isCallValid)
529         {
530             context->multiTexCoordP4ui(texture, type, coords);
531         }
532         ANGLE_CAPTURE(MultiTexCoordP4ui, isCallValid, context, texture, type, coords);
533     }
534 }
535 
MultiTexCoordP4uiv(GLenum texture,GLenum type,const GLuint * coords)536 void GL_APIENTRY MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
537 {
538     Context *context = GetValidGlobalContext();
539     EVENT(
540         "glMultiTexCoordP4uiv",
541         "context = %d, GLenum texture = %s, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR
542         "",
543         CID(context), GLenumToString(GLenumGroup::TextureUnit, texture),
544         GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
545 
546     if (context)
547     {
548         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
549         bool isCallValid                                      = (context->skipValidation() ||
550                             ValidateMultiTexCoordP4uiv(context, texture, type, coords));
551         if (isCallValid)
552         {
553             context->multiTexCoordP4uiv(texture, type, coords);
554         }
555         ANGLE_CAPTURE(MultiTexCoordP4uiv, isCallValid, context, texture, type, coords);
556     }
557 }
558 
NormalP3ui(GLenum type,GLuint coords)559 void GL_APIENTRY NormalP3ui(GLenum type, GLuint coords)
560 {
561     Context *context = GetValidGlobalContext();
562     EVENT("glNormalP3ui", "context = %d, GLenum type = %s, GLuint coords = %u", CID(context),
563           GLenumToString(GLenumGroup::NormalPointerType, type), coords);
564 
565     if (context)
566     {
567         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
568         bool isCallValid = (context->skipValidation() || ValidateNormalP3ui(context, type, coords));
569         if (isCallValid)
570         {
571             context->normalP3ui(type, coords);
572         }
573         ANGLE_CAPTURE(NormalP3ui, isCallValid, context, type, coords);
574     }
575 }
576 
NormalP3uiv(GLenum type,const GLuint * coords)577 void GL_APIENTRY NormalP3uiv(GLenum type, const GLuint *coords)
578 {
579     Context *context = GetValidGlobalContext();
580     EVENT("glNormalP3uiv",
581           "context = %d, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR "", CID(context),
582           GLenumToString(GLenumGroup::NormalPointerType, type), (uintptr_t)coords);
583 
584     if (context)
585     {
586         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
587         bool isCallValid =
588             (context->skipValidation() || ValidateNormalP3uiv(context, type, coords));
589         if (isCallValid)
590         {
591             context->normalP3uiv(type, coords);
592         }
593         ANGLE_CAPTURE(NormalP3uiv, isCallValid, context, type, coords);
594     }
595 }
596 
QueryCounter(GLuint id,GLenum target)597 void GL_APIENTRY QueryCounter(GLuint id, GLenum target)
598 {
599     Context *context = GetValidGlobalContext();
600     EVENT("glQueryCounter", "context = %d, GLuint id = %u, GLenum target = %s", CID(context), id,
601           GLenumToString(GLenumGroup::QueryTarget, target));
602 
603     if (context)
604     {
605         QueryID idPacked                                      = FromGL<QueryID>(id);
606         QueryType targetPacked                                = FromGL<QueryType>(target);
607         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
608         bool isCallValid =
609             (context->skipValidation() || ValidateQueryCounter(context, idPacked, targetPacked));
610         if (isCallValid)
611         {
612             context->queryCounter(idPacked, targetPacked);
613         }
614         ANGLE_CAPTURE(QueryCounter, isCallValid, context, idPacked, targetPacked);
615     }
616 }
617 
SamplerParameterIiv(GLuint sampler,GLenum pname,const GLint * param)618 void GL_APIENTRY SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
619 {
620     Context *context = GetValidGlobalContext();
621     EVENT(
622         "glSamplerParameterIiv",
623         "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
624         "",
625         CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
626         (uintptr_t)param);
627 
628     if (context)
629     {
630         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
631         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
632         bool isCallValid                                      = (context->skipValidation() ||
633                             ValidateSamplerParameterIiv(context, samplerPacked, pname, param));
634         if (isCallValid)
635         {
636             context->samplerParameterIiv(samplerPacked, pname, param);
637         }
638         ANGLE_CAPTURE(SamplerParameterIiv, isCallValid, context, samplerPacked, pname, param);
639     }
640 }
641 
SamplerParameterIuiv(GLuint sampler,GLenum pname,const GLuint * param)642 void GL_APIENTRY SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
643 {
644     Context *context = GetValidGlobalContext();
645     EVENT(
646         "glSamplerParameterIuiv",
647         "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLuint *param = 0x%016" PRIxPTR
648         "",
649         CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
650         (uintptr_t)param);
651 
652     if (context)
653     {
654         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
655         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
656         bool isCallValid                                      = (context->skipValidation() ||
657                             ValidateSamplerParameterIuiv(context, samplerPacked, pname, param));
658         if (isCallValid)
659         {
660             context->samplerParameterIuiv(samplerPacked, pname, param);
661         }
662         ANGLE_CAPTURE(SamplerParameterIuiv, isCallValid, context, samplerPacked, pname, param);
663     }
664 }
665 
SamplerParameterf(GLuint sampler,GLenum pname,GLfloat param)666 void GL_APIENTRY SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
667 {
668     Context *context = GetValidGlobalContext();
669     EVENT("glSamplerParameterf",
670           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLfloat param = %f", CID(context),
671           sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param);
672 
673     if (context)
674     {
675         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
676         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
677         bool isCallValid                                      = (context->skipValidation() ||
678                             ValidateSamplerParameterf(context, samplerPacked, pname, param));
679         if (isCallValid)
680         {
681             context->samplerParameterf(samplerPacked, pname, param);
682         }
683         ANGLE_CAPTURE(SamplerParameterf, isCallValid, context, samplerPacked, pname, param);
684     }
685 }
686 
SamplerParameterfv(GLuint sampler,GLenum pname,const GLfloat * param)687 void GL_APIENTRY SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
688 {
689     Context *context = GetValidGlobalContext();
690     EVENT("glSamplerParameterfv",
691           "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLfloat *param = "
692           "0x%016" PRIxPTR "",
693           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
694           (uintptr_t)param);
695 
696     if (context)
697     {
698         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
699         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
700         bool isCallValid                                      = (context->skipValidation() ||
701                             ValidateSamplerParameterfv(context, samplerPacked, pname, param));
702         if (isCallValid)
703         {
704             context->samplerParameterfv(samplerPacked, pname, param);
705         }
706         ANGLE_CAPTURE(SamplerParameterfv, isCallValid, context, samplerPacked, pname, param);
707     }
708 }
709 
SamplerParameteri(GLuint sampler,GLenum pname,GLint param)710 void GL_APIENTRY SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
711 {
712     Context *context = GetValidGlobalContext();
713     EVENT("glSamplerParameteri",
714           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint param = %d", CID(context),
715           sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param);
716 
717     if (context)
718     {
719         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
720         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
721         bool isCallValid                                      = (context->skipValidation() ||
722                             ValidateSamplerParameteri(context, samplerPacked, pname, param));
723         if (isCallValid)
724         {
725             context->samplerParameteri(samplerPacked, pname, param);
726         }
727         ANGLE_CAPTURE(SamplerParameteri, isCallValid, context, samplerPacked, pname, param);
728     }
729 }
730 
SamplerParameteriv(GLuint sampler,GLenum pname,const GLint * param)731 void GL_APIENTRY SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
732 {
733     Context *context = GetValidGlobalContext();
734     EVENT(
735         "glSamplerParameteriv",
736         "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
737         "",
738         CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
739         (uintptr_t)param);
740 
741     if (context)
742     {
743         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
744         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
745         bool isCallValid                                      = (context->skipValidation() ||
746                             ValidateSamplerParameteriv(context, samplerPacked, pname, param));
747         if (isCallValid)
748         {
749             context->samplerParameteriv(samplerPacked, pname, param);
750         }
751         ANGLE_CAPTURE(SamplerParameteriv, isCallValid, context, samplerPacked, pname, param);
752     }
753 }
754 
SecondaryColorP3ui(GLenum type,GLuint color)755 void GL_APIENTRY SecondaryColorP3ui(GLenum type, GLuint color)
756 {
757     Context *context = GetValidGlobalContext();
758     EVENT("glSecondaryColorP3ui", "context = %d, GLenum type = %s, GLuint color = %u", CID(context),
759           GLenumToString(GLenumGroup::ColorPointerType, type), color);
760 
761     if (context)
762     {
763         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
764         bool isCallValid =
765             (context->skipValidation() || ValidateSecondaryColorP3ui(context, type, color));
766         if (isCallValid)
767         {
768             context->secondaryColorP3ui(type, color);
769         }
770         ANGLE_CAPTURE(SecondaryColorP3ui, isCallValid, context, type, color);
771     }
772 }
773 
SecondaryColorP3uiv(GLenum type,const GLuint * color)774 void GL_APIENTRY SecondaryColorP3uiv(GLenum type, const GLuint *color)
775 {
776     Context *context = GetValidGlobalContext();
777     EVENT("glSecondaryColorP3uiv",
778           "context = %d, GLenum type = %s, const GLuint *color = 0x%016" PRIxPTR "", CID(context),
779           GLenumToString(GLenumGroup::ColorPointerType, type), (uintptr_t)color);
780 
781     if (context)
782     {
783         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
784         bool isCallValid =
785             (context->skipValidation() || ValidateSecondaryColorP3uiv(context, type, color));
786         if (isCallValid)
787         {
788             context->secondaryColorP3uiv(type, color);
789         }
790         ANGLE_CAPTURE(SecondaryColorP3uiv, isCallValid, context, type, color);
791     }
792 }
793 
TexCoordP1ui(GLenum type,GLuint coords)794 void GL_APIENTRY TexCoordP1ui(GLenum type, GLuint coords)
795 {
796     Context *context = GetValidGlobalContext();
797     EVENT("glTexCoordP1ui", "context = %d, GLenum type = %s, GLuint coords = %u", CID(context),
798           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
799 
800     if (context)
801     {
802         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
803         bool isCallValid =
804             (context->skipValidation() || ValidateTexCoordP1ui(context, type, coords));
805         if (isCallValid)
806         {
807             context->texCoordP1ui(type, coords);
808         }
809         ANGLE_CAPTURE(TexCoordP1ui, isCallValid, context, type, coords);
810     }
811 }
812 
TexCoordP1uiv(GLenum type,const GLuint * coords)813 void GL_APIENTRY TexCoordP1uiv(GLenum type, const GLuint *coords)
814 {
815     Context *context = GetValidGlobalContext();
816     EVENT("glTexCoordP1uiv",
817           "context = %d, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR "", CID(context),
818           GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
819 
820     if (context)
821     {
822         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
823         bool isCallValid =
824             (context->skipValidation() || ValidateTexCoordP1uiv(context, type, coords));
825         if (isCallValid)
826         {
827             context->texCoordP1uiv(type, coords);
828         }
829         ANGLE_CAPTURE(TexCoordP1uiv, isCallValid, context, type, coords);
830     }
831 }
832 
TexCoordP2ui(GLenum type,GLuint coords)833 void GL_APIENTRY TexCoordP2ui(GLenum type, GLuint coords)
834 {
835     Context *context = GetValidGlobalContext();
836     EVENT("glTexCoordP2ui", "context = %d, GLenum type = %s, GLuint coords = %u", CID(context),
837           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
838 
839     if (context)
840     {
841         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
842         bool isCallValid =
843             (context->skipValidation() || ValidateTexCoordP2ui(context, type, coords));
844         if (isCallValid)
845         {
846             context->texCoordP2ui(type, coords);
847         }
848         ANGLE_CAPTURE(TexCoordP2ui, isCallValid, context, type, coords);
849     }
850 }
851 
TexCoordP2uiv(GLenum type,const GLuint * coords)852 void GL_APIENTRY TexCoordP2uiv(GLenum type, const GLuint *coords)
853 {
854     Context *context = GetValidGlobalContext();
855     EVENT("glTexCoordP2uiv",
856           "context = %d, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR "", CID(context),
857           GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
858 
859     if (context)
860     {
861         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
862         bool isCallValid =
863             (context->skipValidation() || ValidateTexCoordP2uiv(context, type, coords));
864         if (isCallValid)
865         {
866             context->texCoordP2uiv(type, coords);
867         }
868         ANGLE_CAPTURE(TexCoordP2uiv, isCallValid, context, type, coords);
869     }
870 }
871 
TexCoordP3ui(GLenum type,GLuint coords)872 void GL_APIENTRY TexCoordP3ui(GLenum type, GLuint coords)
873 {
874     Context *context = GetValidGlobalContext();
875     EVENT("glTexCoordP3ui", "context = %d, GLenum type = %s, GLuint coords = %u", CID(context),
876           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
877 
878     if (context)
879     {
880         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
881         bool isCallValid =
882             (context->skipValidation() || ValidateTexCoordP3ui(context, type, coords));
883         if (isCallValid)
884         {
885             context->texCoordP3ui(type, coords);
886         }
887         ANGLE_CAPTURE(TexCoordP3ui, isCallValid, context, type, coords);
888     }
889 }
890 
TexCoordP3uiv(GLenum type,const GLuint * coords)891 void GL_APIENTRY TexCoordP3uiv(GLenum type, const GLuint *coords)
892 {
893     Context *context = GetValidGlobalContext();
894     EVENT("glTexCoordP3uiv",
895           "context = %d, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR "", CID(context),
896           GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
897 
898     if (context)
899     {
900         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
901         bool isCallValid =
902             (context->skipValidation() || ValidateTexCoordP3uiv(context, type, coords));
903         if (isCallValid)
904         {
905             context->texCoordP3uiv(type, coords);
906         }
907         ANGLE_CAPTURE(TexCoordP3uiv, isCallValid, context, type, coords);
908     }
909 }
910 
TexCoordP4ui(GLenum type,GLuint coords)911 void GL_APIENTRY TexCoordP4ui(GLenum type, GLuint coords)
912 {
913     Context *context = GetValidGlobalContext();
914     EVENT("glTexCoordP4ui", "context = %d, GLenum type = %s, GLuint coords = %u", CID(context),
915           GLenumToString(GLenumGroup::TexCoordPointerType, type), coords);
916 
917     if (context)
918     {
919         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
920         bool isCallValid =
921             (context->skipValidation() || ValidateTexCoordP4ui(context, type, coords));
922         if (isCallValid)
923         {
924             context->texCoordP4ui(type, coords);
925         }
926         ANGLE_CAPTURE(TexCoordP4ui, isCallValid, context, type, coords);
927     }
928 }
929 
TexCoordP4uiv(GLenum type,const GLuint * coords)930 void GL_APIENTRY TexCoordP4uiv(GLenum type, const GLuint *coords)
931 {
932     Context *context = GetValidGlobalContext();
933     EVENT("glTexCoordP4uiv",
934           "context = %d, GLenum type = %s, const GLuint *coords = 0x%016" PRIxPTR "", CID(context),
935           GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords);
936 
937     if (context)
938     {
939         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
940         bool isCallValid =
941             (context->skipValidation() || ValidateTexCoordP4uiv(context, type, coords));
942         if (isCallValid)
943         {
944             context->texCoordP4uiv(type, coords);
945         }
946         ANGLE_CAPTURE(TexCoordP4uiv, isCallValid, context, type, coords);
947     }
948 }
949 
VertexAttribDivisor(GLuint index,GLuint divisor)950 void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor)
951 {
952     Context *context = GetValidGlobalContext();
953     EVENT("glVertexAttribDivisor", "context = %d, GLuint index = %u, GLuint divisor = %u",
954           CID(context), index, divisor);
955 
956     if (context)
957     {
958         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
959         bool isCallValid =
960             (context->skipValidation() || ValidateVertexAttribDivisor(context, index, divisor));
961         if (isCallValid)
962         {
963             context->vertexAttribDivisor(index, divisor);
964         }
965         ANGLE_CAPTURE(VertexAttribDivisor, isCallValid, context, index, divisor);
966     }
967 }
968 
VertexAttribP1ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)969 void GL_APIENTRY VertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
970 {
971     Context *context = GetValidGlobalContext();
972     EVENT("glVertexAttribP1ui",
973           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, GLuint "
974           "value = %u",
975           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
976           GLbooleanToString(normalized), value);
977 
978     if (context)
979     {
980         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
981         bool isCallValid                                      = (context->skipValidation() ||
982                             ValidateVertexAttribP1ui(context, index, type, normalized, value));
983         if (isCallValid)
984         {
985             context->vertexAttribP1ui(index, type, normalized, value);
986         }
987         ANGLE_CAPTURE(VertexAttribP1ui, isCallValid, context, index, type, normalized, value);
988     }
989 }
990 
VertexAttribP1uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)991 void GL_APIENTRY VertexAttribP1uiv(GLuint index,
992                                    GLenum type,
993                                    GLboolean normalized,
994                                    const GLuint *value)
995 {
996     Context *context = GetValidGlobalContext();
997     EVENT("glVertexAttribP1uiv",
998           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, const "
999           "GLuint *value = 0x%016" PRIxPTR "",
1000           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1001           GLbooleanToString(normalized), (uintptr_t)value);
1002 
1003     if (context)
1004     {
1005         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1006         bool isCallValid                                      = (context->skipValidation() ||
1007                             ValidateVertexAttribP1uiv(context, index, type, normalized, value));
1008         if (isCallValid)
1009         {
1010             context->vertexAttribP1uiv(index, type, normalized, value);
1011         }
1012         ANGLE_CAPTURE(VertexAttribP1uiv, isCallValid, context, index, type, normalized, value);
1013     }
1014 }
1015 
VertexAttribP2ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1016 void GL_APIENTRY VertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1017 {
1018     Context *context = GetValidGlobalContext();
1019     EVENT("glVertexAttribP2ui",
1020           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, GLuint "
1021           "value = %u",
1022           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1023           GLbooleanToString(normalized), value);
1024 
1025     if (context)
1026     {
1027         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1028         bool isCallValid                                      = (context->skipValidation() ||
1029                             ValidateVertexAttribP2ui(context, index, type, normalized, value));
1030         if (isCallValid)
1031         {
1032             context->vertexAttribP2ui(index, type, normalized, value);
1033         }
1034         ANGLE_CAPTURE(VertexAttribP2ui, isCallValid, context, index, type, normalized, value);
1035     }
1036 }
1037 
VertexAttribP2uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1038 void GL_APIENTRY VertexAttribP2uiv(GLuint index,
1039                                    GLenum type,
1040                                    GLboolean normalized,
1041                                    const GLuint *value)
1042 {
1043     Context *context = GetValidGlobalContext();
1044     EVENT("glVertexAttribP2uiv",
1045           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, const "
1046           "GLuint *value = 0x%016" PRIxPTR "",
1047           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1048           GLbooleanToString(normalized), (uintptr_t)value);
1049 
1050     if (context)
1051     {
1052         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1053         bool isCallValid                                      = (context->skipValidation() ||
1054                             ValidateVertexAttribP2uiv(context, index, type, normalized, value));
1055         if (isCallValid)
1056         {
1057             context->vertexAttribP2uiv(index, type, normalized, value);
1058         }
1059         ANGLE_CAPTURE(VertexAttribP2uiv, isCallValid, context, index, type, normalized, value);
1060     }
1061 }
1062 
VertexAttribP3ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1063 void GL_APIENTRY VertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1064 {
1065     Context *context = GetValidGlobalContext();
1066     EVENT("glVertexAttribP3ui",
1067           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, GLuint "
1068           "value = %u",
1069           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1070           GLbooleanToString(normalized), value);
1071 
1072     if (context)
1073     {
1074         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1075         bool isCallValid                                      = (context->skipValidation() ||
1076                             ValidateVertexAttribP3ui(context, index, type, normalized, value));
1077         if (isCallValid)
1078         {
1079             context->vertexAttribP3ui(index, type, normalized, value);
1080         }
1081         ANGLE_CAPTURE(VertexAttribP3ui, isCallValid, context, index, type, normalized, value);
1082     }
1083 }
1084 
VertexAttribP3uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1085 void GL_APIENTRY VertexAttribP3uiv(GLuint index,
1086                                    GLenum type,
1087                                    GLboolean normalized,
1088                                    const GLuint *value)
1089 {
1090     Context *context = GetValidGlobalContext();
1091     EVENT("glVertexAttribP3uiv",
1092           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, const "
1093           "GLuint *value = 0x%016" PRIxPTR "",
1094           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1095           GLbooleanToString(normalized), (uintptr_t)value);
1096 
1097     if (context)
1098     {
1099         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1100         bool isCallValid                                      = (context->skipValidation() ||
1101                             ValidateVertexAttribP3uiv(context, index, type, normalized, value));
1102         if (isCallValid)
1103         {
1104             context->vertexAttribP3uiv(index, type, normalized, value);
1105         }
1106         ANGLE_CAPTURE(VertexAttribP3uiv, isCallValid, context, index, type, normalized, value);
1107     }
1108 }
1109 
VertexAttribP4ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)1110 void GL_APIENTRY VertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
1111 {
1112     Context *context = GetValidGlobalContext();
1113     EVENT("glVertexAttribP4ui",
1114           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, GLuint "
1115           "value = %u",
1116           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1117           GLbooleanToString(normalized), value);
1118 
1119     if (context)
1120     {
1121         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1122         bool isCallValid                                      = (context->skipValidation() ||
1123                             ValidateVertexAttribP4ui(context, index, type, normalized, value));
1124         if (isCallValid)
1125         {
1126             context->vertexAttribP4ui(index, type, normalized, value);
1127         }
1128         ANGLE_CAPTURE(VertexAttribP4ui, isCallValid, context, index, type, normalized, value);
1129     }
1130 }
1131 
VertexAttribP4uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint * value)1132 void GL_APIENTRY VertexAttribP4uiv(GLuint index,
1133                                    GLenum type,
1134                                    GLboolean normalized,
1135                                    const GLuint *value)
1136 {
1137     Context *context = GetValidGlobalContext();
1138     EVENT("glVertexAttribP4uiv",
1139           "context = %d, GLuint index = %u, GLenum type = %s, GLboolean normalized = %s, const "
1140           "GLuint *value = 0x%016" PRIxPTR "",
1141           CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1142           GLbooleanToString(normalized), (uintptr_t)value);
1143 
1144     if (context)
1145     {
1146         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1147         bool isCallValid                                      = (context->skipValidation() ||
1148                             ValidateVertexAttribP4uiv(context, index, type, normalized, value));
1149         if (isCallValid)
1150         {
1151             context->vertexAttribP4uiv(index, type, normalized, value);
1152         }
1153         ANGLE_CAPTURE(VertexAttribP4uiv, isCallValid, context, index, type, normalized, value);
1154     }
1155 }
1156 
VertexP2ui(GLenum type,GLuint value)1157 void GL_APIENTRY VertexP2ui(GLenum type, GLuint value)
1158 {
1159     Context *context = GetValidGlobalContext();
1160     EVENT("glVertexP2ui", "context = %d, GLenum type = %s, GLuint value = %u", CID(context),
1161           GLenumToString(GLenumGroup::VertexPointerType, type), value);
1162 
1163     if (context)
1164     {
1165         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1166         bool isCallValid = (context->skipValidation() || ValidateVertexP2ui(context, type, value));
1167         if (isCallValid)
1168         {
1169             context->vertexP2ui(type, value);
1170         }
1171         ANGLE_CAPTURE(VertexP2ui, isCallValid, context, type, value);
1172     }
1173 }
1174 
VertexP2uiv(GLenum type,const GLuint * value)1175 void GL_APIENTRY VertexP2uiv(GLenum type, const GLuint *value)
1176 {
1177     Context *context = GetValidGlobalContext();
1178     EVENT("glVertexP2uiv",
1179           "context = %d, GLenum type = %s, const GLuint *value = 0x%016" PRIxPTR "", CID(context),
1180           GLenumToString(GLenumGroup::VertexPointerType, type), (uintptr_t)value);
1181 
1182     if (context)
1183     {
1184         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1185         bool isCallValid = (context->skipValidation() || ValidateVertexP2uiv(context, type, value));
1186         if (isCallValid)
1187         {
1188             context->vertexP2uiv(type, value);
1189         }
1190         ANGLE_CAPTURE(VertexP2uiv, isCallValid, context, type, value);
1191     }
1192 }
1193 
VertexP3ui(GLenum type,GLuint value)1194 void GL_APIENTRY VertexP3ui(GLenum type, GLuint value)
1195 {
1196     Context *context = GetValidGlobalContext();
1197     EVENT("glVertexP3ui", "context = %d, GLenum type = %s, GLuint value = %u", CID(context),
1198           GLenumToString(GLenumGroup::VertexPointerType, type), value);
1199 
1200     if (context)
1201     {
1202         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1203         bool isCallValid = (context->skipValidation() || ValidateVertexP3ui(context, type, value));
1204         if (isCallValid)
1205         {
1206             context->vertexP3ui(type, value);
1207         }
1208         ANGLE_CAPTURE(VertexP3ui, isCallValid, context, type, value);
1209     }
1210 }
1211 
VertexP3uiv(GLenum type,const GLuint * value)1212 void GL_APIENTRY VertexP3uiv(GLenum type, const GLuint *value)
1213 {
1214     Context *context = GetValidGlobalContext();
1215     EVENT("glVertexP3uiv",
1216           "context = %d, GLenum type = %s, const GLuint *value = 0x%016" PRIxPTR "", CID(context),
1217           GLenumToString(GLenumGroup::VertexPointerType, type), (uintptr_t)value);
1218 
1219     if (context)
1220     {
1221         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1222         bool isCallValid = (context->skipValidation() || ValidateVertexP3uiv(context, type, value));
1223         if (isCallValid)
1224         {
1225             context->vertexP3uiv(type, value);
1226         }
1227         ANGLE_CAPTURE(VertexP3uiv, isCallValid, context, type, value);
1228     }
1229 }
1230 
VertexP4ui(GLenum type,GLuint value)1231 void GL_APIENTRY VertexP4ui(GLenum type, GLuint value)
1232 {
1233     Context *context = GetValidGlobalContext();
1234     EVENT("glVertexP4ui", "context = %d, GLenum type = %s, GLuint value = %u", CID(context),
1235           GLenumToString(GLenumGroup::VertexPointerType, type), value);
1236 
1237     if (context)
1238     {
1239         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1240         bool isCallValid = (context->skipValidation() || ValidateVertexP4ui(context, type, value));
1241         if (isCallValid)
1242         {
1243             context->vertexP4ui(type, value);
1244         }
1245         ANGLE_CAPTURE(VertexP4ui, isCallValid, context, type, value);
1246     }
1247 }
1248 
VertexP4uiv(GLenum type,const GLuint * value)1249 void GL_APIENTRY VertexP4uiv(GLenum type, const GLuint *value)
1250 {
1251     Context *context = GetValidGlobalContext();
1252     EVENT("glVertexP4uiv",
1253           "context = %d, GLenum type = %s, const GLuint *value = 0x%016" PRIxPTR "", CID(context),
1254           GLenumToString(GLenumGroup::VertexPointerType, type), (uintptr_t)value);
1255 
1256     if (context)
1257     {
1258         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1259         bool isCallValid = (context->skipValidation() || ValidateVertexP4uiv(context, type, value));
1260         if (isCallValid)
1261         {
1262             context->vertexP4uiv(type, value);
1263         }
1264         ANGLE_CAPTURE(VertexP4uiv, isCallValid, context, type, value);
1265     }
1266 }
1267 }  // namespace gl
1268