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