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