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_1_0_autogen.cpp:
9 // Defines the GL 1.0 entry points.
10
11 #include "libGL/entry_points_gl_1_0_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/validationGL1_autogen.h"
25 #include "libGLESv2/global_state.h"
26
27 namespace gl
28 {
Accum(GLenum op,GLfloat value)29 void GL_APIENTRY Accum(GLenum op, GLfloat value)
30 {
31 EVENT("(GLenum op = %s, GLfloat value = %f)", GLenumToString(GLenumGroup::AccumOp, op), value);
32
33 Context *context = GetValidGlobalContext();
34 if (context)
35 {
36 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
37 bool isCallValid = (context->skipValidation() || ValidateAccum(context, op, value));
38 if (isCallValid)
39 {
40 context->accum(op, value);
41 }
42 ANGLE_CAPTURE(Accum, isCallValid, context, op, value);
43 }
44 }
45
AlphaFunc(GLenum func,GLfloat ref)46 void GL_APIENTRY AlphaFunc(GLenum func, GLfloat ref)
47 {
48 EVENT("(GLenum func = %s, GLfloat ref = %f)", GLenumToString(GLenumGroup::AlphaFunction, func),
49 ref);
50
51 Context *context = GetValidGlobalContext();
52 if (context)
53 {
54 AlphaTestFunc funcPacked = FromGL<AlphaTestFunc>(func);
55 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
56 bool isCallValid =
57 (context->skipValidation() || ValidateAlphaFunc(context, funcPacked, ref));
58 if (isCallValid)
59 {
60 context->alphaFunc(funcPacked, ref);
61 }
62 ANGLE_CAPTURE(AlphaFunc, isCallValid, context, funcPacked, ref);
63 }
64 }
65
Begin(GLenum mode)66 void GL_APIENTRY Begin(GLenum mode)
67 {
68 EVENT("(GLenum mode = %s)", GLenumToString(GLenumGroup::PrimitiveType, mode));
69
70 Context *context = GetValidGlobalContext();
71 if (context)
72 {
73 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
74 bool isCallValid = (context->skipValidation() || ValidateBegin(context, mode));
75 if (isCallValid)
76 {
77 context->begin(mode);
78 }
79 ANGLE_CAPTURE(Begin, isCallValid, context, mode);
80 }
81 }
82
Bitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte * bitmap)83 void GL_APIENTRY Bitmap(GLsizei width,
84 GLsizei height,
85 GLfloat xorig,
86 GLfloat yorig,
87 GLfloat xmove,
88 GLfloat ymove,
89 const GLubyte *bitmap)
90 {
91 EVENT(
92 "(GLsizei width = %d, GLsizei height = %d, GLfloat xorig = %f, GLfloat yorig = %f, GLfloat "
93 "xmove = %f, GLfloat ymove = %f, const GLubyte *bitmap = 0x%016" PRIxPTR ")",
94 width, height, xorig, yorig, xmove, ymove, (uintptr_t)bitmap);
95
96 Context *context = GetValidGlobalContext();
97 if (context)
98 {
99 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
100 bool isCallValid =
101 (context->skipValidation() ||
102 ValidateBitmap(context, width, height, xorig, yorig, xmove, ymove, bitmap));
103 if (isCallValid)
104 {
105 context->bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
106 }
107 ANGLE_CAPTURE(Bitmap, isCallValid, context, width, height, xorig, yorig, xmove, ymove,
108 bitmap);
109 }
110 }
111
BlendFunc(GLenum sfactor,GLenum dfactor)112 void GL_APIENTRY BlendFunc(GLenum sfactor, GLenum dfactor)
113 {
114 EVENT("(GLenum sfactor = %s, GLenum dfactor = %s)",
115 GLenumToString(GLenumGroup::BlendingFactor, sfactor),
116 GLenumToString(GLenumGroup::BlendingFactor, dfactor));
117
118 Context *context = GetValidGlobalContext();
119 if (context)
120 {
121 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
122 bool isCallValid =
123 (context->skipValidation() || ValidateBlendFunc(context, sfactor, dfactor));
124 if (isCallValid)
125 {
126 context->blendFunc(sfactor, dfactor);
127 }
128 ANGLE_CAPTURE(BlendFunc, isCallValid, context, sfactor, dfactor);
129 }
130 }
131
CallList(GLuint list)132 void GL_APIENTRY CallList(GLuint list)
133 {
134 EVENT("(GLuint list = %u)", list);
135
136 Context *context = GetValidGlobalContext();
137 if (context)
138 {
139 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
140 bool isCallValid = (context->skipValidation() || ValidateCallList(context, list));
141 if (isCallValid)
142 {
143 context->callList(list);
144 }
145 ANGLE_CAPTURE(CallList, isCallValid, context, list);
146 }
147 }
148
CallLists(GLsizei n,GLenum type,const void * lists)149 void GL_APIENTRY CallLists(GLsizei n, GLenum type, const void *lists)
150 {
151 EVENT("(GLsizei n = %d, GLenum type = %s, const void *lists = 0x%016" PRIxPTR ")", n,
152 GLenumToString(GLenumGroup::ListNameType, type), (uintptr_t)lists);
153
154 Context *context = GetValidGlobalContext();
155 if (context)
156 {
157 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
158 bool isCallValid =
159 (context->skipValidation() || ValidateCallLists(context, n, type, lists));
160 if (isCallValid)
161 {
162 context->callLists(n, type, lists);
163 }
164 ANGLE_CAPTURE(CallLists, isCallValid, context, n, type, lists);
165 }
166 }
167
Clear(GLbitfield mask)168 void GL_APIENTRY Clear(GLbitfield mask)
169 {
170 EVENT("(GLbitfield mask = %s)", GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str());
171
172 Context *context = GetValidGlobalContext();
173 if (context)
174 {
175 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
176 bool isCallValid = (context->skipValidation() || ValidateClear(context, mask));
177 if (isCallValid)
178 {
179 context->clear(mask);
180 }
181 ANGLE_CAPTURE(Clear, isCallValid, context, mask);
182 }
183 }
184
ClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)185 void GL_APIENTRY ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
186 {
187 EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
188 green, blue, alpha);
189
190 Context *context = GetValidGlobalContext();
191 if (context)
192 {
193 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
194 bool isCallValid =
195 (context->skipValidation() || ValidateClearAccum(context, red, green, blue, alpha));
196 if (isCallValid)
197 {
198 context->clearAccum(red, green, blue, alpha);
199 }
200 ANGLE_CAPTURE(ClearAccum, isCallValid, context, red, green, blue, alpha);
201 }
202 }
203
ClearColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)204 void GL_APIENTRY ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
205 {
206 EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
207 green, blue, alpha);
208
209 Context *context = GetValidGlobalContext();
210 if (context)
211 {
212 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
213 bool isCallValid =
214 (context->skipValidation() || ValidateClearColor(context, red, green, blue, alpha));
215 if (isCallValid)
216 {
217 context->clearColor(red, green, blue, alpha);
218 }
219 ANGLE_CAPTURE(ClearColor, isCallValid, context, red, green, blue, alpha);
220 }
221 }
222
ClearDepth(GLdouble depth)223 void GL_APIENTRY ClearDepth(GLdouble depth)
224 {
225 EVENT("(GLdouble depth = %f)", depth);
226
227 Context *context = GetValidGlobalContext();
228 if (context)
229 {
230 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
231 bool isCallValid = (context->skipValidation() || ValidateClearDepth(context, depth));
232 if (isCallValid)
233 {
234 context->clearDepth(depth);
235 }
236 ANGLE_CAPTURE(ClearDepth, isCallValid, context, depth);
237 }
238 }
239
ClearIndex(GLfloat c)240 void GL_APIENTRY ClearIndex(GLfloat c)
241 {
242 EVENT("(GLfloat c = %f)", c);
243
244 Context *context = GetValidGlobalContext();
245 if (context)
246 {
247 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
248 bool isCallValid = (context->skipValidation() || ValidateClearIndex(context, c));
249 if (isCallValid)
250 {
251 context->clearIndex(c);
252 }
253 ANGLE_CAPTURE(ClearIndex, isCallValid, context, c);
254 }
255 }
256
ClearStencil(GLint s)257 void GL_APIENTRY ClearStencil(GLint s)
258 {
259 EVENT("(GLint s = %d)", s);
260
261 Context *context = GetValidGlobalContext();
262 if (context)
263 {
264 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
265 bool isCallValid = (context->skipValidation() || ValidateClearStencil(context, s));
266 if (isCallValid)
267 {
268 context->clearStencil(s);
269 }
270 ANGLE_CAPTURE(ClearStencil, isCallValid, context, s);
271 }
272 }
273
ClipPlane(GLenum plane,const GLdouble * equation)274 void GL_APIENTRY ClipPlane(GLenum plane, const GLdouble *equation)
275 {
276 EVENT("(GLenum plane = %s, const GLdouble *equation = 0x%016" PRIxPTR ")",
277 GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
278
279 Context *context = GetValidGlobalContext();
280 if (context)
281 {
282 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
283 bool isCallValid =
284 (context->skipValidation() || ValidateClipPlane(context, plane, equation));
285 if (isCallValid)
286 {
287 context->clipPlane(plane, equation);
288 }
289 ANGLE_CAPTURE(ClipPlane, isCallValid, context, plane, equation);
290 }
291 }
292
Color3b(GLbyte red,GLbyte green,GLbyte blue)293 void GL_APIENTRY Color3b(GLbyte red, GLbyte green, GLbyte blue)
294 {
295 EVENT("(GLbyte red = %d, GLbyte green = %d, GLbyte blue = %d)", red, green, blue);
296
297 Context *context = GetValidGlobalContext();
298 if (context)
299 {
300 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
301 bool isCallValid =
302 (context->skipValidation() || ValidateColor3b(context, red, green, blue));
303 if (isCallValid)
304 {
305 context->color3b(red, green, blue);
306 }
307 ANGLE_CAPTURE(Color3b, isCallValid, context, red, green, blue);
308 }
309 }
310
Color3bv(const GLbyte * v)311 void GL_APIENTRY Color3bv(const GLbyte *v)
312 {
313 EVENT("(const GLbyte *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
314
315 Context *context = GetValidGlobalContext();
316 if (context)
317 {
318 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
319 bool isCallValid = (context->skipValidation() || ValidateColor3bv(context, v));
320 if (isCallValid)
321 {
322 context->color3bv(v);
323 }
324 ANGLE_CAPTURE(Color3bv, isCallValid, context, v);
325 }
326 }
327
Color3d(GLdouble red,GLdouble green,GLdouble blue)328 void GL_APIENTRY Color3d(GLdouble red, GLdouble green, GLdouble blue)
329 {
330 EVENT("(GLdouble red = %f, GLdouble green = %f, GLdouble blue = %f)", red, green, blue);
331
332 Context *context = GetValidGlobalContext();
333 if (context)
334 {
335 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
336 bool isCallValid =
337 (context->skipValidation() || ValidateColor3d(context, red, green, blue));
338 if (isCallValid)
339 {
340 context->color3d(red, green, blue);
341 }
342 ANGLE_CAPTURE(Color3d, isCallValid, context, red, green, blue);
343 }
344 }
345
Color3dv(const GLdouble * v)346 void GL_APIENTRY Color3dv(const GLdouble *v)
347 {
348 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
349
350 Context *context = GetValidGlobalContext();
351 if (context)
352 {
353 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
354 bool isCallValid = (context->skipValidation() || ValidateColor3dv(context, v));
355 if (isCallValid)
356 {
357 context->color3dv(v);
358 }
359 ANGLE_CAPTURE(Color3dv, isCallValid, context, v);
360 }
361 }
362
Color3f(GLfloat red,GLfloat green,GLfloat blue)363 void GL_APIENTRY Color3f(GLfloat red, GLfloat green, GLfloat blue)
364 {
365 EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f)", red, green, blue);
366
367 Context *context = GetValidGlobalContext();
368 if (context)
369 {
370 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
371 bool isCallValid =
372 (context->skipValidation() || ValidateColor3f(context, red, green, blue));
373 if (isCallValid)
374 {
375 context->color3f(red, green, blue);
376 }
377 ANGLE_CAPTURE(Color3f, isCallValid, context, red, green, blue);
378 }
379 }
380
Color3fv(const GLfloat * v)381 void GL_APIENTRY Color3fv(const GLfloat *v)
382 {
383 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
384
385 Context *context = GetValidGlobalContext();
386 if (context)
387 {
388 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
389 bool isCallValid = (context->skipValidation() || ValidateColor3fv(context, v));
390 if (isCallValid)
391 {
392 context->color3fv(v);
393 }
394 ANGLE_CAPTURE(Color3fv, isCallValid, context, v);
395 }
396 }
397
Color3i(GLint red,GLint green,GLint blue)398 void GL_APIENTRY Color3i(GLint red, GLint green, GLint blue)
399 {
400 EVENT("(GLint red = %d, GLint green = %d, GLint blue = %d)", red, green, blue);
401
402 Context *context = GetValidGlobalContext();
403 if (context)
404 {
405 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
406 bool isCallValid =
407 (context->skipValidation() || ValidateColor3i(context, red, green, blue));
408 if (isCallValid)
409 {
410 context->color3i(red, green, blue);
411 }
412 ANGLE_CAPTURE(Color3i, isCallValid, context, red, green, blue);
413 }
414 }
415
Color3iv(const GLint * v)416 void GL_APIENTRY Color3iv(const GLint *v)
417 {
418 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
419
420 Context *context = GetValidGlobalContext();
421 if (context)
422 {
423 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
424 bool isCallValid = (context->skipValidation() || ValidateColor3iv(context, v));
425 if (isCallValid)
426 {
427 context->color3iv(v);
428 }
429 ANGLE_CAPTURE(Color3iv, isCallValid, context, v);
430 }
431 }
432
Color3s(GLshort red,GLshort green,GLshort blue)433 void GL_APIENTRY Color3s(GLshort red, GLshort green, GLshort blue)
434 {
435 EVENT("(GLshort red = %d, GLshort green = %d, GLshort blue = %d)", red, green, blue);
436
437 Context *context = GetValidGlobalContext();
438 if (context)
439 {
440 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
441 bool isCallValid =
442 (context->skipValidation() || ValidateColor3s(context, red, green, blue));
443 if (isCallValid)
444 {
445 context->color3s(red, green, blue);
446 }
447 ANGLE_CAPTURE(Color3s, isCallValid, context, red, green, blue);
448 }
449 }
450
Color3sv(const GLshort * v)451 void GL_APIENTRY Color3sv(const GLshort *v)
452 {
453 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
454
455 Context *context = GetValidGlobalContext();
456 if (context)
457 {
458 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
459 bool isCallValid = (context->skipValidation() || ValidateColor3sv(context, v));
460 if (isCallValid)
461 {
462 context->color3sv(v);
463 }
464 ANGLE_CAPTURE(Color3sv, isCallValid, context, v);
465 }
466 }
467
Color3ub(GLubyte red,GLubyte green,GLubyte blue)468 void GL_APIENTRY Color3ub(GLubyte red, GLubyte green, GLubyte blue)
469 {
470 EVENT("(GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d)", red, green, blue);
471
472 Context *context = GetValidGlobalContext();
473 if (context)
474 {
475 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
476 bool isCallValid =
477 (context->skipValidation() || ValidateColor3ub(context, red, green, blue));
478 if (isCallValid)
479 {
480 context->color3ub(red, green, blue);
481 }
482 ANGLE_CAPTURE(Color3ub, isCallValid, context, red, green, blue);
483 }
484 }
485
Color3ubv(const GLubyte * v)486 void GL_APIENTRY Color3ubv(const GLubyte *v)
487 {
488 EVENT("(const GLubyte *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
489
490 Context *context = GetValidGlobalContext();
491 if (context)
492 {
493 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
494 bool isCallValid = (context->skipValidation() || ValidateColor3ubv(context, v));
495 if (isCallValid)
496 {
497 context->color3ubv(v);
498 }
499 ANGLE_CAPTURE(Color3ubv, isCallValid, context, v);
500 }
501 }
502
Color3ui(GLuint red,GLuint green,GLuint blue)503 void GL_APIENTRY Color3ui(GLuint red, GLuint green, GLuint blue)
504 {
505 EVENT("(GLuint red = %u, GLuint green = %u, GLuint blue = %u)", red, green, blue);
506
507 Context *context = GetValidGlobalContext();
508 if (context)
509 {
510 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
511 bool isCallValid =
512 (context->skipValidation() || ValidateColor3ui(context, red, green, blue));
513 if (isCallValid)
514 {
515 context->color3ui(red, green, blue);
516 }
517 ANGLE_CAPTURE(Color3ui, isCallValid, context, red, green, blue);
518 }
519 }
520
Color3uiv(const GLuint * v)521 void GL_APIENTRY Color3uiv(const GLuint *v)
522 {
523 EVENT("(const GLuint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
524
525 Context *context = GetValidGlobalContext();
526 if (context)
527 {
528 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
529 bool isCallValid = (context->skipValidation() || ValidateColor3uiv(context, v));
530 if (isCallValid)
531 {
532 context->color3uiv(v);
533 }
534 ANGLE_CAPTURE(Color3uiv, isCallValid, context, v);
535 }
536 }
537
Color3us(GLushort red,GLushort green,GLushort blue)538 void GL_APIENTRY Color3us(GLushort red, GLushort green, GLushort blue)
539 {
540 EVENT("(GLushort red = %u, GLushort green = %u, GLushort blue = %u)", red, green, blue);
541
542 Context *context = GetValidGlobalContext();
543 if (context)
544 {
545 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
546 bool isCallValid =
547 (context->skipValidation() || ValidateColor3us(context, red, green, blue));
548 if (isCallValid)
549 {
550 context->color3us(red, green, blue);
551 }
552 ANGLE_CAPTURE(Color3us, isCallValid, context, red, green, blue);
553 }
554 }
555
Color3usv(const GLushort * v)556 void GL_APIENTRY Color3usv(const GLushort *v)
557 {
558 EVENT("(const GLushort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
559
560 Context *context = GetValidGlobalContext();
561 if (context)
562 {
563 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
564 bool isCallValid = (context->skipValidation() || ValidateColor3usv(context, v));
565 if (isCallValid)
566 {
567 context->color3usv(v);
568 }
569 ANGLE_CAPTURE(Color3usv, isCallValid, context, v);
570 }
571 }
572
Color4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha)573 void GL_APIENTRY Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
574 {
575 EVENT("(GLbyte red = %d, GLbyte green = %d, GLbyte blue = %d, GLbyte alpha = %d)", red, green,
576 blue, alpha);
577
578 Context *context = GetValidGlobalContext();
579 if (context)
580 {
581 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
582 bool isCallValid =
583 (context->skipValidation() || ValidateColor4b(context, red, green, blue, alpha));
584 if (isCallValid)
585 {
586 context->color4b(red, green, blue, alpha);
587 }
588 ANGLE_CAPTURE(Color4b, isCallValid, context, red, green, blue, alpha);
589 }
590 }
591
Color4bv(const GLbyte * v)592 void GL_APIENTRY Color4bv(const GLbyte *v)
593 {
594 EVENT("(const GLbyte *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
595
596 Context *context = GetValidGlobalContext();
597 if (context)
598 {
599 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
600 bool isCallValid = (context->skipValidation() || ValidateColor4bv(context, v));
601 if (isCallValid)
602 {
603 context->color4bv(v);
604 }
605 ANGLE_CAPTURE(Color4bv, isCallValid, context, v);
606 }
607 }
608
Color4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha)609 void GL_APIENTRY Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
610 {
611 EVENT("(GLdouble red = %f, GLdouble green = %f, GLdouble blue = %f, GLdouble alpha = %f)", red,
612 green, blue, alpha);
613
614 Context *context = GetValidGlobalContext();
615 if (context)
616 {
617 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
618 bool isCallValid =
619 (context->skipValidation() || ValidateColor4d(context, red, green, blue, alpha));
620 if (isCallValid)
621 {
622 context->color4d(red, green, blue, alpha);
623 }
624 ANGLE_CAPTURE(Color4d, isCallValid, context, red, green, blue, alpha);
625 }
626 }
627
Color4dv(const GLdouble * v)628 void GL_APIENTRY Color4dv(const GLdouble *v)
629 {
630 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
631
632 Context *context = GetValidGlobalContext();
633 if (context)
634 {
635 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
636 bool isCallValid = (context->skipValidation() || ValidateColor4dv(context, v));
637 if (isCallValid)
638 {
639 context->color4dv(v);
640 }
641 ANGLE_CAPTURE(Color4dv, isCallValid, context, v);
642 }
643 }
644
Color4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)645 void GL_APIENTRY Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
646 {
647 EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
648 green, blue, alpha);
649
650 Context *context = GetValidGlobalContext();
651 if (context)
652 {
653 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
654 bool isCallValid =
655 (context->skipValidation() || ValidateColor4f(context, red, green, blue, alpha));
656 if (isCallValid)
657 {
658 context->color4f(red, green, blue, alpha);
659 }
660 ANGLE_CAPTURE(Color4f, isCallValid, context, red, green, blue, alpha);
661 }
662 }
663
Color4fv(const GLfloat * v)664 void GL_APIENTRY Color4fv(const GLfloat *v)
665 {
666 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
667
668 Context *context = GetValidGlobalContext();
669 if (context)
670 {
671 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
672 bool isCallValid = (context->skipValidation() || ValidateColor4fv(context, v));
673 if (isCallValid)
674 {
675 context->color4fv(v);
676 }
677 ANGLE_CAPTURE(Color4fv, isCallValid, context, v);
678 }
679 }
680
Color4i(GLint red,GLint green,GLint blue,GLint alpha)681 void GL_APIENTRY Color4i(GLint red, GLint green, GLint blue, GLint alpha)
682 {
683 EVENT("(GLint red = %d, GLint green = %d, GLint blue = %d, GLint alpha = %d)", red, green, blue,
684 alpha);
685
686 Context *context = GetValidGlobalContext();
687 if (context)
688 {
689 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
690 bool isCallValid =
691 (context->skipValidation() || ValidateColor4i(context, red, green, blue, alpha));
692 if (isCallValid)
693 {
694 context->color4i(red, green, blue, alpha);
695 }
696 ANGLE_CAPTURE(Color4i, isCallValid, context, red, green, blue, alpha);
697 }
698 }
699
Color4iv(const GLint * v)700 void GL_APIENTRY Color4iv(const GLint *v)
701 {
702 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
703
704 Context *context = GetValidGlobalContext();
705 if (context)
706 {
707 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
708 bool isCallValid = (context->skipValidation() || ValidateColor4iv(context, v));
709 if (isCallValid)
710 {
711 context->color4iv(v);
712 }
713 ANGLE_CAPTURE(Color4iv, isCallValid, context, v);
714 }
715 }
716
Color4s(GLshort red,GLshort green,GLshort blue,GLshort alpha)717 void GL_APIENTRY Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
718 {
719 EVENT("(GLshort red = %d, GLshort green = %d, GLshort blue = %d, GLshort alpha = %d)", red,
720 green, blue, alpha);
721
722 Context *context = GetValidGlobalContext();
723 if (context)
724 {
725 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
726 bool isCallValid =
727 (context->skipValidation() || ValidateColor4s(context, red, green, blue, alpha));
728 if (isCallValid)
729 {
730 context->color4s(red, green, blue, alpha);
731 }
732 ANGLE_CAPTURE(Color4s, isCallValid, context, red, green, blue, alpha);
733 }
734 }
735
Color4sv(const GLshort * v)736 void GL_APIENTRY Color4sv(const GLshort *v)
737 {
738 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
739
740 Context *context = GetValidGlobalContext();
741 if (context)
742 {
743 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
744 bool isCallValid = (context->skipValidation() || ValidateColor4sv(context, v));
745 if (isCallValid)
746 {
747 context->color4sv(v);
748 }
749 ANGLE_CAPTURE(Color4sv, isCallValid, context, v);
750 }
751 }
752
Color4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)753 void GL_APIENTRY Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
754 {
755 EVENT("(GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d, GLubyte alpha = %d)", red,
756 green, blue, alpha);
757
758 Context *context = GetValidGlobalContext();
759 if (context)
760 {
761 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
762 bool isCallValid =
763 (context->skipValidation() || ValidateColor4ub(context, red, green, blue, alpha));
764 if (isCallValid)
765 {
766 context->color4ub(red, green, blue, alpha);
767 }
768 ANGLE_CAPTURE(Color4ub, isCallValid, context, red, green, blue, alpha);
769 }
770 }
771
Color4ubv(const GLubyte * v)772 void GL_APIENTRY Color4ubv(const GLubyte *v)
773 {
774 EVENT("(const GLubyte *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
775
776 Context *context = GetValidGlobalContext();
777 if (context)
778 {
779 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
780 bool isCallValid = (context->skipValidation() || ValidateColor4ubv(context, v));
781 if (isCallValid)
782 {
783 context->color4ubv(v);
784 }
785 ANGLE_CAPTURE(Color4ubv, isCallValid, context, v);
786 }
787 }
788
Color4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha)789 void GL_APIENTRY Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
790 {
791 EVENT("(GLuint red = %u, GLuint green = %u, GLuint blue = %u, GLuint alpha = %u)", red, green,
792 blue, alpha);
793
794 Context *context = GetValidGlobalContext();
795 if (context)
796 {
797 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
798 bool isCallValid =
799 (context->skipValidation() || ValidateColor4ui(context, red, green, blue, alpha));
800 if (isCallValid)
801 {
802 context->color4ui(red, green, blue, alpha);
803 }
804 ANGLE_CAPTURE(Color4ui, isCallValid, context, red, green, blue, alpha);
805 }
806 }
807
Color4uiv(const GLuint * v)808 void GL_APIENTRY Color4uiv(const GLuint *v)
809 {
810 EVENT("(const GLuint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
811
812 Context *context = GetValidGlobalContext();
813 if (context)
814 {
815 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
816 bool isCallValid = (context->skipValidation() || ValidateColor4uiv(context, v));
817 if (isCallValid)
818 {
819 context->color4uiv(v);
820 }
821 ANGLE_CAPTURE(Color4uiv, isCallValid, context, v);
822 }
823 }
824
Color4us(GLushort red,GLushort green,GLushort blue,GLushort alpha)825 void GL_APIENTRY Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
826 {
827 EVENT("(GLushort red = %u, GLushort green = %u, GLushort blue = %u, GLushort alpha = %u)", red,
828 green, blue, alpha);
829
830 Context *context = GetValidGlobalContext();
831 if (context)
832 {
833 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
834 bool isCallValid =
835 (context->skipValidation() || ValidateColor4us(context, red, green, blue, alpha));
836 if (isCallValid)
837 {
838 context->color4us(red, green, blue, alpha);
839 }
840 ANGLE_CAPTURE(Color4us, isCallValid, context, red, green, blue, alpha);
841 }
842 }
843
Color4usv(const GLushort * v)844 void GL_APIENTRY Color4usv(const GLushort *v)
845 {
846 EVENT("(const GLushort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
847
848 Context *context = GetValidGlobalContext();
849 if (context)
850 {
851 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
852 bool isCallValid = (context->skipValidation() || ValidateColor4usv(context, v));
853 if (isCallValid)
854 {
855 context->color4usv(v);
856 }
857 ANGLE_CAPTURE(Color4usv, isCallValid, context, v);
858 }
859 }
860
ColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)861 void GL_APIENTRY ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
862 {
863 EVENT("(GLboolean red = %s, GLboolean green = %s, GLboolean blue = %s, GLboolean alpha = %s)",
864 GLbooleanToString(red), GLbooleanToString(green), GLbooleanToString(blue),
865 GLbooleanToString(alpha));
866
867 Context *context = GetValidGlobalContext();
868 if (context)
869 {
870 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
871 bool isCallValid =
872 (context->skipValidation() || ValidateColorMask(context, red, green, blue, alpha));
873 if (isCallValid)
874 {
875 context->colorMask(red, green, blue, alpha);
876 }
877 ANGLE_CAPTURE(ColorMask, isCallValid, context, red, green, blue, alpha);
878 }
879 }
880
ColorMaterial(GLenum face,GLenum mode)881 void GL_APIENTRY ColorMaterial(GLenum face, GLenum mode)
882 {
883 EVENT("(GLenum face = %s, GLenum mode = %s)", GLenumToString(GLenumGroup::MaterialFace, face),
884 GLenumToString(GLenumGroup::ColorMaterialParameter, mode));
885
886 Context *context = GetValidGlobalContext();
887 if (context)
888 {
889 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
890 bool isCallValid =
891 (context->skipValidation() || ValidateColorMaterial(context, face, mode));
892 if (isCallValid)
893 {
894 context->colorMaterial(face, mode);
895 }
896 ANGLE_CAPTURE(ColorMaterial, isCallValid, context, face, mode);
897 }
898 }
899
CopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type)900 void GL_APIENTRY CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
901 {
902 EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum type = %s)",
903 x, y, width, height, GLenumToString(GLenumGroup::PixelCopyType, type));
904
905 Context *context = GetValidGlobalContext();
906 if (context)
907 {
908 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
909 bool isCallValid =
910 (context->skipValidation() || ValidateCopyPixels(context, x, y, width, height, type));
911 if (isCallValid)
912 {
913 context->copyPixels(x, y, width, height, type);
914 }
915 ANGLE_CAPTURE(CopyPixels, isCallValid, context, x, y, width, height, type);
916 }
917 }
918
CullFace(GLenum mode)919 void GL_APIENTRY CullFace(GLenum mode)
920 {
921 EVENT("(GLenum mode = %s)", GLenumToString(GLenumGroup::CullFaceMode, mode));
922
923 Context *context = GetValidGlobalContext();
924 if (context)
925 {
926 CullFaceMode modePacked = FromGL<CullFaceMode>(mode);
927 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
928 bool isCallValid = (context->skipValidation() || ValidateCullFace(context, modePacked));
929 if (isCallValid)
930 {
931 context->cullFace(modePacked);
932 }
933 ANGLE_CAPTURE(CullFace, isCallValid, context, modePacked);
934 }
935 }
936
DeleteLists(GLuint list,GLsizei range)937 void GL_APIENTRY DeleteLists(GLuint list, GLsizei range)
938 {
939 EVENT("(GLuint list = %u, GLsizei range = %d)", list, range);
940
941 Context *context = GetValidGlobalContext();
942 if (context)
943 {
944 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
945 bool isCallValid = (context->skipValidation() || ValidateDeleteLists(context, list, range));
946 if (isCallValid)
947 {
948 context->deleteLists(list, range);
949 }
950 ANGLE_CAPTURE(DeleteLists, isCallValid, context, list, range);
951 }
952 }
953
DepthFunc(GLenum func)954 void GL_APIENTRY DepthFunc(GLenum func)
955 {
956 EVENT("(GLenum func = %s)", GLenumToString(GLenumGroup::DepthFunction, func));
957
958 Context *context = GetValidGlobalContext();
959 if (context)
960 {
961 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
962 bool isCallValid = (context->skipValidation() || ValidateDepthFunc(context, func));
963 if (isCallValid)
964 {
965 context->depthFunc(func);
966 }
967 ANGLE_CAPTURE(DepthFunc, isCallValid, context, func);
968 }
969 }
970
DepthMask(GLboolean flag)971 void GL_APIENTRY DepthMask(GLboolean flag)
972 {
973 EVENT("(GLboolean flag = %s)", GLbooleanToString(flag));
974
975 Context *context = GetValidGlobalContext();
976 if (context)
977 {
978 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
979 bool isCallValid = (context->skipValidation() || ValidateDepthMask(context, flag));
980 if (isCallValid)
981 {
982 context->depthMask(flag);
983 }
984 ANGLE_CAPTURE(DepthMask, isCallValid, context, flag);
985 }
986 }
987
DepthRange(GLdouble n,GLdouble f)988 void GL_APIENTRY DepthRange(GLdouble n, GLdouble f)
989 {
990 EVENT("(GLdouble n = %f, GLdouble f = %f)", n, f);
991
992 Context *context = GetValidGlobalContext();
993 if (context)
994 {
995 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
996 bool isCallValid = (context->skipValidation() || ValidateDepthRange(context, n, f));
997 if (isCallValid)
998 {
999 context->depthRange(n, f);
1000 }
1001 ANGLE_CAPTURE(DepthRange, isCallValid, context, n, f);
1002 }
1003 }
1004
Disable(GLenum cap)1005 void GL_APIENTRY Disable(GLenum cap)
1006 {
1007 EVENT("(GLenum cap = %s)", GLenumToString(GLenumGroup::EnableCap, cap));
1008
1009 Context *context = GetValidGlobalContext();
1010 if (context)
1011 {
1012 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1013 bool isCallValid = (context->skipValidation() || ValidateDisable(context, cap));
1014 if (isCallValid)
1015 {
1016 context->disable(cap);
1017 }
1018 ANGLE_CAPTURE(Disable, isCallValid, context, cap);
1019 }
1020 }
1021
DrawBuffer(GLenum buf)1022 void GL_APIENTRY DrawBuffer(GLenum buf)
1023 {
1024 EVENT("(GLenum buf = %s)", GLenumToString(GLenumGroup::DrawBufferMode, buf));
1025
1026 Context *context = GetValidGlobalContext();
1027 if (context)
1028 {
1029 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1030 bool isCallValid = (context->skipValidation() || ValidateDrawBuffer(context, buf));
1031 if (isCallValid)
1032 {
1033 context->drawBuffer(buf);
1034 }
1035 ANGLE_CAPTURE(DrawBuffer, isCallValid, context, buf);
1036 }
1037 }
1038
1039 void GL_APIENTRY
DrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)1040 DrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
1041 {
1042 EVENT(
1043 "(GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLenum type = %s, const "
1044 "void *pixels = 0x%016" PRIxPTR ")",
1045 width, height, GLenumToString(GLenumGroup::PixelFormat, format),
1046 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
1047
1048 Context *context = GetValidGlobalContext();
1049 if (context)
1050 {
1051 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1052 bool isCallValid = (context->skipValidation() ||
1053 ValidateDrawPixels(context, width, height, format, type, pixels));
1054 if (isCallValid)
1055 {
1056 context->drawPixels(width, height, format, type, pixels);
1057 }
1058 ANGLE_CAPTURE(DrawPixels, isCallValid, context, width, height, format, type, pixels);
1059 }
1060 }
1061
EdgeFlag(GLboolean flag)1062 void GL_APIENTRY EdgeFlag(GLboolean flag)
1063 {
1064 EVENT("(GLboolean flag = %s)", GLbooleanToString(flag));
1065
1066 Context *context = GetValidGlobalContext();
1067 if (context)
1068 {
1069 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1070 bool isCallValid = (context->skipValidation() || ValidateEdgeFlag(context, flag));
1071 if (isCallValid)
1072 {
1073 context->edgeFlag(flag);
1074 }
1075 ANGLE_CAPTURE(EdgeFlag, isCallValid, context, flag);
1076 }
1077 }
1078
EdgeFlagv(const GLboolean * flag)1079 void GL_APIENTRY EdgeFlagv(const GLboolean *flag)
1080 {
1081 EVENT("(const GLboolean *flag = 0x%016" PRIxPTR ")", (uintptr_t)flag);
1082
1083 Context *context = GetValidGlobalContext();
1084 if (context)
1085 {
1086 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1087 bool isCallValid = (context->skipValidation() || ValidateEdgeFlagv(context, flag));
1088 if (isCallValid)
1089 {
1090 context->edgeFlagv(flag);
1091 }
1092 ANGLE_CAPTURE(EdgeFlagv, isCallValid, context, flag);
1093 }
1094 }
1095
Enable(GLenum cap)1096 void GL_APIENTRY Enable(GLenum cap)
1097 {
1098 EVENT("(GLenum cap = %s)", GLenumToString(GLenumGroup::EnableCap, cap));
1099
1100 Context *context = GetValidGlobalContext();
1101 if (context)
1102 {
1103 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1104 bool isCallValid = (context->skipValidation() || ValidateEnable(context, cap));
1105 if (isCallValid)
1106 {
1107 context->enable(cap);
1108 }
1109 ANGLE_CAPTURE(Enable, isCallValid, context, cap);
1110 }
1111 }
1112
End()1113 void GL_APIENTRY End()
1114 {
1115 EVENT("()");
1116
1117 Context *context = GetValidGlobalContext();
1118 if (context)
1119 {
1120 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1121 bool isCallValid = (context->skipValidation() || ValidateEnd(context));
1122 if (isCallValid)
1123 {
1124 context->end();
1125 }
1126 ANGLE_CAPTURE(End, isCallValid, context);
1127 }
1128 }
1129
EndList()1130 void GL_APIENTRY EndList()
1131 {
1132 EVENT("()");
1133
1134 Context *context = GetValidGlobalContext();
1135 if (context)
1136 {
1137 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1138 bool isCallValid = (context->skipValidation() || ValidateEndList(context));
1139 if (isCallValid)
1140 {
1141 context->endList();
1142 }
1143 ANGLE_CAPTURE(EndList, isCallValid, context);
1144 }
1145 }
1146
EvalCoord1d(GLdouble u)1147 void GL_APIENTRY EvalCoord1d(GLdouble u)
1148 {
1149 EVENT("(GLdouble u = %f)", u);
1150
1151 Context *context = GetValidGlobalContext();
1152 if (context)
1153 {
1154 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1155 bool isCallValid = (context->skipValidation() || ValidateEvalCoord1d(context, u));
1156 if (isCallValid)
1157 {
1158 context->evalCoord1d(u);
1159 }
1160 ANGLE_CAPTURE(EvalCoord1d, isCallValid, context, u);
1161 }
1162 }
1163
EvalCoord1dv(const GLdouble * u)1164 void GL_APIENTRY EvalCoord1dv(const GLdouble *u)
1165 {
1166 EVENT("(const GLdouble *u = 0x%016" PRIxPTR ")", (uintptr_t)u);
1167
1168 Context *context = GetValidGlobalContext();
1169 if (context)
1170 {
1171 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1172 bool isCallValid = (context->skipValidation() || ValidateEvalCoord1dv(context, u));
1173 if (isCallValid)
1174 {
1175 context->evalCoord1dv(u);
1176 }
1177 ANGLE_CAPTURE(EvalCoord1dv, isCallValid, context, u);
1178 }
1179 }
1180
EvalCoord1f(GLfloat u)1181 void GL_APIENTRY EvalCoord1f(GLfloat u)
1182 {
1183 EVENT("(GLfloat u = %f)", u);
1184
1185 Context *context = GetValidGlobalContext();
1186 if (context)
1187 {
1188 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1189 bool isCallValid = (context->skipValidation() || ValidateEvalCoord1f(context, u));
1190 if (isCallValid)
1191 {
1192 context->evalCoord1f(u);
1193 }
1194 ANGLE_CAPTURE(EvalCoord1f, isCallValid, context, u);
1195 }
1196 }
1197
EvalCoord1fv(const GLfloat * u)1198 void GL_APIENTRY EvalCoord1fv(const GLfloat *u)
1199 {
1200 EVENT("(const GLfloat *u = 0x%016" PRIxPTR ")", (uintptr_t)u);
1201
1202 Context *context = GetValidGlobalContext();
1203 if (context)
1204 {
1205 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1206 bool isCallValid = (context->skipValidation() || ValidateEvalCoord1fv(context, u));
1207 if (isCallValid)
1208 {
1209 context->evalCoord1fv(u);
1210 }
1211 ANGLE_CAPTURE(EvalCoord1fv, isCallValid, context, u);
1212 }
1213 }
1214
EvalCoord2d(GLdouble u,GLdouble v)1215 void GL_APIENTRY EvalCoord2d(GLdouble u, GLdouble v)
1216 {
1217 EVENT("(GLdouble u = %f, GLdouble v = %f)", u, v);
1218
1219 Context *context = GetValidGlobalContext();
1220 if (context)
1221 {
1222 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1223 bool isCallValid = (context->skipValidation() || ValidateEvalCoord2d(context, u, v));
1224 if (isCallValid)
1225 {
1226 context->evalCoord2d(u, v);
1227 }
1228 ANGLE_CAPTURE(EvalCoord2d, isCallValid, context, u, v);
1229 }
1230 }
1231
EvalCoord2dv(const GLdouble * u)1232 void GL_APIENTRY EvalCoord2dv(const GLdouble *u)
1233 {
1234 EVENT("(const GLdouble *u = 0x%016" PRIxPTR ")", (uintptr_t)u);
1235
1236 Context *context = GetValidGlobalContext();
1237 if (context)
1238 {
1239 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1240 bool isCallValid = (context->skipValidation() || ValidateEvalCoord2dv(context, u));
1241 if (isCallValid)
1242 {
1243 context->evalCoord2dv(u);
1244 }
1245 ANGLE_CAPTURE(EvalCoord2dv, isCallValid, context, u);
1246 }
1247 }
1248
EvalCoord2f(GLfloat u,GLfloat v)1249 void GL_APIENTRY EvalCoord2f(GLfloat u, GLfloat v)
1250 {
1251 EVENT("(GLfloat u = %f, GLfloat v = %f)", u, v);
1252
1253 Context *context = GetValidGlobalContext();
1254 if (context)
1255 {
1256 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1257 bool isCallValid = (context->skipValidation() || ValidateEvalCoord2f(context, u, v));
1258 if (isCallValid)
1259 {
1260 context->evalCoord2f(u, v);
1261 }
1262 ANGLE_CAPTURE(EvalCoord2f, isCallValid, context, u, v);
1263 }
1264 }
1265
EvalCoord2fv(const GLfloat * u)1266 void GL_APIENTRY EvalCoord2fv(const GLfloat *u)
1267 {
1268 EVENT("(const GLfloat *u = 0x%016" PRIxPTR ")", (uintptr_t)u);
1269
1270 Context *context = GetValidGlobalContext();
1271 if (context)
1272 {
1273 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1274 bool isCallValid = (context->skipValidation() || ValidateEvalCoord2fv(context, u));
1275 if (isCallValid)
1276 {
1277 context->evalCoord2fv(u);
1278 }
1279 ANGLE_CAPTURE(EvalCoord2fv, isCallValid, context, u);
1280 }
1281 }
1282
EvalMesh1(GLenum mode,GLint i1,GLint i2)1283 void GL_APIENTRY EvalMesh1(GLenum mode, GLint i1, GLint i2)
1284 {
1285 EVENT("(GLenum mode = %s, GLint i1 = %d, GLint i2 = %d)",
1286 GLenumToString(GLenumGroup::MeshMode1, mode), i1, i2);
1287
1288 Context *context = GetValidGlobalContext();
1289 if (context)
1290 {
1291 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1292 bool isCallValid = (context->skipValidation() || ValidateEvalMesh1(context, mode, i1, i2));
1293 if (isCallValid)
1294 {
1295 context->evalMesh1(mode, i1, i2);
1296 }
1297 ANGLE_CAPTURE(EvalMesh1, isCallValid, context, mode, i1, i2);
1298 }
1299 }
1300
EvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2)1301 void GL_APIENTRY EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1302 {
1303 EVENT("(GLenum mode = %s, GLint i1 = %d, GLint i2 = %d, GLint j1 = %d, GLint j2 = %d)",
1304 GLenumToString(GLenumGroup::MeshMode2, mode), i1, i2, j1, j2);
1305
1306 Context *context = GetValidGlobalContext();
1307 if (context)
1308 {
1309 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1310 bool isCallValid =
1311 (context->skipValidation() || ValidateEvalMesh2(context, mode, i1, i2, j1, j2));
1312 if (isCallValid)
1313 {
1314 context->evalMesh2(mode, i1, i2, j1, j2);
1315 }
1316 ANGLE_CAPTURE(EvalMesh2, isCallValid, context, mode, i1, i2, j1, j2);
1317 }
1318 }
1319
EvalPoint1(GLint i)1320 void GL_APIENTRY EvalPoint1(GLint i)
1321 {
1322 EVENT("(GLint i = %d)", i);
1323
1324 Context *context = GetValidGlobalContext();
1325 if (context)
1326 {
1327 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1328 bool isCallValid = (context->skipValidation() || ValidateEvalPoint1(context, i));
1329 if (isCallValid)
1330 {
1331 context->evalPoint1(i);
1332 }
1333 ANGLE_CAPTURE(EvalPoint1, isCallValid, context, i);
1334 }
1335 }
1336
EvalPoint2(GLint i,GLint j)1337 void GL_APIENTRY EvalPoint2(GLint i, GLint j)
1338 {
1339 EVENT("(GLint i = %d, GLint j = %d)", i, j);
1340
1341 Context *context = GetValidGlobalContext();
1342 if (context)
1343 {
1344 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1345 bool isCallValid = (context->skipValidation() || ValidateEvalPoint2(context, i, j));
1346 if (isCallValid)
1347 {
1348 context->evalPoint2(i, j);
1349 }
1350 ANGLE_CAPTURE(EvalPoint2, isCallValid, context, i, j);
1351 }
1352 }
1353
FeedbackBuffer(GLsizei size,GLenum type,GLfloat * buffer)1354 void GL_APIENTRY FeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
1355 {
1356 EVENT("(GLsizei size = %d, GLenum type = %s, GLfloat *buffer = 0x%016" PRIxPTR ")", size,
1357 GLenumToString(GLenumGroup::FeedbackType, type), (uintptr_t)buffer);
1358
1359 Context *context = GetValidGlobalContext();
1360 if (context)
1361 {
1362 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1363 bool isCallValid =
1364 (context->skipValidation() || ValidateFeedbackBuffer(context, size, type, buffer));
1365 if (isCallValid)
1366 {
1367 context->feedbackBuffer(size, type, buffer);
1368 }
1369 ANGLE_CAPTURE(FeedbackBuffer, isCallValid, context, size, type, buffer);
1370 }
1371 }
1372
Finish()1373 void GL_APIENTRY Finish()
1374 {
1375 EVENT("()");
1376
1377 Context *context = GetValidGlobalContext();
1378 if (context)
1379 {
1380 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1381 bool isCallValid = (context->skipValidation() || ValidateFinish(context));
1382 if (isCallValid)
1383 {
1384 context->finish();
1385 }
1386 ANGLE_CAPTURE(Finish, isCallValid, context);
1387 }
1388 }
1389
Flush()1390 void GL_APIENTRY Flush()
1391 {
1392 EVENT("()");
1393
1394 Context *context = GetValidGlobalContext();
1395 if (context)
1396 {
1397 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1398 bool isCallValid = (context->skipValidation() || ValidateFlush(context));
1399 if (isCallValid)
1400 {
1401 context->flush();
1402 }
1403 ANGLE_CAPTURE(Flush, isCallValid, context);
1404 }
1405 }
1406
Fogf(GLenum pname,GLfloat param)1407 void GL_APIENTRY Fogf(GLenum pname, GLfloat param)
1408 {
1409 EVENT("(GLenum pname = %s, GLfloat param = %f)",
1410 GLenumToString(GLenumGroup::FogParameter, pname), param);
1411
1412 Context *context = GetValidGlobalContext();
1413 if (context)
1414 {
1415 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1416 bool isCallValid = (context->skipValidation() || ValidateFogf(context, pname, param));
1417 if (isCallValid)
1418 {
1419 context->fogf(pname, param);
1420 }
1421 ANGLE_CAPTURE(Fogf, isCallValid, context, pname, param);
1422 }
1423 }
1424
Fogfv(GLenum pname,const GLfloat * params)1425 void GL_APIENTRY Fogfv(GLenum pname, const GLfloat *params)
1426 {
1427 EVENT("(GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
1428 GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params);
1429
1430 Context *context = GetValidGlobalContext();
1431 if (context)
1432 {
1433 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1434 bool isCallValid = (context->skipValidation() || ValidateFogfv(context, pname, params));
1435 if (isCallValid)
1436 {
1437 context->fogfv(pname, params);
1438 }
1439 ANGLE_CAPTURE(Fogfv, isCallValid, context, pname, params);
1440 }
1441 }
1442
Fogi(GLenum pname,GLint param)1443 void GL_APIENTRY Fogi(GLenum pname, GLint param)
1444 {
1445 EVENT("(GLenum pname = %s, GLint param = %d)", GLenumToString(GLenumGroup::FogParameter, pname),
1446 param);
1447
1448 Context *context = GetValidGlobalContext();
1449 if (context)
1450 {
1451 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1452 bool isCallValid = (context->skipValidation() || ValidateFogi(context, pname, param));
1453 if (isCallValid)
1454 {
1455 context->fogi(pname, param);
1456 }
1457 ANGLE_CAPTURE(Fogi, isCallValid, context, pname, param);
1458 }
1459 }
1460
Fogiv(GLenum pname,const GLint * params)1461 void GL_APIENTRY Fogiv(GLenum pname, const GLint *params)
1462 {
1463 EVENT("(GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
1464 GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params);
1465
1466 Context *context = GetValidGlobalContext();
1467 if (context)
1468 {
1469 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1470 bool isCallValid = (context->skipValidation() || ValidateFogiv(context, pname, params));
1471 if (isCallValid)
1472 {
1473 context->fogiv(pname, params);
1474 }
1475 ANGLE_CAPTURE(Fogiv, isCallValid, context, pname, params);
1476 }
1477 }
1478
FrontFace(GLenum mode)1479 void GL_APIENTRY FrontFace(GLenum mode)
1480 {
1481 EVENT("(GLenum mode = %s)", GLenumToString(GLenumGroup::FrontFaceDirection, mode));
1482
1483 Context *context = GetValidGlobalContext();
1484 if (context)
1485 {
1486 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1487 bool isCallValid = (context->skipValidation() || ValidateFrontFace(context, mode));
1488 if (isCallValid)
1489 {
1490 context->frontFace(mode);
1491 }
1492 ANGLE_CAPTURE(FrontFace, isCallValid, context, mode);
1493 }
1494 }
1495
1496 void GL_APIENTRY
Frustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)1497 Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
1498 {
1499 EVENT(
1500 "(GLdouble left = %f, GLdouble right = %f, GLdouble bottom = %f, GLdouble top = %f, "
1501 "GLdouble zNear = %f, GLdouble zFar = %f)",
1502 left, right, bottom, top, zNear, zFar);
1503
1504 Context *context = GetValidGlobalContext();
1505 if (context)
1506 {
1507 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1508 bool isCallValid = (context->skipValidation() ||
1509 ValidateFrustum(context, left, right, bottom, top, zNear, zFar));
1510 if (isCallValid)
1511 {
1512 context->frustum(left, right, bottom, top, zNear, zFar);
1513 }
1514 ANGLE_CAPTURE(Frustum, isCallValid, context, left, right, bottom, top, zNear, zFar);
1515 }
1516 }
1517
GenLists(GLsizei range)1518 GLuint GL_APIENTRY GenLists(GLsizei range)
1519 {
1520 EVENT("(GLsizei range = %d)", range);
1521
1522 Context *context = GetValidGlobalContext();
1523 GLuint returnValue;
1524 if (context)
1525 {
1526 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1527 bool isCallValid = (context->skipValidation() || ValidateGenLists(context, range));
1528 if (isCallValid)
1529 {
1530 returnValue = context->genLists(range);
1531 }
1532 else
1533 {
1534 returnValue = GetDefaultReturnValue<EntryPoint::GenLists, GLuint>();
1535 }
1536 ANGLE_CAPTURE(GenLists, isCallValid, context, range, returnValue);
1537 }
1538 else
1539 {
1540 returnValue = GetDefaultReturnValue<EntryPoint::GenLists, GLuint>();
1541 }
1542 return returnValue;
1543 }
1544
GetBooleanv(GLenum pname,GLboolean * data)1545 void GL_APIENTRY GetBooleanv(GLenum pname, GLboolean *data)
1546 {
1547 EVENT("(GLenum pname = %s, GLboolean *data = 0x%016" PRIxPTR ")",
1548 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
1549
1550 Context *context = GetValidGlobalContext();
1551 if (context)
1552 {
1553 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1554 bool isCallValid = (context->skipValidation() || ValidateGetBooleanv(context, pname, data));
1555 if (isCallValid)
1556 {
1557 context->getBooleanv(pname, data);
1558 }
1559 ANGLE_CAPTURE(GetBooleanv, isCallValid, context, pname, data);
1560 }
1561 }
1562
GetClipPlane(GLenum plane,GLdouble * equation)1563 void GL_APIENTRY GetClipPlane(GLenum plane, GLdouble *equation)
1564 {
1565 EVENT("(GLenum plane = %s, GLdouble *equation = 0x%016" PRIxPTR ")",
1566 GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
1567
1568 Context *context = GetValidGlobalContext();
1569 if (context)
1570 {
1571 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1572 bool isCallValid =
1573 (context->skipValidation() || ValidateGetClipPlane(context, plane, equation));
1574 if (isCallValid)
1575 {
1576 context->getClipPlane(plane, equation);
1577 }
1578 ANGLE_CAPTURE(GetClipPlane, isCallValid, context, plane, equation);
1579 }
1580 }
1581
GetDoublev(GLenum pname,GLdouble * data)1582 void GL_APIENTRY GetDoublev(GLenum pname, GLdouble *data)
1583 {
1584 EVENT("(GLenum pname = %s, GLdouble *data = 0x%016" PRIxPTR ")",
1585 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
1586
1587 Context *context = GetValidGlobalContext();
1588 if (context)
1589 {
1590 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1591 bool isCallValid = (context->skipValidation() || ValidateGetDoublev(context, pname, data));
1592 if (isCallValid)
1593 {
1594 context->getDoublev(pname, data);
1595 }
1596 ANGLE_CAPTURE(GetDoublev, isCallValid, context, pname, data);
1597 }
1598 }
1599
GetError()1600 GLenum GL_APIENTRY GetError()
1601 {
1602 EVENT("()");
1603
1604 Context *context = GetGlobalContext();
1605 GLenum returnValue;
1606 if (context)
1607 {
1608 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1609 bool isCallValid = (context->skipValidation() || ValidateGetError(context));
1610 if (isCallValid)
1611 {
1612 returnValue = context->getError();
1613 }
1614 else
1615 {
1616 returnValue = GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
1617 }
1618 ANGLE_CAPTURE(GetError, isCallValid, context, returnValue);
1619 }
1620 else
1621 {
1622 returnValue = GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
1623 }
1624 return returnValue;
1625 }
1626
GetFloatv(GLenum pname,GLfloat * data)1627 void GL_APIENTRY GetFloatv(GLenum pname, GLfloat *data)
1628 {
1629 EVENT("(GLenum pname = %s, GLfloat *data = 0x%016" PRIxPTR ")",
1630 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
1631
1632 Context *context = GetValidGlobalContext();
1633 if (context)
1634 {
1635 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1636 bool isCallValid = (context->skipValidation() || ValidateGetFloatv(context, pname, data));
1637 if (isCallValid)
1638 {
1639 context->getFloatv(pname, data);
1640 }
1641 ANGLE_CAPTURE(GetFloatv, isCallValid, context, pname, data);
1642 }
1643 }
1644
GetIntegerv(GLenum pname,GLint * data)1645 void GL_APIENTRY GetIntegerv(GLenum pname, GLint *data)
1646 {
1647 EVENT("(GLenum pname = %s, GLint *data = 0x%016" PRIxPTR ")",
1648 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
1649
1650 Context *context = GetValidGlobalContext();
1651 if (context)
1652 {
1653 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1654 bool isCallValid = (context->skipValidation() || ValidateGetIntegerv(context, pname, data));
1655 if (isCallValid)
1656 {
1657 context->getIntegerv(pname, data);
1658 }
1659 ANGLE_CAPTURE(GetIntegerv, isCallValid, context, pname, data);
1660 }
1661 }
1662
GetLightfv(GLenum light,GLenum pname,GLfloat * params)1663 void GL_APIENTRY GetLightfv(GLenum light, GLenum pname, GLfloat *params)
1664 {
1665 EVENT("(GLenum light = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR ")",
1666 GLenumToString(GLenumGroup::LightName, light),
1667 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
1668
1669 Context *context = GetValidGlobalContext();
1670 if (context)
1671 {
1672 LightParameter pnamePacked = FromGL<LightParameter>(pname);
1673 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1674 bool isCallValid =
1675 (context->skipValidation() || ValidateGetLightfv(context, light, pnamePacked, params));
1676 if (isCallValid)
1677 {
1678 context->getLightfv(light, pnamePacked, params);
1679 }
1680 ANGLE_CAPTURE(GetLightfv, isCallValid, context, light, pnamePacked, params);
1681 }
1682 }
1683
GetLightiv(GLenum light,GLenum pname,GLint * params)1684 void GL_APIENTRY GetLightiv(GLenum light, GLenum pname, GLint *params)
1685 {
1686 EVENT("(GLenum light = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR ")",
1687 GLenumToString(GLenumGroup::LightName, light),
1688 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
1689
1690 Context *context = GetValidGlobalContext();
1691 if (context)
1692 {
1693 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1694 bool isCallValid =
1695 (context->skipValidation() || ValidateGetLightiv(context, light, pname, params));
1696 if (isCallValid)
1697 {
1698 context->getLightiv(light, pname, params);
1699 }
1700 ANGLE_CAPTURE(GetLightiv, isCallValid, context, light, pname, params);
1701 }
1702 }
1703
GetMapdv(GLenum target,GLenum query,GLdouble * v)1704 void GL_APIENTRY GetMapdv(GLenum target, GLenum query, GLdouble *v)
1705 {
1706 EVENT("(GLenum target = %s, GLenum query = %s, GLdouble *v = 0x%016" PRIxPTR ")",
1707 GLenumToString(GLenumGroup::MapTarget, target),
1708 GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v);
1709
1710 Context *context = GetValidGlobalContext();
1711 if (context)
1712 {
1713 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1714 bool isCallValid =
1715 (context->skipValidation() || ValidateGetMapdv(context, target, query, v));
1716 if (isCallValid)
1717 {
1718 context->getMapdv(target, query, v);
1719 }
1720 ANGLE_CAPTURE(GetMapdv, isCallValid, context, target, query, v);
1721 }
1722 }
1723
GetMapfv(GLenum target,GLenum query,GLfloat * v)1724 void GL_APIENTRY GetMapfv(GLenum target, GLenum query, GLfloat *v)
1725 {
1726 EVENT("(GLenum target = %s, GLenum query = %s, GLfloat *v = 0x%016" PRIxPTR ")",
1727 GLenumToString(GLenumGroup::MapTarget, target),
1728 GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v);
1729
1730 Context *context = GetValidGlobalContext();
1731 if (context)
1732 {
1733 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1734 bool isCallValid =
1735 (context->skipValidation() || ValidateGetMapfv(context, target, query, v));
1736 if (isCallValid)
1737 {
1738 context->getMapfv(target, query, v);
1739 }
1740 ANGLE_CAPTURE(GetMapfv, isCallValid, context, target, query, v);
1741 }
1742 }
1743
GetMapiv(GLenum target,GLenum query,GLint * v)1744 void GL_APIENTRY GetMapiv(GLenum target, GLenum query, GLint *v)
1745 {
1746 EVENT("(GLenum target = %s, GLenum query = %s, GLint *v = 0x%016" PRIxPTR ")",
1747 GLenumToString(GLenumGroup::MapTarget, target),
1748 GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v);
1749
1750 Context *context = GetValidGlobalContext();
1751 if (context)
1752 {
1753 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1754 bool isCallValid =
1755 (context->skipValidation() || ValidateGetMapiv(context, target, query, v));
1756 if (isCallValid)
1757 {
1758 context->getMapiv(target, query, v);
1759 }
1760 ANGLE_CAPTURE(GetMapiv, isCallValid, context, target, query, v);
1761 }
1762 }
1763
GetMaterialfv(GLenum face,GLenum pname,GLfloat * params)1764 void GL_APIENTRY GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
1765 {
1766 EVENT("(GLenum face = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR ")",
1767 GLenumToString(GLenumGroup::MaterialFace, face),
1768 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
1769
1770 Context *context = GetValidGlobalContext();
1771 if (context)
1772 {
1773 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
1774 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1775 bool isCallValid = (context->skipValidation() ||
1776 ValidateGetMaterialfv(context, face, pnamePacked, params));
1777 if (isCallValid)
1778 {
1779 context->getMaterialfv(face, pnamePacked, params);
1780 }
1781 ANGLE_CAPTURE(GetMaterialfv, isCallValid, context, face, pnamePacked, params);
1782 }
1783 }
1784
GetMaterialiv(GLenum face,GLenum pname,GLint * params)1785 void GL_APIENTRY GetMaterialiv(GLenum face, GLenum pname, GLint *params)
1786 {
1787 EVENT("(GLenum face = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR ")",
1788 GLenumToString(GLenumGroup::MaterialFace, face),
1789 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
1790
1791 Context *context = GetValidGlobalContext();
1792 if (context)
1793 {
1794 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1795 bool isCallValid =
1796 (context->skipValidation() || ValidateGetMaterialiv(context, face, pname, params));
1797 if (isCallValid)
1798 {
1799 context->getMaterialiv(face, pname, params);
1800 }
1801 ANGLE_CAPTURE(GetMaterialiv, isCallValid, context, face, pname, params);
1802 }
1803 }
1804
GetPixelMapfv(GLenum map,GLfloat * values)1805 void GL_APIENTRY GetPixelMapfv(GLenum map, GLfloat *values)
1806 {
1807 EVENT("(GLenum map = %s, GLfloat *values = 0x%016" PRIxPTR ")",
1808 GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values);
1809
1810 Context *context = GetValidGlobalContext();
1811 if (context)
1812 {
1813 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1814 bool isCallValid =
1815 (context->skipValidation() || ValidateGetPixelMapfv(context, map, values));
1816 if (isCallValid)
1817 {
1818 context->getPixelMapfv(map, values);
1819 }
1820 ANGLE_CAPTURE(GetPixelMapfv, isCallValid, context, map, values);
1821 }
1822 }
1823
GetPixelMapuiv(GLenum map,GLuint * values)1824 void GL_APIENTRY GetPixelMapuiv(GLenum map, GLuint *values)
1825 {
1826 EVENT("(GLenum map = %s, GLuint *values = 0x%016" PRIxPTR ")",
1827 GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values);
1828
1829 Context *context = GetValidGlobalContext();
1830 if (context)
1831 {
1832 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1833 bool isCallValid =
1834 (context->skipValidation() || ValidateGetPixelMapuiv(context, map, values));
1835 if (isCallValid)
1836 {
1837 context->getPixelMapuiv(map, values);
1838 }
1839 ANGLE_CAPTURE(GetPixelMapuiv, isCallValid, context, map, values);
1840 }
1841 }
1842
GetPixelMapusv(GLenum map,GLushort * values)1843 void GL_APIENTRY GetPixelMapusv(GLenum map, GLushort *values)
1844 {
1845 EVENT("(GLenum map = %s, GLushort *values = 0x%016" PRIxPTR ")",
1846 GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values);
1847
1848 Context *context = GetValidGlobalContext();
1849 if (context)
1850 {
1851 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1852 bool isCallValid =
1853 (context->skipValidation() || ValidateGetPixelMapusv(context, map, values));
1854 if (isCallValid)
1855 {
1856 context->getPixelMapusv(map, values);
1857 }
1858 ANGLE_CAPTURE(GetPixelMapusv, isCallValid, context, map, values);
1859 }
1860 }
1861
GetPolygonStipple(GLubyte * mask)1862 void GL_APIENTRY GetPolygonStipple(GLubyte *mask)
1863 {
1864 EVENT("(GLubyte *mask = 0x%016" PRIxPTR ")", (uintptr_t)mask);
1865
1866 Context *context = GetValidGlobalContext();
1867 if (context)
1868 {
1869 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1870 bool isCallValid = (context->skipValidation() || ValidateGetPolygonStipple(context, mask));
1871 if (isCallValid)
1872 {
1873 context->getPolygonStipple(mask);
1874 }
1875 ANGLE_CAPTURE(GetPolygonStipple, isCallValid, context, mask);
1876 }
1877 }
1878
GetString(GLenum name)1879 const GLubyte *GL_APIENTRY GetString(GLenum name)
1880 {
1881 EVENT("(GLenum name = %s)", GLenumToString(GLenumGroup::StringName, name));
1882
1883 Context *context = GetValidGlobalContext();
1884 const GLubyte *returnValue;
1885 if (context)
1886 {
1887 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1888 bool isCallValid = (context->skipValidation() || ValidateGetString(context, name));
1889 if (isCallValid)
1890 {
1891 returnValue = context->getString(name);
1892 }
1893 else
1894 {
1895 returnValue = GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
1896 }
1897 ANGLE_CAPTURE(GetString, isCallValid, context, name, returnValue);
1898 }
1899 else
1900 {
1901 returnValue = GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
1902 }
1903 return returnValue;
1904 }
1905
GetTexEnvfv(GLenum target,GLenum pname,GLfloat * params)1906 void GL_APIENTRY GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
1907 {
1908 EVENT("(GLenum target = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR ")",
1909 GLenumToString(GLenumGroup::TextureEnvTarget, target),
1910 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
1911
1912 Context *context = GetValidGlobalContext();
1913 if (context)
1914 {
1915 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
1916 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
1917 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1918 bool isCallValid = (context->skipValidation() ||
1919 ValidateGetTexEnvfv(context, targetPacked, pnamePacked, params));
1920 if (isCallValid)
1921 {
1922 context->getTexEnvfv(targetPacked, pnamePacked, params);
1923 }
1924 ANGLE_CAPTURE(GetTexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
1925 }
1926 }
1927
GetTexEnviv(GLenum target,GLenum pname,GLint * params)1928 void GL_APIENTRY GetTexEnviv(GLenum target, GLenum pname, GLint *params)
1929 {
1930 EVENT("(GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR ")",
1931 GLenumToString(GLenumGroup::TextureEnvTarget, target),
1932 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
1933
1934 Context *context = GetValidGlobalContext();
1935 if (context)
1936 {
1937 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
1938 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
1939 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1940 bool isCallValid = (context->skipValidation() ||
1941 ValidateGetTexEnviv(context, targetPacked, pnamePacked, params));
1942 if (isCallValid)
1943 {
1944 context->getTexEnviv(targetPacked, pnamePacked, params);
1945 }
1946 ANGLE_CAPTURE(GetTexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
1947 }
1948 }
1949
GetTexGendv(GLenum coord,GLenum pname,GLdouble * params)1950 void GL_APIENTRY GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
1951 {
1952 EVENT("(GLenum coord = %s, GLenum pname = %s, GLdouble *params = 0x%016" PRIxPTR ")",
1953 GLenumToString(GLenumGroup::TextureCoordName, coord),
1954 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
1955
1956 Context *context = GetValidGlobalContext();
1957 if (context)
1958 {
1959 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1960 bool isCallValid =
1961 (context->skipValidation() || ValidateGetTexGendv(context, coord, pname, params));
1962 if (isCallValid)
1963 {
1964 context->getTexGendv(coord, pname, params);
1965 }
1966 ANGLE_CAPTURE(GetTexGendv, isCallValid, context, coord, pname, params);
1967 }
1968 }
1969
GetTexGenfv(GLenum coord,GLenum pname,GLfloat * params)1970 void GL_APIENTRY GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
1971 {
1972 EVENT("(GLenum coord = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR ")",
1973 GLenumToString(GLenumGroup::TextureCoordName, coord),
1974 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
1975
1976 Context *context = GetValidGlobalContext();
1977 if (context)
1978 {
1979 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1980 bool isCallValid =
1981 (context->skipValidation() || ValidateGetTexGenfv(context, coord, pname, params));
1982 if (isCallValid)
1983 {
1984 context->getTexGenfv(coord, pname, params);
1985 }
1986 ANGLE_CAPTURE(GetTexGenfv, isCallValid, context, coord, pname, params);
1987 }
1988 }
1989
GetTexGeniv(GLenum coord,GLenum pname,GLint * params)1990 void GL_APIENTRY GetTexGeniv(GLenum coord, GLenum pname, GLint *params)
1991 {
1992 EVENT("(GLenum coord = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR ")",
1993 GLenumToString(GLenumGroup::TextureCoordName, coord),
1994 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
1995
1996 Context *context = GetValidGlobalContext();
1997 if (context)
1998 {
1999 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2000 bool isCallValid =
2001 (context->skipValidation() || ValidateGetTexGeniv(context, coord, pname, params));
2002 if (isCallValid)
2003 {
2004 context->getTexGeniv(coord, pname, params);
2005 }
2006 ANGLE_CAPTURE(GetTexGeniv, isCallValid, context, coord, pname, params);
2007 }
2008 }
2009
GetTexImage(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)2010 void GL_APIENTRY GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
2011 {
2012 EVENT(
2013 "(GLenum target = %s, GLint level = %d, GLenum format = %s, GLenum type = %s, void *pixels "
2014 "= 0x%016" PRIxPTR ")",
2015 GLenumToString(GLenumGroup::TextureTarget, target), level,
2016 GLenumToString(GLenumGroup::PixelFormat, format),
2017 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
2018
2019 Context *context = GetValidGlobalContext();
2020 if (context)
2021 {
2022 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2023 bool isCallValid = (context->skipValidation() ||
2024 ValidateGetTexImage(context, target, level, format, type, pixels));
2025 if (isCallValid)
2026 {
2027 context->getTexImage(target, level, format, type, pixels);
2028 }
2029 ANGLE_CAPTURE(GetTexImage, isCallValid, context, target, level, format, type, pixels);
2030 }
2031 }
2032
GetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat * params)2033 void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
2034 {
2035 EVENT(
2036 "(GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
2037 ")",
2038 GLenumToString(GLenumGroup::TextureTarget, target), level,
2039 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
2040
2041 Context *context = GetValidGlobalContext();
2042 if (context)
2043 {
2044 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2045 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2046 bool isCallValid =
2047 (context->skipValidation() ||
2048 ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params));
2049 if (isCallValid)
2050 {
2051 context->getTexLevelParameterfv(targetPacked, level, pname, params);
2052 }
2053 ANGLE_CAPTURE(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname,
2054 params);
2055 }
2056 }
2057
GetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint * params)2058 void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
2059 {
2060 EVENT("(GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
2061 ")",
2062 GLenumToString(GLenumGroup::TextureTarget, target), level,
2063 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
2064
2065 Context *context = GetValidGlobalContext();
2066 if (context)
2067 {
2068 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2069 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2070 bool isCallValid =
2071 (context->skipValidation() ||
2072 ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params));
2073 if (isCallValid)
2074 {
2075 context->getTexLevelParameteriv(targetPacked, level, pname, params);
2076 }
2077 ANGLE_CAPTURE(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname,
2078 params);
2079 }
2080 }
2081
GetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)2082 void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
2083 {
2084 EVENT("(GLenum target = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR ")",
2085 GLenumToString(GLenumGroup::TextureTarget, target),
2086 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
2087
2088 Context *context = GetValidGlobalContext();
2089 if (context)
2090 {
2091 TextureType targetPacked = FromGL<TextureType>(target);
2092 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2093 bool isCallValid = (context->skipValidation() ||
2094 ValidateGetTexParameterfv(context, targetPacked, pname, params));
2095 if (isCallValid)
2096 {
2097 context->getTexParameterfv(targetPacked, pname, params);
2098 }
2099 ANGLE_CAPTURE(GetTexParameterfv, isCallValid, context, targetPacked, pname, params);
2100 }
2101 }
2102
GetTexParameteriv(GLenum target,GLenum pname,GLint * params)2103 void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
2104 {
2105 EVENT("(GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR ")",
2106 GLenumToString(GLenumGroup::TextureTarget, target),
2107 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
2108
2109 Context *context = GetValidGlobalContext();
2110 if (context)
2111 {
2112 TextureType targetPacked = FromGL<TextureType>(target);
2113 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2114 bool isCallValid = (context->skipValidation() ||
2115 ValidateGetTexParameteriv(context, targetPacked, pname, params));
2116 if (isCallValid)
2117 {
2118 context->getTexParameteriv(targetPacked, pname, params);
2119 }
2120 ANGLE_CAPTURE(GetTexParameteriv, isCallValid, context, targetPacked, pname, params);
2121 }
2122 }
2123
Hint(GLenum target,GLenum mode)2124 void GL_APIENTRY Hint(GLenum target, GLenum mode)
2125 {
2126 EVENT("(GLenum target = %s, GLenum mode = %s)", GLenumToString(GLenumGroup::HintTarget, target),
2127 GLenumToString(GLenumGroup::HintMode, mode));
2128
2129 Context *context = GetValidGlobalContext();
2130 if (context)
2131 {
2132 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2133 bool isCallValid = (context->skipValidation() || ValidateHint(context, target, mode));
2134 if (isCallValid)
2135 {
2136 context->hint(target, mode);
2137 }
2138 ANGLE_CAPTURE(Hint, isCallValid, context, target, mode);
2139 }
2140 }
2141
IndexMask(GLuint mask)2142 void GL_APIENTRY IndexMask(GLuint mask)
2143 {
2144 EVENT("(GLuint mask = %u)", mask);
2145
2146 Context *context = GetValidGlobalContext();
2147 if (context)
2148 {
2149 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2150 bool isCallValid = (context->skipValidation() || ValidateIndexMask(context, mask));
2151 if (isCallValid)
2152 {
2153 context->indexMask(mask);
2154 }
2155 ANGLE_CAPTURE(IndexMask, isCallValid, context, mask);
2156 }
2157 }
2158
Indexd(GLdouble c)2159 void GL_APIENTRY Indexd(GLdouble c)
2160 {
2161 EVENT("(GLdouble c = %f)", c);
2162
2163 Context *context = GetValidGlobalContext();
2164 if (context)
2165 {
2166 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2167 bool isCallValid = (context->skipValidation() || ValidateIndexd(context, c));
2168 if (isCallValid)
2169 {
2170 context->indexd(c);
2171 }
2172 ANGLE_CAPTURE(Indexd, isCallValid, context, c);
2173 }
2174 }
2175
Indexdv(const GLdouble * c)2176 void GL_APIENTRY Indexdv(const GLdouble *c)
2177 {
2178 EVENT("(const GLdouble *c = 0x%016" PRIxPTR ")", (uintptr_t)c);
2179
2180 Context *context = GetValidGlobalContext();
2181 if (context)
2182 {
2183 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2184 bool isCallValid = (context->skipValidation() || ValidateIndexdv(context, c));
2185 if (isCallValid)
2186 {
2187 context->indexdv(c);
2188 }
2189 ANGLE_CAPTURE(Indexdv, isCallValid, context, c);
2190 }
2191 }
2192
Indexf(GLfloat c)2193 void GL_APIENTRY Indexf(GLfloat c)
2194 {
2195 EVENT("(GLfloat c = %f)", c);
2196
2197 Context *context = GetValidGlobalContext();
2198 if (context)
2199 {
2200 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2201 bool isCallValid = (context->skipValidation() || ValidateIndexf(context, c));
2202 if (isCallValid)
2203 {
2204 context->indexf(c);
2205 }
2206 ANGLE_CAPTURE(Indexf, isCallValid, context, c);
2207 }
2208 }
2209
Indexfv(const GLfloat * c)2210 void GL_APIENTRY Indexfv(const GLfloat *c)
2211 {
2212 EVENT("(const GLfloat *c = 0x%016" PRIxPTR ")", (uintptr_t)c);
2213
2214 Context *context = GetValidGlobalContext();
2215 if (context)
2216 {
2217 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2218 bool isCallValid = (context->skipValidation() || ValidateIndexfv(context, c));
2219 if (isCallValid)
2220 {
2221 context->indexfv(c);
2222 }
2223 ANGLE_CAPTURE(Indexfv, isCallValid, context, c);
2224 }
2225 }
2226
Indexi(GLint c)2227 void GL_APIENTRY Indexi(GLint c)
2228 {
2229 EVENT("(GLint c = %d)", c);
2230
2231 Context *context = GetValidGlobalContext();
2232 if (context)
2233 {
2234 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2235 bool isCallValid = (context->skipValidation() || ValidateIndexi(context, c));
2236 if (isCallValid)
2237 {
2238 context->indexi(c);
2239 }
2240 ANGLE_CAPTURE(Indexi, isCallValid, context, c);
2241 }
2242 }
2243
Indexiv(const GLint * c)2244 void GL_APIENTRY Indexiv(const GLint *c)
2245 {
2246 EVENT("(const GLint *c = 0x%016" PRIxPTR ")", (uintptr_t)c);
2247
2248 Context *context = GetValidGlobalContext();
2249 if (context)
2250 {
2251 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2252 bool isCallValid = (context->skipValidation() || ValidateIndexiv(context, c));
2253 if (isCallValid)
2254 {
2255 context->indexiv(c);
2256 }
2257 ANGLE_CAPTURE(Indexiv, isCallValid, context, c);
2258 }
2259 }
2260
Indexs(GLshort c)2261 void GL_APIENTRY Indexs(GLshort c)
2262 {
2263 EVENT("(GLshort c = %d)", c);
2264
2265 Context *context = GetValidGlobalContext();
2266 if (context)
2267 {
2268 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2269 bool isCallValid = (context->skipValidation() || ValidateIndexs(context, c));
2270 if (isCallValid)
2271 {
2272 context->indexs(c);
2273 }
2274 ANGLE_CAPTURE(Indexs, isCallValid, context, c);
2275 }
2276 }
2277
Indexsv(const GLshort * c)2278 void GL_APIENTRY Indexsv(const GLshort *c)
2279 {
2280 EVENT("(const GLshort *c = 0x%016" PRIxPTR ")", (uintptr_t)c);
2281
2282 Context *context = GetValidGlobalContext();
2283 if (context)
2284 {
2285 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2286 bool isCallValid = (context->skipValidation() || ValidateIndexsv(context, c));
2287 if (isCallValid)
2288 {
2289 context->indexsv(c);
2290 }
2291 ANGLE_CAPTURE(Indexsv, isCallValid, context, c);
2292 }
2293 }
2294
InitNames()2295 void GL_APIENTRY InitNames()
2296 {
2297 EVENT("()");
2298
2299 Context *context = GetValidGlobalContext();
2300 if (context)
2301 {
2302 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2303 bool isCallValid = (context->skipValidation() || ValidateInitNames(context));
2304 if (isCallValid)
2305 {
2306 context->initNames();
2307 }
2308 ANGLE_CAPTURE(InitNames, isCallValid, context);
2309 }
2310 }
2311
IsEnabled(GLenum cap)2312 GLboolean GL_APIENTRY IsEnabled(GLenum cap)
2313 {
2314 EVENT("(GLenum cap = %s)", GLenumToString(GLenumGroup::EnableCap, cap));
2315
2316 Context *context = GetValidGlobalContext();
2317 GLboolean returnValue;
2318 if (context)
2319 {
2320 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2321 bool isCallValid = (context->skipValidation() || ValidateIsEnabled(context, cap));
2322 if (isCallValid)
2323 {
2324 returnValue = context->isEnabled(cap);
2325 }
2326 else
2327 {
2328 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
2329 }
2330 ANGLE_CAPTURE(IsEnabled, isCallValid, context, cap, returnValue);
2331 }
2332 else
2333 {
2334 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
2335 }
2336 return returnValue;
2337 }
2338
IsList(GLuint list)2339 GLboolean GL_APIENTRY IsList(GLuint list)
2340 {
2341 EVENT("(GLuint list = %u)", list);
2342
2343 Context *context = GetValidGlobalContext();
2344 GLboolean returnValue;
2345 if (context)
2346 {
2347 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2348 bool isCallValid = (context->skipValidation() || ValidateIsList(context, list));
2349 if (isCallValid)
2350 {
2351 returnValue = context->isList(list);
2352 }
2353 else
2354 {
2355 returnValue = GetDefaultReturnValue<EntryPoint::IsList, GLboolean>();
2356 }
2357 ANGLE_CAPTURE(IsList, isCallValid, context, list, returnValue);
2358 }
2359 else
2360 {
2361 returnValue = GetDefaultReturnValue<EntryPoint::IsList, GLboolean>();
2362 }
2363 return returnValue;
2364 }
2365
LightModelf(GLenum pname,GLfloat param)2366 void GL_APIENTRY LightModelf(GLenum pname, GLfloat param)
2367 {
2368 EVENT("(GLenum pname = %s, GLfloat param = %f)",
2369 GLenumToString(GLenumGroup::LightModelParameter, pname), param);
2370
2371 Context *context = GetValidGlobalContext();
2372 if (context)
2373 {
2374 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2375 bool isCallValid =
2376 (context->skipValidation() || ValidateLightModelf(context, pname, param));
2377 if (isCallValid)
2378 {
2379 context->lightModelf(pname, param);
2380 }
2381 ANGLE_CAPTURE(LightModelf, isCallValid, context, pname, param);
2382 }
2383 }
2384
LightModelfv(GLenum pname,const GLfloat * params)2385 void GL_APIENTRY LightModelfv(GLenum pname, const GLfloat *params)
2386 {
2387 EVENT("(GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
2388 GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)params);
2389
2390 Context *context = GetValidGlobalContext();
2391 if (context)
2392 {
2393 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2394 bool isCallValid =
2395 (context->skipValidation() || ValidateLightModelfv(context, pname, params));
2396 if (isCallValid)
2397 {
2398 context->lightModelfv(pname, params);
2399 }
2400 ANGLE_CAPTURE(LightModelfv, isCallValid, context, pname, params);
2401 }
2402 }
2403
LightModeli(GLenum pname,GLint param)2404 void GL_APIENTRY LightModeli(GLenum pname, GLint param)
2405 {
2406 EVENT("(GLenum pname = %s, GLint param = %d)",
2407 GLenumToString(GLenumGroup::LightModelParameter, pname), param);
2408
2409 Context *context = GetValidGlobalContext();
2410 if (context)
2411 {
2412 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2413 bool isCallValid =
2414 (context->skipValidation() || ValidateLightModeli(context, pname, param));
2415 if (isCallValid)
2416 {
2417 context->lightModeli(pname, param);
2418 }
2419 ANGLE_CAPTURE(LightModeli, isCallValid, context, pname, param);
2420 }
2421 }
2422
LightModeliv(GLenum pname,const GLint * params)2423 void GL_APIENTRY LightModeliv(GLenum pname, const GLint *params)
2424 {
2425 EVENT("(GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
2426 GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)params);
2427
2428 Context *context = GetValidGlobalContext();
2429 if (context)
2430 {
2431 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2432 bool isCallValid =
2433 (context->skipValidation() || ValidateLightModeliv(context, pname, params));
2434 if (isCallValid)
2435 {
2436 context->lightModeliv(pname, params);
2437 }
2438 ANGLE_CAPTURE(LightModeliv, isCallValid, context, pname, params);
2439 }
2440 }
2441
Lightf(GLenum light,GLenum pname,GLfloat param)2442 void GL_APIENTRY Lightf(GLenum light, GLenum pname, GLfloat param)
2443 {
2444 EVENT("(GLenum light = %s, GLenum pname = %s, GLfloat param = %f)",
2445 GLenumToString(GLenumGroup::LightName, light),
2446 GLenumToString(GLenumGroup::LightParameter, pname), param);
2447
2448 Context *context = GetValidGlobalContext();
2449 if (context)
2450 {
2451 LightParameter pnamePacked = FromGL<LightParameter>(pname);
2452 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2453 bool isCallValid =
2454 (context->skipValidation() || ValidateLightf(context, light, pnamePacked, param));
2455 if (isCallValid)
2456 {
2457 context->lightf(light, pnamePacked, param);
2458 }
2459 ANGLE_CAPTURE(Lightf, isCallValid, context, light, pnamePacked, param);
2460 }
2461 }
2462
Lightfv(GLenum light,GLenum pname,const GLfloat * params)2463 void GL_APIENTRY Lightfv(GLenum light, GLenum pname, const GLfloat *params)
2464 {
2465 EVENT("(GLenum light = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
2466 GLenumToString(GLenumGroup::LightName, light),
2467 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
2468
2469 Context *context = GetValidGlobalContext();
2470 if (context)
2471 {
2472 LightParameter pnamePacked = FromGL<LightParameter>(pname);
2473 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2474 bool isCallValid =
2475 (context->skipValidation() || ValidateLightfv(context, light, pnamePacked, params));
2476 if (isCallValid)
2477 {
2478 context->lightfv(light, pnamePacked, params);
2479 }
2480 ANGLE_CAPTURE(Lightfv, isCallValid, context, light, pnamePacked, params);
2481 }
2482 }
2483
Lighti(GLenum light,GLenum pname,GLint param)2484 void GL_APIENTRY Lighti(GLenum light, GLenum pname, GLint param)
2485 {
2486 EVENT("(GLenum light = %s, GLenum pname = %s, GLint param = %d)",
2487 GLenumToString(GLenumGroup::LightName, light),
2488 GLenumToString(GLenumGroup::LightParameter, pname), param);
2489
2490 Context *context = GetValidGlobalContext();
2491 if (context)
2492 {
2493 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2494 bool isCallValid =
2495 (context->skipValidation() || ValidateLighti(context, light, pname, param));
2496 if (isCallValid)
2497 {
2498 context->lighti(light, pname, param);
2499 }
2500 ANGLE_CAPTURE(Lighti, isCallValid, context, light, pname, param);
2501 }
2502 }
2503
Lightiv(GLenum light,GLenum pname,const GLint * params)2504 void GL_APIENTRY Lightiv(GLenum light, GLenum pname, const GLint *params)
2505 {
2506 EVENT("(GLenum light = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
2507 GLenumToString(GLenumGroup::LightName, light),
2508 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
2509
2510 Context *context = GetValidGlobalContext();
2511 if (context)
2512 {
2513 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2514 bool isCallValid =
2515 (context->skipValidation() || ValidateLightiv(context, light, pname, params));
2516 if (isCallValid)
2517 {
2518 context->lightiv(light, pname, params);
2519 }
2520 ANGLE_CAPTURE(Lightiv, isCallValid, context, light, pname, params);
2521 }
2522 }
2523
LineStipple(GLint factor,GLushort pattern)2524 void GL_APIENTRY LineStipple(GLint factor, GLushort pattern)
2525 {
2526 EVENT("(GLint factor = %d, GLushort pattern = %u)", factor, pattern);
2527
2528 Context *context = GetValidGlobalContext();
2529 if (context)
2530 {
2531 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2532 bool isCallValid =
2533 (context->skipValidation() || ValidateLineStipple(context, factor, pattern));
2534 if (isCallValid)
2535 {
2536 context->lineStipple(factor, pattern);
2537 }
2538 ANGLE_CAPTURE(LineStipple, isCallValid, context, factor, pattern);
2539 }
2540 }
2541
LineWidth(GLfloat width)2542 void GL_APIENTRY LineWidth(GLfloat width)
2543 {
2544 EVENT("(GLfloat width = %f)", width);
2545
2546 Context *context = GetValidGlobalContext();
2547 if (context)
2548 {
2549 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2550 bool isCallValid = (context->skipValidation() || ValidateLineWidth(context, width));
2551 if (isCallValid)
2552 {
2553 context->lineWidth(width);
2554 }
2555 ANGLE_CAPTURE(LineWidth, isCallValid, context, width);
2556 }
2557 }
2558
ListBase(GLuint base)2559 void GL_APIENTRY ListBase(GLuint base)
2560 {
2561 EVENT("(GLuint base = %u)", base);
2562
2563 Context *context = GetValidGlobalContext();
2564 if (context)
2565 {
2566 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2567 bool isCallValid = (context->skipValidation() || ValidateListBase(context, base));
2568 if (isCallValid)
2569 {
2570 context->listBase(base);
2571 }
2572 ANGLE_CAPTURE(ListBase, isCallValid, context, base);
2573 }
2574 }
2575
LoadIdentity()2576 void GL_APIENTRY LoadIdentity()
2577 {
2578 EVENT("()");
2579
2580 Context *context = GetValidGlobalContext();
2581 if (context)
2582 {
2583 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2584 bool isCallValid = (context->skipValidation() || ValidateLoadIdentity(context));
2585 if (isCallValid)
2586 {
2587 context->loadIdentity();
2588 }
2589 ANGLE_CAPTURE(LoadIdentity, isCallValid, context);
2590 }
2591 }
2592
LoadMatrixd(const GLdouble * m)2593 void GL_APIENTRY LoadMatrixd(const GLdouble *m)
2594 {
2595 EVENT("(const GLdouble *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
2596
2597 Context *context = GetValidGlobalContext();
2598 if (context)
2599 {
2600 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2601 bool isCallValid = (context->skipValidation() || ValidateLoadMatrixd(context, m));
2602 if (isCallValid)
2603 {
2604 context->loadMatrixd(m);
2605 }
2606 ANGLE_CAPTURE(LoadMatrixd, isCallValid, context, m);
2607 }
2608 }
2609
LoadMatrixf(const GLfloat * m)2610 void GL_APIENTRY LoadMatrixf(const GLfloat *m)
2611 {
2612 EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
2613
2614 Context *context = GetValidGlobalContext();
2615 if (context)
2616 {
2617 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2618 bool isCallValid = (context->skipValidation() || ValidateLoadMatrixf(context, m));
2619 if (isCallValid)
2620 {
2621 context->loadMatrixf(m);
2622 }
2623 ANGLE_CAPTURE(LoadMatrixf, isCallValid, context, m);
2624 }
2625 }
2626
LoadName(GLuint name)2627 void GL_APIENTRY LoadName(GLuint name)
2628 {
2629 EVENT("(GLuint name = %u)", name);
2630
2631 Context *context = GetValidGlobalContext();
2632 if (context)
2633 {
2634 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2635 bool isCallValid = (context->skipValidation() || ValidateLoadName(context, name));
2636 if (isCallValid)
2637 {
2638 context->loadName(name);
2639 }
2640 ANGLE_CAPTURE(LoadName, isCallValid, context, name);
2641 }
2642 }
2643
LogicOp(GLenum opcode)2644 void GL_APIENTRY LogicOp(GLenum opcode)
2645 {
2646 EVENT("(GLenum opcode = %s)", GLenumToString(GLenumGroup::LogicOp, opcode));
2647
2648 Context *context = GetValidGlobalContext();
2649 if (context)
2650 {
2651 LogicalOperation opcodePacked = FromGL<LogicalOperation>(opcode);
2652 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2653 bool isCallValid = (context->skipValidation() || ValidateLogicOp(context, opcodePacked));
2654 if (isCallValid)
2655 {
2656 context->logicOp(opcodePacked);
2657 }
2658 ANGLE_CAPTURE(LogicOp, isCallValid, context, opcodePacked);
2659 }
2660 }
2661
2662 void GL_APIENTRY
Map1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble * points)2663 Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
2664 {
2665 EVENT(
2666 "(GLenum target = %s, GLdouble u1 = %f, GLdouble u2 = %f, GLint stride = %d, GLint order = "
2667 "%d, const GLdouble *points = 0x%016" PRIxPTR ")",
2668 GLenumToString(GLenumGroup::MapTarget, target), u1, u2, stride, order, (uintptr_t)points);
2669
2670 Context *context = GetValidGlobalContext();
2671 if (context)
2672 {
2673 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2674 bool isCallValid = (context->skipValidation() ||
2675 ValidateMap1d(context, target, u1, u2, stride, order, points));
2676 if (isCallValid)
2677 {
2678 context->map1d(target, u1, u2, stride, order, points);
2679 }
2680 ANGLE_CAPTURE(Map1d, isCallValid, context, target, u1, u2, stride, order, points);
2681 }
2682 }
2683
2684 void GL_APIENTRY
Map1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat * points)2685 Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
2686 {
2687 EVENT(
2688 "(GLenum target = %s, GLfloat u1 = %f, GLfloat u2 = %f, GLint stride = %d, GLint order = "
2689 "%d, const GLfloat *points = 0x%016" PRIxPTR ")",
2690 GLenumToString(GLenumGroup::MapTarget, target), u1, u2, stride, order, (uintptr_t)points);
2691
2692 Context *context = GetValidGlobalContext();
2693 if (context)
2694 {
2695 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2696 bool isCallValid = (context->skipValidation() ||
2697 ValidateMap1f(context, target, u1, u2, stride, order, points));
2698 if (isCallValid)
2699 {
2700 context->map1f(target, u1, u2, stride, order, points);
2701 }
2702 ANGLE_CAPTURE(Map1f, isCallValid, context, target, u1, u2, stride, order, points);
2703 }
2704 }
2705
Map2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble * points)2706 void GL_APIENTRY Map2d(GLenum target,
2707 GLdouble u1,
2708 GLdouble u2,
2709 GLint ustride,
2710 GLint uorder,
2711 GLdouble v1,
2712 GLdouble v2,
2713 GLint vstride,
2714 GLint vorder,
2715 const GLdouble *points)
2716 {
2717 EVENT(
2718 "(GLenum target = %s, GLdouble u1 = %f, GLdouble u2 = %f, GLint ustride = %d, GLint uorder "
2719 "= %d, GLdouble v1 = %f, GLdouble v2 = %f, GLint vstride = %d, GLint vorder = %d, const "
2720 "GLdouble *points = 0x%016" PRIxPTR ")",
2721 GLenumToString(GLenumGroup::MapTarget, target), u1, u2, ustride, uorder, v1, v2, vstride,
2722 vorder, (uintptr_t)points);
2723
2724 Context *context = GetValidGlobalContext();
2725 if (context)
2726 {
2727 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2728 bool isCallValid =
2729 (context->skipValidation() || ValidateMap2d(context, target, u1, u2, ustride, uorder,
2730 v1, v2, vstride, vorder, points));
2731 if (isCallValid)
2732 {
2733 context->map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
2734 }
2735 ANGLE_CAPTURE(Map2d, isCallValid, context, target, u1, u2, ustride, uorder, v1, v2, vstride,
2736 vorder, points);
2737 }
2738 }
2739
Map2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat * points)2740 void GL_APIENTRY Map2f(GLenum target,
2741 GLfloat u1,
2742 GLfloat u2,
2743 GLint ustride,
2744 GLint uorder,
2745 GLfloat v1,
2746 GLfloat v2,
2747 GLint vstride,
2748 GLint vorder,
2749 const GLfloat *points)
2750 {
2751 EVENT(
2752 "(GLenum target = %s, GLfloat u1 = %f, GLfloat u2 = %f, GLint ustride = %d, GLint uorder = "
2753 "%d, GLfloat v1 = %f, GLfloat v2 = %f, GLint vstride = %d, GLint vorder = %d, const "
2754 "GLfloat *points = 0x%016" PRIxPTR ")",
2755 GLenumToString(GLenumGroup::MapTarget, target), u1, u2, ustride, uorder, v1, v2, vstride,
2756 vorder, (uintptr_t)points);
2757
2758 Context *context = GetValidGlobalContext();
2759 if (context)
2760 {
2761 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2762 bool isCallValid =
2763 (context->skipValidation() || ValidateMap2f(context, target, u1, u2, ustride, uorder,
2764 v1, v2, vstride, vorder, points));
2765 if (isCallValid)
2766 {
2767 context->map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
2768 }
2769 ANGLE_CAPTURE(Map2f, isCallValid, context, target, u1, u2, ustride, uorder, v1, v2, vstride,
2770 vorder, points);
2771 }
2772 }
2773
MapGrid1d(GLint un,GLdouble u1,GLdouble u2)2774 void GL_APIENTRY MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2775 {
2776 EVENT("(GLint un = %d, GLdouble u1 = %f, GLdouble u2 = %f)", un, u1, u2);
2777
2778 Context *context = GetValidGlobalContext();
2779 if (context)
2780 {
2781 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2782 bool isCallValid = (context->skipValidation() || ValidateMapGrid1d(context, un, u1, u2));
2783 if (isCallValid)
2784 {
2785 context->mapGrid1d(un, u1, u2);
2786 }
2787 ANGLE_CAPTURE(MapGrid1d, isCallValid, context, un, u1, u2);
2788 }
2789 }
2790
MapGrid1f(GLint un,GLfloat u1,GLfloat u2)2791 void GL_APIENTRY MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2792 {
2793 EVENT("(GLint un = %d, GLfloat u1 = %f, GLfloat u2 = %f)", un, u1, u2);
2794
2795 Context *context = GetValidGlobalContext();
2796 if (context)
2797 {
2798 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2799 bool isCallValid = (context->skipValidation() || ValidateMapGrid1f(context, un, u1, u2));
2800 if (isCallValid)
2801 {
2802 context->mapGrid1f(un, u1, u2);
2803 }
2804 ANGLE_CAPTURE(MapGrid1f, isCallValid, context, un, u1, u2);
2805 }
2806 }
2807
MapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2)2808 void GL_APIENTRY MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
2809 {
2810 EVENT(
2811 "(GLint un = %d, GLdouble u1 = %f, GLdouble u2 = %f, GLint vn = %d, GLdouble v1 = %f, "
2812 "GLdouble v2 = %f)",
2813 un, u1, u2, vn, v1, v2);
2814
2815 Context *context = GetValidGlobalContext();
2816 if (context)
2817 {
2818 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2819 bool isCallValid =
2820 (context->skipValidation() || ValidateMapGrid2d(context, un, u1, u2, vn, v1, v2));
2821 if (isCallValid)
2822 {
2823 context->mapGrid2d(un, u1, u2, vn, v1, v2);
2824 }
2825 ANGLE_CAPTURE(MapGrid2d, isCallValid, context, un, u1, u2, vn, v1, v2);
2826 }
2827 }
2828
MapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2)2829 void GL_APIENTRY MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
2830 {
2831 EVENT(
2832 "(GLint un = %d, GLfloat u1 = %f, GLfloat u2 = %f, GLint vn = %d, GLfloat v1 = %f, GLfloat "
2833 "v2 = %f)",
2834 un, u1, u2, vn, v1, v2);
2835
2836 Context *context = GetValidGlobalContext();
2837 if (context)
2838 {
2839 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2840 bool isCallValid =
2841 (context->skipValidation() || ValidateMapGrid2f(context, un, u1, u2, vn, v1, v2));
2842 if (isCallValid)
2843 {
2844 context->mapGrid2f(un, u1, u2, vn, v1, v2);
2845 }
2846 ANGLE_CAPTURE(MapGrid2f, isCallValid, context, un, u1, u2, vn, v1, v2);
2847 }
2848 }
2849
Materialf(GLenum face,GLenum pname,GLfloat param)2850 void GL_APIENTRY Materialf(GLenum face, GLenum pname, GLfloat param)
2851 {
2852 EVENT("(GLenum face = %s, GLenum pname = %s, GLfloat param = %f)",
2853 GLenumToString(GLenumGroup::MaterialFace, face),
2854 GLenumToString(GLenumGroup::MaterialParameter, pname), param);
2855
2856 Context *context = GetValidGlobalContext();
2857 if (context)
2858 {
2859 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
2860 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2861 bool isCallValid =
2862 (context->skipValidation() || ValidateMaterialf(context, face, pnamePacked, param));
2863 if (isCallValid)
2864 {
2865 context->materialf(face, pnamePacked, param);
2866 }
2867 ANGLE_CAPTURE(Materialf, isCallValid, context, face, pnamePacked, param);
2868 }
2869 }
2870
Materialfv(GLenum face,GLenum pname,const GLfloat * params)2871 void GL_APIENTRY Materialfv(GLenum face, GLenum pname, const GLfloat *params)
2872 {
2873 EVENT("(GLenum face = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
2874 GLenumToString(GLenumGroup::MaterialFace, face),
2875 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
2876
2877 Context *context = GetValidGlobalContext();
2878 if (context)
2879 {
2880 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
2881 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2882 bool isCallValid =
2883 (context->skipValidation() || ValidateMaterialfv(context, face, pnamePacked, params));
2884 if (isCallValid)
2885 {
2886 context->materialfv(face, pnamePacked, params);
2887 }
2888 ANGLE_CAPTURE(Materialfv, isCallValid, context, face, pnamePacked, params);
2889 }
2890 }
2891
Materiali(GLenum face,GLenum pname,GLint param)2892 void GL_APIENTRY Materiali(GLenum face, GLenum pname, GLint param)
2893 {
2894 EVENT("(GLenum face = %s, GLenum pname = %s, GLint param = %d)",
2895 GLenumToString(GLenumGroup::MaterialFace, face),
2896 GLenumToString(GLenumGroup::MaterialParameter, pname), param);
2897
2898 Context *context = GetValidGlobalContext();
2899 if (context)
2900 {
2901 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2902 bool isCallValid =
2903 (context->skipValidation() || ValidateMateriali(context, face, pname, param));
2904 if (isCallValid)
2905 {
2906 context->materiali(face, pname, param);
2907 }
2908 ANGLE_CAPTURE(Materiali, isCallValid, context, face, pname, param);
2909 }
2910 }
2911
Materialiv(GLenum face,GLenum pname,const GLint * params)2912 void GL_APIENTRY Materialiv(GLenum face, GLenum pname, const GLint *params)
2913 {
2914 EVENT("(GLenum face = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
2915 GLenumToString(GLenumGroup::MaterialFace, face),
2916 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
2917
2918 Context *context = GetValidGlobalContext();
2919 if (context)
2920 {
2921 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2922 bool isCallValid =
2923 (context->skipValidation() || ValidateMaterialiv(context, face, pname, params));
2924 if (isCallValid)
2925 {
2926 context->materialiv(face, pname, params);
2927 }
2928 ANGLE_CAPTURE(Materialiv, isCallValid, context, face, pname, params);
2929 }
2930 }
2931
MatrixMode(GLenum mode)2932 void GL_APIENTRY MatrixMode(GLenum mode)
2933 {
2934 EVENT("(GLenum mode = %s)", GLenumToString(GLenumGroup::MatrixMode, mode));
2935
2936 Context *context = GetValidGlobalContext();
2937 if (context)
2938 {
2939 MatrixType modePacked = FromGL<MatrixType>(mode);
2940 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2941 bool isCallValid = (context->skipValidation() || ValidateMatrixMode(context, modePacked));
2942 if (isCallValid)
2943 {
2944 context->matrixMode(modePacked);
2945 }
2946 ANGLE_CAPTURE(MatrixMode, isCallValid, context, modePacked);
2947 }
2948 }
2949
MultMatrixd(const GLdouble * m)2950 void GL_APIENTRY MultMatrixd(const GLdouble *m)
2951 {
2952 EVENT("(const GLdouble *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
2953
2954 Context *context = GetValidGlobalContext();
2955 if (context)
2956 {
2957 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2958 bool isCallValid = (context->skipValidation() || ValidateMultMatrixd(context, m));
2959 if (isCallValid)
2960 {
2961 context->multMatrixd(m);
2962 }
2963 ANGLE_CAPTURE(MultMatrixd, isCallValid, context, m);
2964 }
2965 }
2966
MultMatrixf(const GLfloat * m)2967 void GL_APIENTRY MultMatrixf(const GLfloat *m)
2968 {
2969 EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
2970
2971 Context *context = GetValidGlobalContext();
2972 if (context)
2973 {
2974 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2975 bool isCallValid = (context->skipValidation() || ValidateMultMatrixf(context, m));
2976 if (isCallValid)
2977 {
2978 context->multMatrixf(m);
2979 }
2980 ANGLE_CAPTURE(MultMatrixf, isCallValid, context, m);
2981 }
2982 }
2983
NewList(GLuint list,GLenum mode)2984 void GL_APIENTRY NewList(GLuint list, GLenum mode)
2985 {
2986 EVENT("(GLuint list = %u, GLenum mode = %s)", list,
2987 GLenumToString(GLenumGroup::ListMode, mode));
2988
2989 Context *context = GetValidGlobalContext();
2990 if (context)
2991 {
2992 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
2993 bool isCallValid = (context->skipValidation() || ValidateNewList(context, list, mode));
2994 if (isCallValid)
2995 {
2996 context->newList(list, mode);
2997 }
2998 ANGLE_CAPTURE(NewList, isCallValid, context, list, mode);
2999 }
3000 }
3001
Normal3b(GLbyte nx,GLbyte ny,GLbyte nz)3002 void GL_APIENTRY Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
3003 {
3004 EVENT("(GLbyte nx = %d, GLbyte ny = %d, GLbyte nz = %d)", nx, ny, nz);
3005
3006 Context *context = GetValidGlobalContext();
3007 if (context)
3008 {
3009 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3010 bool isCallValid = (context->skipValidation() || ValidateNormal3b(context, nx, ny, nz));
3011 if (isCallValid)
3012 {
3013 context->normal3b(nx, ny, nz);
3014 }
3015 ANGLE_CAPTURE(Normal3b, isCallValid, context, nx, ny, nz);
3016 }
3017 }
3018
Normal3bv(const GLbyte * v)3019 void GL_APIENTRY Normal3bv(const GLbyte *v)
3020 {
3021 EVENT("(const GLbyte *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3022
3023 Context *context = GetValidGlobalContext();
3024 if (context)
3025 {
3026 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3027 bool isCallValid = (context->skipValidation() || ValidateNormal3bv(context, v));
3028 if (isCallValid)
3029 {
3030 context->normal3bv(v);
3031 }
3032 ANGLE_CAPTURE(Normal3bv, isCallValid, context, v);
3033 }
3034 }
3035
Normal3d(GLdouble nx,GLdouble ny,GLdouble nz)3036 void GL_APIENTRY Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
3037 {
3038 EVENT("(GLdouble nx = %f, GLdouble ny = %f, GLdouble nz = %f)", nx, ny, nz);
3039
3040 Context *context = GetValidGlobalContext();
3041 if (context)
3042 {
3043 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3044 bool isCallValid = (context->skipValidation() || ValidateNormal3d(context, nx, ny, nz));
3045 if (isCallValid)
3046 {
3047 context->normal3d(nx, ny, nz);
3048 }
3049 ANGLE_CAPTURE(Normal3d, isCallValid, context, nx, ny, nz);
3050 }
3051 }
3052
Normal3dv(const GLdouble * v)3053 void GL_APIENTRY Normal3dv(const GLdouble *v)
3054 {
3055 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3056
3057 Context *context = GetValidGlobalContext();
3058 if (context)
3059 {
3060 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3061 bool isCallValid = (context->skipValidation() || ValidateNormal3dv(context, v));
3062 if (isCallValid)
3063 {
3064 context->normal3dv(v);
3065 }
3066 ANGLE_CAPTURE(Normal3dv, isCallValid, context, v);
3067 }
3068 }
3069
Normal3f(GLfloat nx,GLfloat ny,GLfloat nz)3070 void GL_APIENTRY Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
3071 {
3072 EVENT("(GLfloat nx = %f, GLfloat ny = %f, GLfloat nz = %f)", nx, ny, nz);
3073
3074 Context *context = GetValidGlobalContext();
3075 if (context)
3076 {
3077 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3078 bool isCallValid = (context->skipValidation() || ValidateNormal3f(context, nx, ny, nz));
3079 if (isCallValid)
3080 {
3081 context->normal3f(nx, ny, nz);
3082 }
3083 ANGLE_CAPTURE(Normal3f, isCallValid, context, nx, ny, nz);
3084 }
3085 }
3086
Normal3fv(const GLfloat * v)3087 void GL_APIENTRY Normal3fv(const GLfloat *v)
3088 {
3089 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3090
3091 Context *context = GetValidGlobalContext();
3092 if (context)
3093 {
3094 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3095 bool isCallValid = (context->skipValidation() || ValidateNormal3fv(context, v));
3096 if (isCallValid)
3097 {
3098 context->normal3fv(v);
3099 }
3100 ANGLE_CAPTURE(Normal3fv, isCallValid, context, v);
3101 }
3102 }
3103
Normal3i(GLint nx,GLint ny,GLint nz)3104 void GL_APIENTRY Normal3i(GLint nx, GLint ny, GLint nz)
3105 {
3106 EVENT("(GLint nx = %d, GLint ny = %d, GLint nz = %d)", nx, ny, nz);
3107
3108 Context *context = GetValidGlobalContext();
3109 if (context)
3110 {
3111 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3112 bool isCallValid = (context->skipValidation() || ValidateNormal3i(context, nx, ny, nz));
3113 if (isCallValid)
3114 {
3115 context->normal3i(nx, ny, nz);
3116 }
3117 ANGLE_CAPTURE(Normal3i, isCallValid, context, nx, ny, nz);
3118 }
3119 }
3120
Normal3iv(const GLint * v)3121 void GL_APIENTRY Normal3iv(const GLint *v)
3122 {
3123 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3124
3125 Context *context = GetValidGlobalContext();
3126 if (context)
3127 {
3128 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3129 bool isCallValid = (context->skipValidation() || ValidateNormal3iv(context, v));
3130 if (isCallValid)
3131 {
3132 context->normal3iv(v);
3133 }
3134 ANGLE_CAPTURE(Normal3iv, isCallValid, context, v);
3135 }
3136 }
3137
Normal3s(GLshort nx,GLshort ny,GLshort nz)3138 void GL_APIENTRY Normal3s(GLshort nx, GLshort ny, GLshort nz)
3139 {
3140 EVENT("(GLshort nx = %d, GLshort ny = %d, GLshort nz = %d)", nx, ny, nz);
3141
3142 Context *context = GetValidGlobalContext();
3143 if (context)
3144 {
3145 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3146 bool isCallValid = (context->skipValidation() || ValidateNormal3s(context, nx, ny, nz));
3147 if (isCallValid)
3148 {
3149 context->normal3s(nx, ny, nz);
3150 }
3151 ANGLE_CAPTURE(Normal3s, isCallValid, context, nx, ny, nz);
3152 }
3153 }
3154
Normal3sv(const GLshort * v)3155 void GL_APIENTRY Normal3sv(const GLshort *v)
3156 {
3157 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3158
3159 Context *context = GetValidGlobalContext();
3160 if (context)
3161 {
3162 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3163 bool isCallValid = (context->skipValidation() || ValidateNormal3sv(context, v));
3164 if (isCallValid)
3165 {
3166 context->normal3sv(v);
3167 }
3168 ANGLE_CAPTURE(Normal3sv, isCallValid, context, v);
3169 }
3170 }
3171
3172 void GL_APIENTRY
Ortho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)3173 Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3174 {
3175 EVENT(
3176 "(GLdouble left = %f, GLdouble right = %f, GLdouble bottom = %f, GLdouble top = %f, "
3177 "GLdouble zNear = %f, GLdouble zFar = %f)",
3178 left, right, bottom, top, zNear, zFar);
3179
3180 Context *context = GetValidGlobalContext();
3181 if (context)
3182 {
3183 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3184 bool isCallValid = (context->skipValidation() ||
3185 ValidateOrtho(context, left, right, bottom, top, zNear, zFar));
3186 if (isCallValid)
3187 {
3188 context->ortho(left, right, bottom, top, zNear, zFar);
3189 }
3190 ANGLE_CAPTURE(Ortho, isCallValid, context, left, right, bottom, top, zNear, zFar);
3191 }
3192 }
3193
PassThrough(GLfloat token)3194 void GL_APIENTRY PassThrough(GLfloat token)
3195 {
3196 EVENT("(GLfloat token = %f)", token);
3197
3198 Context *context = GetValidGlobalContext();
3199 if (context)
3200 {
3201 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3202 bool isCallValid = (context->skipValidation() || ValidatePassThrough(context, token));
3203 if (isCallValid)
3204 {
3205 context->passThrough(token);
3206 }
3207 ANGLE_CAPTURE(PassThrough, isCallValid, context, token);
3208 }
3209 }
3210
PixelMapfv(GLenum map,GLsizei mapsize,const GLfloat * values)3211 void GL_APIENTRY PixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
3212 {
3213 EVENT("(GLenum map = %s, GLsizei mapsize = %d, const GLfloat *values = 0x%016" PRIxPTR ")",
3214 GLenumToString(GLenumGroup::PixelMap, map), mapsize, (uintptr_t)values);
3215
3216 Context *context = GetValidGlobalContext();
3217 if (context)
3218 {
3219 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3220 bool isCallValid =
3221 (context->skipValidation() || ValidatePixelMapfv(context, map, mapsize, values));
3222 if (isCallValid)
3223 {
3224 context->pixelMapfv(map, mapsize, values);
3225 }
3226 ANGLE_CAPTURE(PixelMapfv, isCallValid, context, map, mapsize, values);
3227 }
3228 }
3229
PixelMapuiv(GLenum map,GLsizei mapsize,const GLuint * values)3230 void GL_APIENTRY PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
3231 {
3232 EVENT("(GLenum map = %s, GLsizei mapsize = %d, const GLuint *values = 0x%016" PRIxPTR ")",
3233 GLenumToString(GLenumGroup::PixelMap, map), mapsize, (uintptr_t)values);
3234
3235 Context *context = GetValidGlobalContext();
3236 if (context)
3237 {
3238 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3239 bool isCallValid =
3240 (context->skipValidation() || ValidatePixelMapuiv(context, map, mapsize, values));
3241 if (isCallValid)
3242 {
3243 context->pixelMapuiv(map, mapsize, values);
3244 }
3245 ANGLE_CAPTURE(PixelMapuiv, isCallValid, context, map, mapsize, values);
3246 }
3247 }
3248
PixelMapusv(GLenum map,GLsizei mapsize,const GLushort * values)3249 void GL_APIENTRY PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
3250 {
3251 EVENT("(GLenum map = %s, GLsizei mapsize = %d, const GLushort *values = 0x%016" PRIxPTR ")",
3252 GLenumToString(GLenumGroup::PixelMap, map), mapsize, (uintptr_t)values);
3253
3254 Context *context = GetValidGlobalContext();
3255 if (context)
3256 {
3257 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3258 bool isCallValid =
3259 (context->skipValidation() || ValidatePixelMapusv(context, map, mapsize, values));
3260 if (isCallValid)
3261 {
3262 context->pixelMapusv(map, mapsize, values);
3263 }
3264 ANGLE_CAPTURE(PixelMapusv, isCallValid, context, map, mapsize, values);
3265 }
3266 }
3267
PixelStoref(GLenum pname,GLfloat param)3268 void GL_APIENTRY PixelStoref(GLenum pname, GLfloat param)
3269 {
3270 EVENT("(GLenum pname = %s, GLfloat param = %f)",
3271 GLenumToString(GLenumGroup::PixelStoreParameter, pname), param);
3272
3273 Context *context = GetValidGlobalContext();
3274 if (context)
3275 {
3276 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3277 bool isCallValid =
3278 (context->skipValidation() || ValidatePixelStoref(context, pname, param));
3279 if (isCallValid)
3280 {
3281 context->pixelStoref(pname, param);
3282 }
3283 ANGLE_CAPTURE(PixelStoref, isCallValid, context, pname, param);
3284 }
3285 }
3286
PixelStorei(GLenum pname,GLint param)3287 void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
3288 {
3289 EVENT("(GLenum pname = %s, GLint param = %d)",
3290 GLenumToString(GLenumGroup::PixelStoreParameter, pname), param);
3291
3292 Context *context = GetValidGlobalContext();
3293 if (context)
3294 {
3295 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3296 bool isCallValid =
3297 (context->skipValidation() || ValidatePixelStorei(context, pname, param));
3298 if (isCallValid)
3299 {
3300 context->pixelStorei(pname, param);
3301 }
3302 ANGLE_CAPTURE(PixelStorei, isCallValid, context, pname, param);
3303 }
3304 }
3305
PixelTransferf(GLenum pname,GLfloat param)3306 void GL_APIENTRY PixelTransferf(GLenum pname, GLfloat param)
3307 {
3308 EVENT("(GLenum pname = %s, GLfloat param = %f)",
3309 GLenumToString(GLenumGroup::PixelTransferParameter, pname), param);
3310
3311 Context *context = GetValidGlobalContext();
3312 if (context)
3313 {
3314 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3315 bool isCallValid =
3316 (context->skipValidation() || ValidatePixelTransferf(context, pname, param));
3317 if (isCallValid)
3318 {
3319 context->pixelTransferf(pname, param);
3320 }
3321 ANGLE_CAPTURE(PixelTransferf, isCallValid, context, pname, param);
3322 }
3323 }
3324
PixelTransferi(GLenum pname,GLint param)3325 void GL_APIENTRY PixelTransferi(GLenum pname, GLint param)
3326 {
3327 EVENT("(GLenum pname = %s, GLint param = %d)",
3328 GLenumToString(GLenumGroup::PixelTransferParameter, pname), param);
3329
3330 Context *context = GetValidGlobalContext();
3331 if (context)
3332 {
3333 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3334 bool isCallValid =
3335 (context->skipValidation() || ValidatePixelTransferi(context, pname, param));
3336 if (isCallValid)
3337 {
3338 context->pixelTransferi(pname, param);
3339 }
3340 ANGLE_CAPTURE(PixelTransferi, isCallValid, context, pname, param);
3341 }
3342 }
3343
PixelZoom(GLfloat xfactor,GLfloat yfactor)3344 void GL_APIENTRY PixelZoom(GLfloat xfactor, GLfloat yfactor)
3345 {
3346 EVENT("(GLfloat xfactor = %f, GLfloat yfactor = %f)", xfactor, yfactor);
3347
3348 Context *context = GetValidGlobalContext();
3349 if (context)
3350 {
3351 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3352 bool isCallValid =
3353 (context->skipValidation() || ValidatePixelZoom(context, xfactor, yfactor));
3354 if (isCallValid)
3355 {
3356 context->pixelZoom(xfactor, yfactor);
3357 }
3358 ANGLE_CAPTURE(PixelZoom, isCallValid, context, xfactor, yfactor);
3359 }
3360 }
3361
PointSize(GLfloat size)3362 void GL_APIENTRY PointSize(GLfloat size)
3363 {
3364 EVENT("(GLfloat size = %f)", size);
3365
3366 Context *context = GetValidGlobalContext();
3367 if (context)
3368 {
3369 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3370 bool isCallValid = (context->skipValidation() || ValidatePointSize(context, size));
3371 if (isCallValid)
3372 {
3373 context->pointSize(size);
3374 }
3375 ANGLE_CAPTURE(PointSize, isCallValid, context, size);
3376 }
3377 }
3378
PolygonMode(GLenum face,GLenum mode)3379 void GL_APIENTRY PolygonMode(GLenum face, GLenum mode)
3380 {
3381 EVENT("(GLenum face = %s, GLenum mode = %s)", GLenumToString(GLenumGroup::MaterialFace, face),
3382 GLenumToString(GLenumGroup::PolygonMode, mode));
3383
3384 Context *context = GetValidGlobalContext();
3385 if (context)
3386 {
3387 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3388 bool isCallValid = (context->skipValidation() || ValidatePolygonMode(context, face, mode));
3389 if (isCallValid)
3390 {
3391 context->polygonMode(face, mode);
3392 }
3393 ANGLE_CAPTURE(PolygonMode, isCallValid, context, face, mode);
3394 }
3395 }
3396
PolygonStipple(const GLubyte * mask)3397 void GL_APIENTRY PolygonStipple(const GLubyte *mask)
3398 {
3399 EVENT("(const GLubyte *mask = 0x%016" PRIxPTR ")", (uintptr_t)mask);
3400
3401 Context *context = GetValidGlobalContext();
3402 if (context)
3403 {
3404 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3405 bool isCallValid = (context->skipValidation() || ValidatePolygonStipple(context, mask));
3406 if (isCallValid)
3407 {
3408 context->polygonStipple(mask);
3409 }
3410 ANGLE_CAPTURE(PolygonStipple, isCallValid, context, mask);
3411 }
3412 }
3413
PopAttrib()3414 void GL_APIENTRY PopAttrib()
3415 {
3416 EVENT("()");
3417
3418 Context *context = GetValidGlobalContext();
3419 if (context)
3420 {
3421 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3422 bool isCallValid = (context->skipValidation() || ValidatePopAttrib(context));
3423 if (isCallValid)
3424 {
3425 context->popAttrib();
3426 }
3427 ANGLE_CAPTURE(PopAttrib, isCallValid, context);
3428 }
3429 }
3430
PopMatrix()3431 void GL_APIENTRY PopMatrix()
3432 {
3433 EVENT("()");
3434
3435 Context *context = GetValidGlobalContext();
3436 if (context)
3437 {
3438 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3439 bool isCallValid = (context->skipValidation() || ValidatePopMatrix(context));
3440 if (isCallValid)
3441 {
3442 context->popMatrix();
3443 }
3444 ANGLE_CAPTURE(PopMatrix, isCallValid, context);
3445 }
3446 }
3447
PopName()3448 void GL_APIENTRY PopName()
3449 {
3450 EVENT("()");
3451
3452 Context *context = GetValidGlobalContext();
3453 if (context)
3454 {
3455 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3456 bool isCallValid = (context->skipValidation() || ValidatePopName(context));
3457 if (isCallValid)
3458 {
3459 context->popName();
3460 }
3461 ANGLE_CAPTURE(PopName, isCallValid, context);
3462 }
3463 }
3464
PushAttrib(GLbitfield mask)3465 void GL_APIENTRY PushAttrib(GLbitfield mask)
3466 {
3467 EVENT("(GLbitfield mask = %s)", GLbitfieldToString(GLenumGroup::AttribMask, mask).c_str());
3468
3469 Context *context = GetValidGlobalContext();
3470 if (context)
3471 {
3472 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3473 bool isCallValid = (context->skipValidation() || ValidatePushAttrib(context, mask));
3474 if (isCallValid)
3475 {
3476 context->pushAttrib(mask);
3477 }
3478 ANGLE_CAPTURE(PushAttrib, isCallValid, context, mask);
3479 }
3480 }
3481
PushMatrix()3482 void GL_APIENTRY PushMatrix()
3483 {
3484 EVENT("()");
3485
3486 Context *context = GetValidGlobalContext();
3487 if (context)
3488 {
3489 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3490 bool isCallValid = (context->skipValidation() || ValidatePushMatrix(context));
3491 if (isCallValid)
3492 {
3493 context->pushMatrix();
3494 }
3495 ANGLE_CAPTURE(PushMatrix, isCallValid, context);
3496 }
3497 }
3498
PushName(GLuint name)3499 void GL_APIENTRY PushName(GLuint name)
3500 {
3501 EVENT("(GLuint name = %u)", name);
3502
3503 Context *context = GetValidGlobalContext();
3504 if (context)
3505 {
3506 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3507 bool isCallValid = (context->skipValidation() || ValidatePushName(context, name));
3508 if (isCallValid)
3509 {
3510 context->pushName(name);
3511 }
3512 ANGLE_CAPTURE(PushName, isCallValid, context, name);
3513 }
3514 }
3515
RasterPos2d(GLdouble x,GLdouble y)3516 void GL_APIENTRY RasterPos2d(GLdouble x, GLdouble y)
3517 {
3518 EVENT("(GLdouble x = %f, GLdouble y = %f)", x, y);
3519
3520 Context *context = GetValidGlobalContext();
3521 if (context)
3522 {
3523 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3524 bool isCallValid = (context->skipValidation() || ValidateRasterPos2d(context, x, y));
3525 if (isCallValid)
3526 {
3527 context->rasterPos2d(x, y);
3528 }
3529 ANGLE_CAPTURE(RasterPos2d, isCallValid, context, x, y);
3530 }
3531 }
3532
RasterPos2dv(const GLdouble * v)3533 void GL_APIENTRY RasterPos2dv(const GLdouble *v)
3534 {
3535 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3536
3537 Context *context = GetValidGlobalContext();
3538 if (context)
3539 {
3540 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3541 bool isCallValid = (context->skipValidation() || ValidateRasterPos2dv(context, v));
3542 if (isCallValid)
3543 {
3544 context->rasterPos2dv(v);
3545 }
3546 ANGLE_CAPTURE(RasterPos2dv, isCallValid, context, v);
3547 }
3548 }
3549
RasterPos2f(GLfloat x,GLfloat y)3550 void GL_APIENTRY RasterPos2f(GLfloat x, GLfloat y)
3551 {
3552 EVENT("(GLfloat x = %f, GLfloat y = %f)", x, y);
3553
3554 Context *context = GetValidGlobalContext();
3555 if (context)
3556 {
3557 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3558 bool isCallValid = (context->skipValidation() || ValidateRasterPos2f(context, x, y));
3559 if (isCallValid)
3560 {
3561 context->rasterPos2f(x, y);
3562 }
3563 ANGLE_CAPTURE(RasterPos2f, isCallValid, context, x, y);
3564 }
3565 }
3566
RasterPos2fv(const GLfloat * v)3567 void GL_APIENTRY RasterPos2fv(const GLfloat *v)
3568 {
3569 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3570
3571 Context *context = GetValidGlobalContext();
3572 if (context)
3573 {
3574 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3575 bool isCallValid = (context->skipValidation() || ValidateRasterPos2fv(context, v));
3576 if (isCallValid)
3577 {
3578 context->rasterPos2fv(v);
3579 }
3580 ANGLE_CAPTURE(RasterPos2fv, isCallValid, context, v);
3581 }
3582 }
3583
RasterPos2i(GLint x,GLint y)3584 void GL_APIENTRY RasterPos2i(GLint x, GLint y)
3585 {
3586 EVENT("(GLint x = %d, GLint y = %d)", x, y);
3587
3588 Context *context = GetValidGlobalContext();
3589 if (context)
3590 {
3591 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3592 bool isCallValid = (context->skipValidation() || ValidateRasterPos2i(context, x, y));
3593 if (isCallValid)
3594 {
3595 context->rasterPos2i(x, y);
3596 }
3597 ANGLE_CAPTURE(RasterPos2i, isCallValid, context, x, y);
3598 }
3599 }
3600
RasterPos2iv(const GLint * v)3601 void GL_APIENTRY RasterPos2iv(const GLint *v)
3602 {
3603 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3604
3605 Context *context = GetValidGlobalContext();
3606 if (context)
3607 {
3608 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3609 bool isCallValid = (context->skipValidation() || ValidateRasterPos2iv(context, v));
3610 if (isCallValid)
3611 {
3612 context->rasterPos2iv(v);
3613 }
3614 ANGLE_CAPTURE(RasterPos2iv, isCallValid, context, v);
3615 }
3616 }
3617
RasterPos2s(GLshort x,GLshort y)3618 void GL_APIENTRY RasterPos2s(GLshort x, GLshort y)
3619 {
3620 EVENT("(GLshort x = %d, GLshort y = %d)", x, y);
3621
3622 Context *context = GetValidGlobalContext();
3623 if (context)
3624 {
3625 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3626 bool isCallValid = (context->skipValidation() || ValidateRasterPos2s(context, x, y));
3627 if (isCallValid)
3628 {
3629 context->rasterPos2s(x, y);
3630 }
3631 ANGLE_CAPTURE(RasterPos2s, isCallValid, context, x, y);
3632 }
3633 }
3634
RasterPos2sv(const GLshort * v)3635 void GL_APIENTRY RasterPos2sv(const GLshort *v)
3636 {
3637 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3638
3639 Context *context = GetValidGlobalContext();
3640 if (context)
3641 {
3642 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3643 bool isCallValid = (context->skipValidation() || ValidateRasterPos2sv(context, v));
3644 if (isCallValid)
3645 {
3646 context->rasterPos2sv(v);
3647 }
3648 ANGLE_CAPTURE(RasterPos2sv, isCallValid, context, v);
3649 }
3650 }
3651
RasterPos3d(GLdouble x,GLdouble y,GLdouble z)3652 void GL_APIENTRY RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
3653 {
3654 EVENT("(GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", x, y, z);
3655
3656 Context *context = GetValidGlobalContext();
3657 if (context)
3658 {
3659 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3660 bool isCallValid = (context->skipValidation() || ValidateRasterPos3d(context, x, y, z));
3661 if (isCallValid)
3662 {
3663 context->rasterPos3d(x, y, z);
3664 }
3665 ANGLE_CAPTURE(RasterPos3d, isCallValid, context, x, y, z);
3666 }
3667 }
3668
RasterPos3dv(const GLdouble * v)3669 void GL_APIENTRY RasterPos3dv(const GLdouble *v)
3670 {
3671 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3672
3673 Context *context = GetValidGlobalContext();
3674 if (context)
3675 {
3676 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3677 bool isCallValid = (context->skipValidation() || ValidateRasterPos3dv(context, v));
3678 if (isCallValid)
3679 {
3680 context->rasterPos3dv(v);
3681 }
3682 ANGLE_CAPTURE(RasterPos3dv, isCallValid, context, v);
3683 }
3684 }
3685
RasterPos3f(GLfloat x,GLfloat y,GLfloat z)3686 void GL_APIENTRY RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
3687 {
3688 EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
3689
3690 Context *context = GetValidGlobalContext();
3691 if (context)
3692 {
3693 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3694 bool isCallValid = (context->skipValidation() || ValidateRasterPos3f(context, x, y, z));
3695 if (isCallValid)
3696 {
3697 context->rasterPos3f(x, y, z);
3698 }
3699 ANGLE_CAPTURE(RasterPos3f, isCallValid, context, x, y, z);
3700 }
3701 }
3702
RasterPos3fv(const GLfloat * v)3703 void GL_APIENTRY RasterPos3fv(const GLfloat *v)
3704 {
3705 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3706
3707 Context *context = GetValidGlobalContext();
3708 if (context)
3709 {
3710 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3711 bool isCallValid = (context->skipValidation() || ValidateRasterPos3fv(context, v));
3712 if (isCallValid)
3713 {
3714 context->rasterPos3fv(v);
3715 }
3716 ANGLE_CAPTURE(RasterPos3fv, isCallValid, context, v);
3717 }
3718 }
3719
RasterPos3i(GLint x,GLint y,GLint z)3720 void GL_APIENTRY RasterPos3i(GLint x, GLint y, GLint z)
3721 {
3722 EVENT("(GLint x = %d, GLint y = %d, GLint z = %d)", x, y, z);
3723
3724 Context *context = GetValidGlobalContext();
3725 if (context)
3726 {
3727 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3728 bool isCallValid = (context->skipValidation() || ValidateRasterPos3i(context, x, y, z));
3729 if (isCallValid)
3730 {
3731 context->rasterPos3i(x, y, z);
3732 }
3733 ANGLE_CAPTURE(RasterPos3i, isCallValid, context, x, y, z);
3734 }
3735 }
3736
RasterPos3iv(const GLint * v)3737 void GL_APIENTRY RasterPos3iv(const GLint *v)
3738 {
3739 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3740
3741 Context *context = GetValidGlobalContext();
3742 if (context)
3743 {
3744 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3745 bool isCallValid = (context->skipValidation() || ValidateRasterPos3iv(context, v));
3746 if (isCallValid)
3747 {
3748 context->rasterPos3iv(v);
3749 }
3750 ANGLE_CAPTURE(RasterPos3iv, isCallValid, context, v);
3751 }
3752 }
3753
RasterPos3s(GLshort x,GLshort y,GLshort z)3754 void GL_APIENTRY RasterPos3s(GLshort x, GLshort y, GLshort z)
3755 {
3756 EVENT("(GLshort x = %d, GLshort y = %d, GLshort z = %d)", x, y, z);
3757
3758 Context *context = GetValidGlobalContext();
3759 if (context)
3760 {
3761 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3762 bool isCallValid = (context->skipValidation() || ValidateRasterPos3s(context, x, y, z));
3763 if (isCallValid)
3764 {
3765 context->rasterPos3s(x, y, z);
3766 }
3767 ANGLE_CAPTURE(RasterPos3s, isCallValid, context, x, y, z);
3768 }
3769 }
3770
RasterPos3sv(const GLshort * v)3771 void GL_APIENTRY RasterPos3sv(const GLshort *v)
3772 {
3773 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3774
3775 Context *context = GetValidGlobalContext();
3776 if (context)
3777 {
3778 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3779 bool isCallValid = (context->skipValidation() || ValidateRasterPos3sv(context, v));
3780 if (isCallValid)
3781 {
3782 context->rasterPos3sv(v);
3783 }
3784 ANGLE_CAPTURE(RasterPos3sv, isCallValid, context, v);
3785 }
3786 }
3787
RasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)3788 void GL_APIENTRY RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3789 {
3790 EVENT("(GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, GLdouble w = %f)", x, y, z, w);
3791
3792 Context *context = GetValidGlobalContext();
3793 if (context)
3794 {
3795 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3796 bool isCallValid = (context->skipValidation() || ValidateRasterPos4d(context, x, y, z, w));
3797 if (isCallValid)
3798 {
3799 context->rasterPos4d(x, y, z, w);
3800 }
3801 ANGLE_CAPTURE(RasterPos4d, isCallValid, context, x, y, z, w);
3802 }
3803 }
3804
RasterPos4dv(const GLdouble * v)3805 void GL_APIENTRY RasterPos4dv(const GLdouble *v)
3806 {
3807 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3808
3809 Context *context = GetValidGlobalContext();
3810 if (context)
3811 {
3812 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3813 bool isCallValid = (context->skipValidation() || ValidateRasterPos4dv(context, v));
3814 if (isCallValid)
3815 {
3816 context->rasterPos4dv(v);
3817 }
3818 ANGLE_CAPTURE(RasterPos4dv, isCallValid, context, v);
3819 }
3820 }
3821
RasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)3822 void GL_APIENTRY RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3823 {
3824 EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", x, y, z, w);
3825
3826 Context *context = GetValidGlobalContext();
3827 if (context)
3828 {
3829 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3830 bool isCallValid = (context->skipValidation() || ValidateRasterPos4f(context, x, y, z, w));
3831 if (isCallValid)
3832 {
3833 context->rasterPos4f(x, y, z, w);
3834 }
3835 ANGLE_CAPTURE(RasterPos4f, isCallValid, context, x, y, z, w);
3836 }
3837 }
3838
RasterPos4fv(const GLfloat * v)3839 void GL_APIENTRY RasterPos4fv(const GLfloat *v)
3840 {
3841 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3842
3843 Context *context = GetValidGlobalContext();
3844 if (context)
3845 {
3846 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3847 bool isCallValid = (context->skipValidation() || ValidateRasterPos4fv(context, v));
3848 if (isCallValid)
3849 {
3850 context->rasterPos4fv(v);
3851 }
3852 ANGLE_CAPTURE(RasterPos4fv, isCallValid, context, v);
3853 }
3854 }
3855
RasterPos4i(GLint x,GLint y,GLint z,GLint w)3856 void GL_APIENTRY RasterPos4i(GLint x, GLint y, GLint z, GLint w)
3857 {
3858 EVENT("(GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)", x, y, z, w);
3859
3860 Context *context = GetValidGlobalContext();
3861 if (context)
3862 {
3863 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3864 bool isCallValid = (context->skipValidation() || ValidateRasterPos4i(context, x, y, z, w));
3865 if (isCallValid)
3866 {
3867 context->rasterPos4i(x, y, z, w);
3868 }
3869 ANGLE_CAPTURE(RasterPos4i, isCallValid, context, x, y, z, w);
3870 }
3871 }
3872
RasterPos4iv(const GLint * v)3873 void GL_APIENTRY RasterPos4iv(const GLint *v)
3874 {
3875 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3876
3877 Context *context = GetValidGlobalContext();
3878 if (context)
3879 {
3880 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3881 bool isCallValid = (context->skipValidation() || ValidateRasterPos4iv(context, v));
3882 if (isCallValid)
3883 {
3884 context->rasterPos4iv(v);
3885 }
3886 ANGLE_CAPTURE(RasterPos4iv, isCallValid, context, v);
3887 }
3888 }
3889
RasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w)3890 void GL_APIENTRY RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
3891 {
3892 EVENT("(GLshort x = %d, GLshort y = %d, GLshort z = %d, GLshort w = %d)", x, y, z, w);
3893
3894 Context *context = GetValidGlobalContext();
3895 if (context)
3896 {
3897 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3898 bool isCallValid = (context->skipValidation() || ValidateRasterPos4s(context, x, y, z, w));
3899 if (isCallValid)
3900 {
3901 context->rasterPos4s(x, y, z, w);
3902 }
3903 ANGLE_CAPTURE(RasterPos4s, isCallValid, context, x, y, z, w);
3904 }
3905 }
3906
RasterPos4sv(const GLshort * v)3907 void GL_APIENTRY RasterPos4sv(const GLshort *v)
3908 {
3909 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
3910
3911 Context *context = GetValidGlobalContext();
3912 if (context)
3913 {
3914 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3915 bool isCallValid = (context->skipValidation() || ValidateRasterPos4sv(context, v));
3916 if (isCallValid)
3917 {
3918 context->rasterPos4sv(v);
3919 }
3920 ANGLE_CAPTURE(RasterPos4sv, isCallValid, context, v);
3921 }
3922 }
3923
ReadBuffer(GLenum src)3924 void GL_APIENTRY ReadBuffer(GLenum src)
3925 {
3926 EVENT("(GLenum src = %s)", GLenumToString(GLenumGroup::ReadBufferMode, src));
3927
3928 Context *context = GetValidGlobalContext();
3929 if (context)
3930 {
3931 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3932 bool isCallValid = (context->skipValidation() || ValidateReadBuffer(context, src));
3933 if (isCallValid)
3934 {
3935 context->readBuffer(src);
3936 }
3937 ANGLE_CAPTURE(ReadBuffer, isCallValid, context, src);
3938 }
3939 }
3940
ReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void * pixels)3941 void GL_APIENTRY ReadPixels(GLint x,
3942 GLint y,
3943 GLsizei width,
3944 GLsizei height,
3945 GLenum format,
3946 GLenum type,
3947 void *pixels)
3948 {
3949 EVENT(
3950 "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, "
3951 "GLenum type = %s, void *pixels = 0x%016" PRIxPTR ")",
3952 x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
3953 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
3954
3955 Context *context = GetValidGlobalContext();
3956 if (context)
3957 {
3958 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3959 bool isCallValid = (context->skipValidation() ||
3960 ValidateReadPixels(context, x, y, width, height, format, type, pixels));
3961 if (isCallValid)
3962 {
3963 context->readPixels(x, y, width, height, format, type, pixels);
3964 }
3965 ANGLE_CAPTURE(ReadPixels, isCallValid, context, x, y, width, height, format, type, pixels);
3966 }
3967 }
3968
Rectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2)3969 void GL_APIENTRY Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
3970 {
3971 EVENT("(GLdouble x1 = %f, GLdouble y1 = %f, GLdouble x2 = %f, GLdouble y2 = %f)", x1, y1, x2,
3972 y2);
3973
3974 Context *context = GetValidGlobalContext();
3975 if (context)
3976 {
3977 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3978 bool isCallValid = (context->skipValidation() || ValidateRectd(context, x1, y1, x2, y2));
3979 if (isCallValid)
3980 {
3981 context->rectd(x1, y1, x2, y2);
3982 }
3983 ANGLE_CAPTURE(Rectd, isCallValid, context, x1, y1, x2, y2);
3984 }
3985 }
3986
Rectdv(const GLdouble * v1,const GLdouble * v2)3987 void GL_APIENTRY Rectdv(const GLdouble *v1, const GLdouble *v2)
3988 {
3989 EVENT("(const GLdouble *v1 = 0x%016" PRIxPTR ", const GLdouble *v2 = 0x%016" PRIxPTR ")",
3990 (uintptr_t)v1, (uintptr_t)v2);
3991
3992 Context *context = GetValidGlobalContext();
3993 if (context)
3994 {
3995 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
3996 bool isCallValid = (context->skipValidation() || ValidateRectdv(context, v1, v2));
3997 if (isCallValid)
3998 {
3999 context->rectdv(v1, v2);
4000 }
4001 ANGLE_CAPTURE(Rectdv, isCallValid, context, v1, v2);
4002 }
4003 }
4004
Rectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2)4005 void GL_APIENTRY Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
4006 {
4007 EVENT("(GLfloat x1 = %f, GLfloat y1 = %f, GLfloat x2 = %f, GLfloat y2 = %f)", x1, y1, x2, y2);
4008
4009 Context *context = GetValidGlobalContext();
4010 if (context)
4011 {
4012 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4013 bool isCallValid = (context->skipValidation() || ValidateRectf(context, x1, y1, x2, y2));
4014 if (isCallValid)
4015 {
4016 context->rectf(x1, y1, x2, y2);
4017 }
4018 ANGLE_CAPTURE(Rectf, isCallValid, context, x1, y1, x2, y2);
4019 }
4020 }
4021
Rectfv(const GLfloat * v1,const GLfloat * v2)4022 void GL_APIENTRY Rectfv(const GLfloat *v1, const GLfloat *v2)
4023 {
4024 EVENT("(const GLfloat *v1 = 0x%016" PRIxPTR ", const GLfloat *v2 = 0x%016" PRIxPTR ")",
4025 (uintptr_t)v1, (uintptr_t)v2);
4026
4027 Context *context = GetValidGlobalContext();
4028 if (context)
4029 {
4030 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4031 bool isCallValid = (context->skipValidation() || ValidateRectfv(context, v1, v2));
4032 if (isCallValid)
4033 {
4034 context->rectfv(v1, v2);
4035 }
4036 ANGLE_CAPTURE(Rectfv, isCallValid, context, v1, v2);
4037 }
4038 }
4039
Recti(GLint x1,GLint y1,GLint x2,GLint y2)4040 void GL_APIENTRY Recti(GLint x1, GLint y1, GLint x2, GLint y2)
4041 {
4042 EVENT("(GLint x1 = %d, GLint y1 = %d, GLint x2 = %d, GLint y2 = %d)", x1, y1, x2, y2);
4043
4044 Context *context = GetValidGlobalContext();
4045 if (context)
4046 {
4047 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4048 bool isCallValid = (context->skipValidation() || ValidateRecti(context, x1, y1, x2, y2));
4049 if (isCallValid)
4050 {
4051 context->recti(x1, y1, x2, y2);
4052 }
4053 ANGLE_CAPTURE(Recti, isCallValid, context, x1, y1, x2, y2);
4054 }
4055 }
4056
Rectiv(const GLint * v1,const GLint * v2)4057 void GL_APIENTRY Rectiv(const GLint *v1, const GLint *v2)
4058 {
4059 EVENT("(const GLint *v1 = 0x%016" PRIxPTR ", const GLint *v2 = 0x%016" PRIxPTR ")",
4060 (uintptr_t)v1, (uintptr_t)v2);
4061
4062 Context *context = GetValidGlobalContext();
4063 if (context)
4064 {
4065 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4066 bool isCallValid = (context->skipValidation() || ValidateRectiv(context, v1, v2));
4067 if (isCallValid)
4068 {
4069 context->rectiv(v1, v2);
4070 }
4071 ANGLE_CAPTURE(Rectiv, isCallValid, context, v1, v2);
4072 }
4073 }
4074
Rects(GLshort x1,GLshort y1,GLshort x2,GLshort y2)4075 void GL_APIENTRY Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
4076 {
4077 EVENT("(GLshort x1 = %d, GLshort y1 = %d, GLshort x2 = %d, GLshort y2 = %d)", x1, y1, x2, y2);
4078
4079 Context *context = GetValidGlobalContext();
4080 if (context)
4081 {
4082 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4083 bool isCallValid = (context->skipValidation() || ValidateRects(context, x1, y1, x2, y2));
4084 if (isCallValid)
4085 {
4086 context->rects(x1, y1, x2, y2);
4087 }
4088 ANGLE_CAPTURE(Rects, isCallValid, context, x1, y1, x2, y2);
4089 }
4090 }
4091
Rectsv(const GLshort * v1,const GLshort * v2)4092 void GL_APIENTRY Rectsv(const GLshort *v1, const GLshort *v2)
4093 {
4094 EVENT("(const GLshort *v1 = 0x%016" PRIxPTR ", const GLshort *v2 = 0x%016" PRIxPTR ")",
4095 (uintptr_t)v1, (uintptr_t)v2);
4096
4097 Context *context = GetValidGlobalContext();
4098 if (context)
4099 {
4100 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4101 bool isCallValid = (context->skipValidation() || ValidateRectsv(context, v1, v2));
4102 if (isCallValid)
4103 {
4104 context->rectsv(v1, v2);
4105 }
4106 ANGLE_CAPTURE(Rectsv, isCallValid, context, v1, v2);
4107 }
4108 }
4109
RenderMode(GLenum mode)4110 GLint GL_APIENTRY RenderMode(GLenum mode)
4111 {
4112 EVENT("(GLenum mode = %s)", GLenumToString(GLenumGroup::RenderingMode, mode));
4113
4114 Context *context = GetValidGlobalContext();
4115 GLint returnValue;
4116 if (context)
4117 {
4118 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4119 bool isCallValid = (context->skipValidation() || ValidateRenderMode(context, mode));
4120 if (isCallValid)
4121 {
4122 returnValue = context->renderMode(mode);
4123 }
4124 else
4125 {
4126 returnValue = GetDefaultReturnValue<EntryPoint::RenderMode, GLint>();
4127 }
4128 ANGLE_CAPTURE(RenderMode, isCallValid, context, mode, returnValue);
4129 }
4130 else
4131 {
4132 returnValue = GetDefaultReturnValue<EntryPoint::RenderMode, GLint>();
4133 }
4134 return returnValue;
4135 }
4136
Rotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z)4137 void GL_APIENTRY Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
4138 {
4139 EVENT("(GLdouble angle = %f, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", angle, x, y,
4140 z);
4141
4142 Context *context = GetValidGlobalContext();
4143 if (context)
4144 {
4145 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4146 bool isCallValid = (context->skipValidation() || ValidateRotated(context, angle, x, y, z));
4147 if (isCallValid)
4148 {
4149 context->rotated(angle, x, y, z);
4150 }
4151 ANGLE_CAPTURE(Rotated, isCallValid, context, angle, x, y, z);
4152 }
4153 }
4154
Rotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)4155 void GL_APIENTRY Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
4156 {
4157 EVENT("(GLfloat angle = %f, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", angle, x, y, z);
4158
4159 Context *context = GetValidGlobalContext();
4160 if (context)
4161 {
4162 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4163 bool isCallValid = (context->skipValidation() || ValidateRotatef(context, angle, x, y, z));
4164 if (isCallValid)
4165 {
4166 context->rotatef(angle, x, y, z);
4167 }
4168 ANGLE_CAPTURE(Rotatef, isCallValid, context, angle, x, y, z);
4169 }
4170 }
4171
Scaled(GLdouble x,GLdouble y,GLdouble z)4172 void GL_APIENTRY Scaled(GLdouble x, GLdouble y, GLdouble z)
4173 {
4174 EVENT("(GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", x, y, z);
4175
4176 Context *context = GetValidGlobalContext();
4177 if (context)
4178 {
4179 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4180 bool isCallValid = (context->skipValidation() || ValidateScaled(context, x, y, z));
4181 if (isCallValid)
4182 {
4183 context->scaled(x, y, z);
4184 }
4185 ANGLE_CAPTURE(Scaled, isCallValid, context, x, y, z);
4186 }
4187 }
4188
Scalef(GLfloat x,GLfloat y,GLfloat z)4189 void GL_APIENTRY Scalef(GLfloat x, GLfloat y, GLfloat z)
4190 {
4191 EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
4192
4193 Context *context = GetValidGlobalContext();
4194 if (context)
4195 {
4196 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4197 bool isCallValid = (context->skipValidation() || ValidateScalef(context, x, y, z));
4198 if (isCallValid)
4199 {
4200 context->scalef(x, y, z);
4201 }
4202 ANGLE_CAPTURE(Scalef, isCallValid, context, x, y, z);
4203 }
4204 }
4205
Scissor(GLint x,GLint y,GLsizei width,GLsizei height)4206 void GL_APIENTRY Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
4207 {
4208 EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width,
4209 height);
4210
4211 Context *context = GetValidGlobalContext();
4212 if (context)
4213 {
4214 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4215 bool isCallValid =
4216 (context->skipValidation() || ValidateScissor(context, x, y, width, height));
4217 if (isCallValid)
4218 {
4219 context->scissor(x, y, width, height);
4220 }
4221 ANGLE_CAPTURE(Scissor, isCallValid, context, x, y, width, height);
4222 }
4223 }
4224
SelectBuffer(GLsizei size,GLuint * buffer)4225 void GL_APIENTRY SelectBuffer(GLsizei size, GLuint *buffer)
4226 {
4227 EVENT("(GLsizei size = %d, GLuint *buffer = 0x%016" PRIxPTR ")", size, (uintptr_t)buffer);
4228
4229 Context *context = GetValidGlobalContext();
4230 if (context)
4231 {
4232 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4233 bool isCallValid =
4234 (context->skipValidation() || ValidateSelectBuffer(context, size, buffer));
4235 if (isCallValid)
4236 {
4237 context->selectBuffer(size, buffer);
4238 }
4239 ANGLE_CAPTURE(SelectBuffer, isCallValid, context, size, buffer);
4240 }
4241 }
4242
ShadeModel(GLenum mode)4243 void GL_APIENTRY ShadeModel(GLenum mode)
4244 {
4245 EVENT("(GLenum mode = %s)", GLenumToString(GLenumGroup::ShadingModel, mode));
4246
4247 Context *context = GetValidGlobalContext();
4248 if (context)
4249 {
4250 ShadingModel modePacked = FromGL<ShadingModel>(mode);
4251 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4252 bool isCallValid = (context->skipValidation() || ValidateShadeModel(context, modePacked));
4253 if (isCallValid)
4254 {
4255 context->shadeModel(modePacked);
4256 }
4257 ANGLE_CAPTURE(ShadeModel, isCallValid, context, modePacked);
4258 }
4259 }
4260
StencilFunc(GLenum func,GLint ref,GLuint mask)4261 void GL_APIENTRY StencilFunc(GLenum func, GLint ref, GLuint mask)
4262 {
4263 EVENT("(GLenum func = %s, GLint ref = %d, GLuint mask = %u)",
4264 GLenumToString(GLenumGroup::StencilFunction, func), ref, mask);
4265
4266 Context *context = GetValidGlobalContext();
4267 if (context)
4268 {
4269 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4270 bool isCallValid =
4271 (context->skipValidation() || ValidateStencilFunc(context, func, ref, mask));
4272 if (isCallValid)
4273 {
4274 context->stencilFunc(func, ref, mask);
4275 }
4276 ANGLE_CAPTURE(StencilFunc, isCallValid, context, func, ref, mask);
4277 }
4278 }
4279
StencilMask(GLuint mask)4280 void GL_APIENTRY StencilMask(GLuint mask)
4281 {
4282 EVENT("(GLuint mask = %u)", mask);
4283
4284 Context *context = GetValidGlobalContext();
4285 if (context)
4286 {
4287 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4288 bool isCallValid = (context->skipValidation() || ValidateStencilMask(context, mask));
4289 if (isCallValid)
4290 {
4291 context->stencilMask(mask);
4292 }
4293 ANGLE_CAPTURE(StencilMask, isCallValid, context, mask);
4294 }
4295 }
4296
StencilOp(GLenum fail,GLenum zfail,GLenum zpass)4297 void GL_APIENTRY StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
4298 {
4299 EVENT("(GLenum fail = %s, GLenum zfail = %s, GLenum zpass = %s)",
4300 GLenumToString(GLenumGroup::StencilOp, fail),
4301 GLenumToString(GLenumGroup::StencilOp, zfail),
4302 GLenumToString(GLenumGroup::StencilOp, zpass));
4303
4304 Context *context = GetValidGlobalContext();
4305 if (context)
4306 {
4307 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4308 bool isCallValid =
4309 (context->skipValidation() || ValidateStencilOp(context, fail, zfail, zpass));
4310 if (isCallValid)
4311 {
4312 context->stencilOp(fail, zfail, zpass);
4313 }
4314 ANGLE_CAPTURE(StencilOp, isCallValid, context, fail, zfail, zpass);
4315 }
4316 }
4317
TexCoord1d(GLdouble s)4318 void GL_APIENTRY TexCoord1d(GLdouble s)
4319 {
4320 EVENT("(GLdouble s = %f)", s);
4321
4322 Context *context = GetValidGlobalContext();
4323 if (context)
4324 {
4325 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4326 bool isCallValid = (context->skipValidation() || ValidateTexCoord1d(context, s));
4327 if (isCallValid)
4328 {
4329 context->texCoord1d(s);
4330 }
4331 ANGLE_CAPTURE(TexCoord1d, isCallValid, context, s);
4332 }
4333 }
4334
TexCoord1dv(const GLdouble * v)4335 void GL_APIENTRY TexCoord1dv(const GLdouble *v)
4336 {
4337 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4338
4339 Context *context = GetValidGlobalContext();
4340 if (context)
4341 {
4342 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4343 bool isCallValid = (context->skipValidation() || ValidateTexCoord1dv(context, v));
4344 if (isCallValid)
4345 {
4346 context->texCoord1dv(v);
4347 }
4348 ANGLE_CAPTURE(TexCoord1dv, isCallValid, context, v);
4349 }
4350 }
4351
TexCoord1f(GLfloat s)4352 void GL_APIENTRY TexCoord1f(GLfloat s)
4353 {
4354 EVENT("(GLfloat s = %f)", s);
4355
4356 Context *context = GetValidGlobalContext();
4357 if (context)
4358 {
4359 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4360 bool isCallValid = (context->skipValidation() || ValidateTexCoord1f(context, s));
4361 if (isCallValid)
4362 {
4363 context->texCoord1f(s);
4364 }
4365 ANGLE_CAPTURE(TexCoord1f, isCallValid, context, s);
4366 }
4367 }
4368
TexCoord1fv(const GLfloat * v)4369 void GL_APIENTRY TexCoord1fv(const GLfloat *v)
4370 {
4371 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4372
4373 Context *context = GetValidGlobalContext();
4374 if (context)
4375 {
4376 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4377 bool isCallValid = (context->skipValidation() || ValidateTexCoord1fv(context, v));
4378 if (isCallValid)
4379 {
4380 context->texCoord1fv(v);
4381 }
4382 ANGLE_CAPTURE(TexCoord1fv, isCallValid, context, v);
4383 }
4384 }
4385
TexCoord1i(GLint s)4386 void GL_APIENTRY TexCoord1i(GLint s)
4387 {
4388 EVENT("(GLint s = %d)", s);
4389
4390 Context *context = GetValidGlobalContext();
4391 if (context)
4392 {
4393 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4394 bool isCallValid = (context->skipValidation() || ValidateTexCoord1i(context, s));
4395 if (isCallValid)
4396 {
4397 context->texCoord1i(s);
4398 }
4399 ANGLE_CAPTURE(TexCoord1i, isCallValid, context, s);
4400 }
4401 }
4402
TexCoord1iv(const GLint * v)4403 void GL_APIENTRY TexCoord1iv(const GLint *v)
4404 {
4405 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4406
4407 Context *context = GetValidGlobalContext();
4408 if (context)
4409 {
4410 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4411 bool isCallValid = (context->skipValidation() || ValidateTexCoord1iv(context, v));
4412 if (isCallValid)
4413 {
4414 context->texCoord1iv(v);
4415 }
4416 ANGLE_CAPTURE(TexCoord1iv, isCallValid, context, v);
4417 }
4418 }
4419
TexCoord1s(GLshort s)4420 void GL_APIENTRY TexCoord1s(GLshort s)
4421 {
4422 EVENT("(GLshort s = %d)", s);
4423
4424 Context *context = GetValidGlobalContext();
4425 if (context)
4426 {
4427 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4428 bool isCallValid = (context->skipValidation() || ValidateTexCoord1s(context, s));
4429 if (isCallValid)
4430 {
4431 context->texCoord1s(s);
4432 }
4433 ANGLE_CAPTURE(TexCoord1s, isCallValid, context, s);
4434 }
4435 }
4436
TexCoord1sv(const GLshort * v)4437 void GL_APIENTRY TexCoord1sv(const GLshort *v)
4438 {
4439 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4440
4441 Context *context = GetValidGlobalContext();
4442 if (context)
4443 {
4444 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4445 bool isCallValid = (context->skipValidation() || ValidateTexCoord1sv(context, v));
4446 if (isCallValid)
4447 {
4448 context->texCoord1sv(v);
4449 }
4450 ANGLE_CAPTURE(TexCoord1sv, isCallValid, context, v);
4451 }
4452 }
4453
TexCoord2d(GLdouble s,GLdouble t)4454 void GL_APIENTRY TexCoord2d(GLdouble s, GLdouble t)
4455 {
4456 EVENT("(GLdouble s = %f, GLdouble t = %f)", s, t);
4457
4458 Context *context = GetValidGlobalContext();
4459 if (context)
4460 {
4461 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4462 bool isCallValid = (context->skipValidation() || ValidateTexCoord2d(context, s, t));
4463 if (isCallValid)
4464 {
4465 context->texCoord2d(s, t);
4466 }
4467 ANGLE_CAPTURE(TexCoord2d, isCallValid, context, s, t);
4468 }
4469 }
4470
TexCoord2dv(const GLdouble * v)4471 void GL_APIENTRY TexCoord2dv(const GLdouble *v)
4472 {
4473 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4474
4475 Context *context = GetValidGlobalContext();
4476 if (context)
4477 {
4478 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4479 bool isCallValid = (context->skipValidation() || ValidateTexCoord2dv(context, v));
4480 if (isCallValid)
4481 {
4482 context->texCoord2dv(v);
4483 }
4484 ANGLE_CAPTURE(TexCoord2dv, isCallValid, context, v);
4485 }
4486 }
4487
TexCoord2f(GLfloat s,GLfloat t)4488 void GL_APIENTRY TexCoord2f(GLfloat s, GLfloat t)
4489 {
4490 EVENT("(GLfloat s = %f, GLfloat t = %f)", s, t);
4491
4492 Context *context = GetValidGlobalContext();
4493 if (context)
4494 {
4495 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4496 bool isCallValid = (context->skipValidation() || ValidateTexCoord2f(context, s, t));
4497 if (isCallValid)
4498 {
4499 context->texCoord2f(s, t);
4500 }
4501 ANGLE_CAPTURE(TexCoord2f, isCallValid, context, s, t);
4502 }
4503 }
4504
TexCoord2fv(const GLfloat * v)4505 void GL_APIENTRY TexCoord2fv(const GLfloat *v)
4506 {
4507 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4508
4509 Context *context = GetValidGlobalContext();
4510 if (context)
4511 {
4512 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4513 bool isCallValid = (context->skipValidation() || ValidateTexCoord2fv(context, v));
4514 if (isCallValid)
4515 {
4516 context->texCoord2fv(v);
4517 }
4518 ANGLE_CAPTURE(TexCoord2fv, isCallValid, context, v);
4519 }
4520 }
4521
TexCoord2i(GLint s,GLint t)4522 void GL_APIENTRY TexCoord2i(GLint s, GLint t)
4523 {
4524 EVENT("(GLint s = %d, GLint t = %d)", s, t);
4525
4526 Context *context = GetValidGlobalContext();
4527 if (context)
4528 {
4529 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4530 bool isCallValid = (context->skipValidation() || ValidateTexCoord2i(context, s, t));
4531 if (isCallValid)
4532 {
4533 context->texCoord2i(s, t);
4534 }
4535 ANGLE_CAPTURE(TexCoord2i, isCallValid, context, s, t);
4536 }
4537 }
4538
TexCoord2iv(const GLint * v)4539 void GL_APIENTRY TexCoord2iv(const GLint *v)
4540 {
4541 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4542
4543 Context *context = GetValidGlobalContext();
4544 if (context)
4545 {
4546 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4547 bool isCallValid = (context->skipValidation() || ValidateTexCoord2iv(context, v));
4548 if (isCallValid)
4549 {
4550 context->texCoord2iv(v);
4551 }
4552 ANGLE_CAPTURE(TexCoord2iv, isCallValid, context, v);
4553 }
4554 }
4555
TexCoord2s(GLshort s,GLshort t)4556 void GL_APIENTRY TexCoord2s(GLshort s, GLshort t)
4557 {
4558 EVENT("(GLshort s = %d, GLshort t = %d)", s, t);
4559
4560 Context *context = GetValidGlobalContext();
4561 if (context)
4562 {
4563 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4564 bool isCallValid = (context->skipValidation() || ValidateTexCoord2s(context, s, t));
4565 if (isCallValid)
4566 {
4567 context->texCoord2s(s, t);
4568 }
4569 ANGLE_CAPTURE(TexCoord2s, isCallValid, context, s, t);
4570 }
4571 }
4572
TexCoord2sv(const GLshort * v)4573 void GL_APIENTRY TexCoord2sv(const GLshort *v)
4574 {
4575 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4576
4577 Context *context = GetValidGlobalContext();
4578 if (context)
4579 {
4580 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4581 bool isCallValid = (context->skipValidation() || ValidateTexCoord2sv(context, v));
4582 if (isCallValid)
4583 {
4584 context->texCoord2sv(v);
4585 }
4586 ANGLE_CAPTURE(TexCoord2sv, isCallValid, context, v);
4587 }
4588 }
4589
TexCoord3d(GLdouble s,GLdouble t,GLdouble r)4590 void GL_APIENTRY TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
4591 {
4592 EVENT("(GLdouble s = %f, GLdouble t = %f, GLdouble r = %f)", s, t, r);
4593
4594 Context *context = GetValidGlobalContext();
4595 if (context)
4596 {
4597 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4598 bool isCallValid = (context->skipValidation() || ValidateTexCoord3d(context, s, t, r));
4599 if (isCallValid)
4600 {
4601 context->texCoord3d(s, t, r);
4602 }
4603 ANGLE_CAPTURE(TexCoord3d, isCallValid, context, s, t, r);
4604 }
4605 }
4606
TexCoord3dv(const GLdouble * v)4607 void GL_APIENTRY TexCoord3dv(const GLdouble *v)
4608 {
4609 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4610
4611 Context *context = GetValidGlobalContext();
4612 if (context)
4613 {
4614 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4615 bool isCallValid = (context->skipValidation() || ValidateTexCoord3dv(context, v));
4616 if (isCallValid)
4617 {
4618 context->texCoord3dv(v);
4619 }
4620 ANGLE_CAPTURE(TexCoord3dv, isCallValid, context, v);
4621 }
4622 }
4623
TexCoord3f(GLfloat s,GLfloat t,GLfloat r)4624 void GL_APIENTRY TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
4625 {
4626 EVENT("(GLfloat s = %f, GLfloat t = %f, GLfloat r = %f)", s, t, r);
4627
4628 Context *context = GetValidGlobalContext();
4629 if (context)
4630 {
4631 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4632 bool isCallValid = (context->skipValidation() || ValidateTexCoord3f(context, s, t, r));
4633 if (isCallValid)
4634 {
4635 context->texCoord3f(s, t, r);
4636 }
4637 ANGLE_CAPTURE(TexCoord3f, isCallValid, context, s, t, r);
4638 }
4639 }
4640
TexCoord3fv(const GLfloat * v)4641 void GL_APIENTRY TexCoord3fv(const GLfloat *v)
4642 {
4643 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4644
4645 Context *context = GetValidGlobalContext();
4646 if (context)
4647 {
4648 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4649 bool isCallValid = (context->skipValidation() || ValidateTexCoord3fv(context, v));
4650 if (isCallValid)
4651 {
4652 context->texCoord3fv(v);
4653 }
4654 ANGLE_CAPTURE(TexCoord3fv, isCallValid, context, v);
4655 }
4656 }
4657
TexCoord3i(GLint s,GLint t,GLint r)4658 void GL_APIENTRY TexCoord3i(GLint s, GLint t, GLint r)
4659 {
4660 EVENT("(GLint s = %d, GLint t = %d, GLint r = %d)", s, t, r);
4661
4662 Context *context = GetValidGlobalContext();
4663 if (context)
4664 {
4665 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4666 bool isCallValid = (context->skipValidation() || ValidateTexCoord3i(context, s, t, r));
4667 if (isCallValid)
4668 {
4669 context->texCoord3i(s, t, r);
4670 }
4671 ANGLE_CAPTURE(TexCoord3i, isCallValid, context, s, t, r);
4672 }
4673 }
4674
TexCoord3iv(const GLint * v)4675 void GL_APIENTRY TexCoord3iv(const GLint *v)
4676 {
4677 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4678
4679 Context *context = GetValidGlobalContext();
4680 if (context)
4681 {
4682 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4683 bool isCallValid = (context->skipValidation() || ValidateTexCoord3iv(context, v));
4684 if (isCallValid)
4685 {
4686 context->texCoord3iv(v);
4687 }
4688 ANGLE_CAPTURE(TexCoord3iv, isCallValid, context, v);
4689 }
4690 }
4691
TexCoord3s(GLshort s,GLshort t,GLshort r)4692 void GL_APIENTRY TexCoord3s(GLshort s, GLshort t, GLshort r)
4693 {
4694 EVENT("(GLshort s = %d, GLshort t = %d, GLshort r = %d)", s, t, r);
4695
4696 Context *context = GetValidGlobalContext();
4697 if (context)
4698 {
4699 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4700 bool isCallValid = (context->skipValidation() || ValidateTexCoord3s(context, s, t, r));
4701 if (isCallValid)
4702 {
4703 context->texCoord3s(s, t, r);
4704 }
4705 ANGLE_CAPTURE(TexCoord3s, isCallValid, context, s, t, r);
4706 }
4707 }
4708
TexCoord3sv(const GLshort * v)4709 void GL_APIENTRY TexCoord3sv(const GLshort *v)
4710 {
4711 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4712
4713 Context *context = GetValidGlobalContext();
4714 if (context)
4715 {
4716 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4717 bool isCallValid = (context->skipValidation() || ValidateTexCoord3sv(context, v));
4718 if (isCallValid)
4719 {
4720 context->texCoord3sv(v);
4721 }
4722 ANGLE_CAPTURE(TexCoord3sv, isCallValid, context, v);
4723 }
4724 }
4725
TexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q)4726 void GL_APIENTRY TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
4727 {
4728 EVENT("(GLdouble s = %f, GLdouble t = %f, GLdouble r = %f, GLdouble q = %f)", s, t, r, q);
4729
4730 Context *context = GetValidGlobalContext();
4731 if (context)
4732 {
4733 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4734 bool isCallValid = (context->skipValidation() || ValidateTexCoord4d(context, s, t, r, q));
4735 if (isCallValid)
4736 {
4737 context->texCoord4d(s, t, r, q);
4738 }
4739 ANGLE_CAPTURE(TexCoord4d, isCallValid, context, s, t, r, q);
4740 }
4741 }
4742
TexCoord4dv(const GLdouble * v)4743 void GL_APIENTRY TexCoord4dv(const GLdouble *v)
4744 {
4745 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4746
4747 Context *context = GetValidGlobalContext();
4748 if (context)
4749 {
4750 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4751 bool isCallValid = (context->skipValidation() || ValidateTexCoord4dv(context, v));
4752 if (isCallValid)
4753 {
4754 context->texCoord4dv(v);
4755 }
4756 ANGLE_CAPTURE(TexCoord4dv, isCallValid, context, v);
4757 }
4758 }
4759
TexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q)4760 void GL_APIENTRY TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
4761 {
4762 EVENT("(GLfloat s = %f, GLfloat t = %f, GLfloat r = %f, GLfloat q = %f)", s, t, r, q);
4763
4764 Context *context = GetValidGlobalContext();
4765 if (context)
4766 {
4767 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4768 bool isCallValid = (context->skipValidation() || ValidateTexCoord4f(context, s, t, r, q));
4769 if (isCallValid)
4770 {
4771 context->texCoord4f(s, t, r, q);
4772 }
4773 ANGLE_CAPTURE(TexCoord4f, isCallValid, context, s, t, r, q);
4774 }
4775 }
4776
TexCoord4fv(const GLfloat * v)4777 void GL_APIENTRY TexCoord4fv(const GLfloat *v)
4778 {
4779 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4780
4781 Context *context = GetValidGlobalContext();
4782 if (context)
4783 {
4784 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4785 bool isCallValid = (context->skipValidation() || ValidateTexCoord4fv(context, v));
4786 if (isCallValid)
4787 {
4788 context->texCoord4fv(v);
4789 }
4790 ANGLE_CAPTURE(TexCoord4fv, isCallValid, context, v);
4791 }
4792 }
4793
TexCoord4i(GLint s,GLint t,GLint r,GLint q)4794 void GL_APIENTRY TexCoord4i(GLint s, GLint t, GLint r, GLint q)
4795 {
4796 EVENT("(GLint s = %d, GLint t = %d, GLint r = %d, GLint q = %d)", s, t, r, q);
4797
4798 Context *context = GetValidGlobalContext();
4799 if (context)
4800 {
4801 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4802 bool isCallValid = (context->skipValidation() || ValidateTexCoord4i(context, s, t, r, q));
4803 if (isCallValid)
4804 {
4805 context->texCoord4i(s, t, r, q);
4806 }
4807 ANGLE_CAPTURE(TexCoord4i, isCallValid, context, s, t, r, q);
4808 }
4809 }
4810
TexCoord4iv(const GLint * v)4811 void GL_APIENTRY TexCoord4iv(const GLint *v)
4812 {
4813 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4814
4815 Context *context = GetValidGlobalContext();
4816 if (context)
4817 {
4818 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4819 bool isCallValid = (context->skipValidation() || ValidateTexCoord4iv(context, v));
4820 if (isCallValid)
4821 {
4822 context->texCoord4iv(v);
4823 }
4824 ANGLE_CAPTURE(TexCoord4iv, isCallValid, context, v);
4825 }
4826 }
4827
TexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q)4828 void GL_APIENTRY TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
4829 {
4830 EVENT("(GLshort s = %d, GLshort t = %d, GLshort r = %d, GLshort q = %d)", s, t, r, q);
4831
4832 Context *context = GetValidGlobalContext();
4833 if (context)
4834 {
4835 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4836 bool isCallValid = (context->skipValidation() || ValidateTexCoord4s(context, s, t, r, q));
4837 if (isCallValid)
4838 {
4839 context->texCoord4s(s, t, r, q);
4840 }
4841 ANGLE_CAPTURE(TexCoord4s, isCallValid, context, s, t, r, q);
4842 }
4843 }
4844
TexCoord4sv(const GLshort * v)4845 void GL_APIENTRY TexCoord4sv(const GLshort *v)
4846 {
4847 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
4848
4849 Context *context = GetValidGlobalContext();
4850 if (context)
4851 {
4852 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4853 bool isCallValid = (context->skipValidation() || ValidateTexCoord4sv(context, v));
4854 if (isCallValid)
4855 {
4856 context->texCoord4sv(v);
4857 }
4858 ANGLE_CAPTURE(TexCoord4sv, isCallValid, context, v);
4859 }
4860 }
4861
TexEnvf(GLenum target,GLenum pname,GLfloat param)4862 void GL_APIENTRY TexEnvf(GLenum target, GLenum pname, GLfloat param)
4863 {
4864 EVENT("(GLenum target = %s, GLenum pname = %s, GLfloat param = %f)",
4865 GLenumToString(GLenumGroup::TextureEnvTarget, target),
4866 GLenumToString(GLenumGroup::TextureEnvParameter, pname), param);
4867
4868 Context *context = GetValidGlobalContext();
4869 if (context)
4870 {
4871 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
4872 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
4873 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4874 bool isCallValid = (context->skipValidation() ||
4875 ValidateTexEnvf(context, targetPacked, pnamePacked, param));
4876 if (isCallValid)
4877 {
4878 context->texEnvf(targetPacked, pnamePacked, param);
4879 }
4880 ANGLE_CAPTURE(TexEnvf, isCallValid, context, targetPacked, pnamePacked, param);
4881 }
4882 }
4883
TexEnvfv(GLenum target,GLenum pname,const GLfloat * params)4884 void GL_APIENTRY TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
4885 {
4886 EVENT("(GLenum target = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
4887 GLenumToString(GLenumGroup::TextureEnvTarget, target),
4888 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
4889
4890 Context *context = GetValidGlobalContext();
4891 if (context)
4892 {
4893 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
4894 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
4895 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4896 bool isCallValid = (context->skipValidation() ||
4897 ValidateTexEnvfv(context, targetPacked, pnamePacked, params));
4898 if (isCallValid)
4899 {
4900 context->texEnvfv(targetPacked, pnamePacked, params);
4901 }
4902 ANGLE_CAPTURE(TexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
4903 }
4904 }
4905
TexEnvi(GLenum target,GLenum pname,GLint param)4906 void GL_APIENTRY TexEnvi(GLenum target, GLenum pname, GLint param)
4907 {
4908 EVENT("(GLenum target = %s, GLenum pname = %s, GLint param = %d)",
4909 GLenumToString(GLenumGroup::TextureEnvTarget, target),
4910 GLenumToString(GLenumGroup::TextureEnvParameter, pname), param);
4911
4912 Context *context = GetValidGlobalContext();
4913 if (context)
4914 {
4915 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
4916 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
4917 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4918 bool isCallValid = (context->skipValidation() ||
4919 ValidateTexEnvi(context, targetPacked, pnamePacked, param));
4920 if (isCallValid)
4921 {
4922 context->texEnvi(targetPacked, pnamePacked, param);
4923 }
4924 ANGLE_CAPTURE(TexEnvi, isCallValid, context, targetPacked, pnamePacked, param);
4925 }
4926 }
4927
TexEnviv(GLenum target,GLenum pname,const GLint * params)4928 void GL_APIENTRY TexEnviv(GLenum target, GLenum pname, const GLint *params)
4929 {
4930 EVENT("(GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
4931 GLenumToString(GLenumGroup::TextureEnvTarget, target),
4932 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
4933
4934 Context *context = GetValidGlobalContext();
4935 if (context)
4936 {
4937 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
4938 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
4939 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4940 bool isCallValid = (context->skipValidation() ||
4941 ValidateTexEnviv(context, targetPacked, pnamePacked, params));
4942 if (isCallValid)
4943 {
4944 context->texEnviv(targetPacked, pnamePacked, params);
4945 }
4946 ANGLE_CAPTURE(TexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
4947 }
4948 }
4949
TexGend(GLenum coord,GLenum pname,GLdouble param)4950 void GL_APIENTRY TexGend(GLenum coord, GLenum pname, GLdouble param)
4951 {
4952 EVENT("(GLenum coord = %s, GLenum pname = %s, GLdouble param = %f)",
4953 GLenumToString(GLenumGroup::TextureCoordName, coord),
4954 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
4955
4956 Context *context = GetValidGlobalContext();
4957 if (context)
4958 {
4959 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4960 bool isCallValid =
4961 (context->skipValidation() || ValidateTexGend(context, coord, pname, param));
4962 if (isCallValid)
4963 {
4964 context->texGend(coord, pname, param);
4965 }
4966 ANGLE_CAPTURE(TexGend, isCallValid, context, coord, pname, param);
4967 }
4968 }
4969
TexGendv(GLenum coord,GLenum pname,const GLdouble * params)4970 void GL_APIENTRY TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
4971 {
4972 EVENT("(GLenum coord = %s, GLenum pname = %s, const GLdouble *params = 0x%016" PRIxPTR ")",
4973 GLenumToString(GLenumGroup::TextureCoordName, coord),
4974 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
4975
4976 Context *context = GetValidGlobalContext();
4977 if (context)
4978 {
4979 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
4980 bool isCallValid =
4981 (context->skipValidation() || ValidateTexGendv(context, coord, pname, params));
4982 if (isCallValid)
4983 {
4984 context->texGendv(coord, pname, params);
4985 }
4986 ANGLE_CAPTURE(TexGendv, isCallValid, context, coord, pname, params);
4987 }
4988 }
4989
TexGenf(GLenum coord,GLenum pname,GLfloat param)4990 void GL_APIENTRY TexGenf(GLenum coord, GLenum pname, GLfloat param)
4991 {
4992 EVENT("(GLenum coord = %s, GLenum pname = %s, GLfloat param = %f)",
4993 GLenumToString(GLenumGroup::TextureCoordName, coord),
4994 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
4995
4996 Context *context = GetValidGlobalContext();
4997 if (context)
4998 {
4999 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5000 bool isCallValid =
5001 (context->skipValidation() || ValidateTexGenf(context, coord, pname, param));
5002 if (isCallValid)
5003 {
5004 context->texGenf(coord, pname, param);
5005 }
5006 ANGLE_CAPTURE(TexGenf, isCallValid, context, coord, pname, param);
5007 }
5008 }
5009
TexGenfv(GLenum coord,GLenum pname,const GLfloat * params)5010 void GL_APIENTRY TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
5011 {
5012 EVENT("(GLenum coord = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
5013 GLenumToString(GLenumGroup::TextureCoordName, coord),
5014 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
5015
5016 Context *context = GetValidGlobalContext();
5017 if (context)
5018 {
5019 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5020 bool isCallValid =
5021 (context->skipValidation() || ValidateTexGenfv(context, coord, pname, params));
5022 if (isCallValid)
5023 {
5024 context->texGenfv(coord, pname, params);
5025 }
5026 ANGLE_CAPTURE(TexGenfv, isCallValid, context, coord, pname, params);
5027 }
5028 }
5029
TexGeni(GLenum coord,GLenum pname,GLint param)5030 void GL_APIENTRY TexGeni(GLenum coord, GLenum pname, GLint param)
5031 {
5032 EVENT("(GLenum coord = %s, GLenum pname = %s, GLint param = %d)",
5033 GLenumToString(GLenumGroup::TextureCoordName, coord),
5034 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
5035
5036 Context *context = GetValidGlobalContext();
5037 if (context)
5038 {
5039 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5040 bool isCallValid =
5041 (context->skipValidation() || ValidateTexGeni(context, coord, pname, param));
5042 if (isCallValid)
5043 {
5044 context->texGeni(coord, pname, param);
5045 }
5046 ANGLE_CAPTURE(TexGeni, isCallValid, context, coord, pname, param);
5047 }
5048 }
5049
TexGeniv(GLenum coord,GLenum pname,const GLint * params)5050 void GL_APIENTRY TexGeniv(GLenum coord, GLenum pname, const GLint *params)
5051 {
5052 EVENT("(GLenum coord = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
5053 GLenumToString(GLenumGroup::TextureCoordName, coord),
5054 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
5055
5056 Context *context = GetValidGlobalContext();
5057 if (context)
5058 {
5059 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5060 bool isCallValid =
5061 (context->skipValidation() || ValidateTexGeniv(context, coord, pname, params));
5062 if (isCallValid)
5063 {
5064 context->texGeniv(coord, pname, params);
5065 }
5066 ANGLE_CAPTURE(TexGeniv, isCallValid, context, coord, pname, params);
5067 }
5068 }
5069
TexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void * pixels)5070 void GL_APIENTRY TexImage1D(GLenum target,
5071 GLint level,
5072 GLint internalformat,
5073 GLsizei width,
5074 GLint border,
5075 GLenum format,
5076 GLenum type,
5077 const void *pixels)
5078 {
5079 EVENT(
5080 "(GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
5081 "GLint border = %d, GLenum format = %s, GLenum type = %s, const void *pixels = "
5082 "0x%016" PRIxPTR ")",
5083 GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, width, border,
5084 GLenumToString(GLenumGroup::PixelFormat, format),
5085 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
5086
5087 Context *context = GetValidGlobalContext();
5088 if (context)
5089 {
5090 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5091 bool isCallValid =
5092 (context->skipValidation() || ValidateTexImage1D(context, target, level, internalformat,
5093 width, border, format, type, pixels));
5094 if (isCallValid)
5095 {
5096 context->texImage1D(target, level, internalformat, width, border, format, type, pixels);
5097 }
5098 ANGLE_CAPTURE(TexImage1D, isCallValid, context, target, level, internalformat, width,
5099 border, format, type, pixels);
5100 }
5101 }
5102
TexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void * pixels)5103 void GL_APIENTRY TexImage2D(GLenum target,
5104 GLint level,
5105 GLint internalformat,
5106 GLsizei width,
5107 GLsizei height,
5108 GLint border,
5109 GLenum format,
5110 GLenum type,
5111 const void *pixels)
5112 {
5113 EVENT(
5114 "(GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
5115 "GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = %s, const void "
5116 "*pixels = 0x%016" PRIxPTR ")",
5117 GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, width, height,
5118 border, GLenumToString(GLenumGroup::PixelFormat, format),
5119 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
5120
5121 Context *context = GetValidGlobalContext();
5122 if (context)
5123 {
5124 TextureTarget targetPacked = FromGL<TextureTarget>(target);
5125 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5126 bool isCallValid = (context->skipValidation() ||
5127 ValidateTexImage2D(context, targetPacked, level, internalformat, width,
5128 height, border, format, type, pixels));
5129 if (isCallValid)
5130 {
5131 context->texImage2D(targetPacked, level, internalformat, width, height, border, format,
5132 type, pixels);
5133 }
5134 ANGLE_CAPTURE(TexImage2D, isCallValid, context, targetPacked, level, internalformat, width,
5135 height, border, format, type, pixels);
5136 }
5137 }
5138
TexParameterf(GLenum target,GLenum pname,GLfloat param)5139 void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param)
5140 {
5141 EVENT("(GLenum target = %s, GLenum pname = %s, GLfloat param = %f)",
5142 GLenumToString(GLenumGroup::TextureTarget, target),
5143 GLenumToString(GLenumGroup::TextureParameterName, pname), param);
5144
5145 Context *context = GetValidGlobalContext();
5146 if (context)
5147 {
5148 TextureType targetPacked = FromGL<TextureType>(target);
5149 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5150 bool isCallValid = (context->skipValidation() ||
5151 ValidateTexParameterf(context, targetPacked, pname, param));
5152 if (isCallValid)
5153 {
5154 context->texParameterf(targetPacked, pname, param);
5155 }
5156 ANGLE_CAPTURE(TexParameterf, isCallValid, context, targetPacked, pname, param);
5157 }
5158 }
5159
TexParameterfv(GLenum target,GLenum pname,const GLfloat * params)5160 void GL_APIENTRY TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
5161 {
5162 EVENT("(GLenum target = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR ")",
5163 GLenumToString(GLenumGroup::TextureTarget, target),
5164 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
5165
5166 Context *context = GetValidGlobalContext();
5167 if (context)
5168 {
5169 TextureType targetPacked = FromGL<TextureType>(target);
5170 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5171 bool isCallValid = (context->skipValidation() ||
5172 ValidateTexParameterfv(context, targetPacked, pname, params));
5173 if (isCallValid)
5174 {
5175 context->texParameterfv(targetPacked, pname, params);
5176 }
5177 ANGLE_CAPTURE(TexParameterfv, isCallValid, context, targetPacked, pname, params);
5178 }
5179 }
5180
TexParameteri(GLenum target,GLenum pname,GLint param)5181 void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param)
5182 {
5183 EVENT("(GLenum target = %s, GLenum pname = %s, GLint param = %d)",
5184 GLenumToString(GLenumGroup::TextureTarget, target),
5185 GLenumToString(GLenumGroup::TextureParameterName, pname), param);
5186
5187 Context *context = GetValidGlobalContext();
5188 if (context)
5189 {
5190 TextureType targetPacked = FromGL<TextureType>(target);
5191 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5192 bool isCallValid = (context->skipValidation() ||
5193 ValidateTexParameteri(context, targetPacked, pname, param));
5194 if (isCallValid)
5195 {
5196 context->texParameteri(targetPacked, pname, param);
5197 }
5198 ANGLE_CAPTURE(TexParameteri, isCallValid, context, targetPacked, pname, param);
5199 }
5200 }
5201
TexParameteriv(GLenum target,GLenum pname,const GLint * params)5202 void GL_APIENTRY TexParameteriv(GLenum target, GLenum pname, const GLint *params)
5203 {
5204 EVENT("(GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR ")",
5205 GLenumToString(GLenumGroup::TextureTarget, target),
5206 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
5207
5208 Context *context = GetValidGlobalContext();
5209 if (context)
5210 {
5211 TextureType targetPacked = FromGL<TextureType>(target);
5212 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5213 bool isCallValid = (context->skipValidation() ||
5214 ValidateTexParameteriv(context, targetPacked, pname, params));
5215 if (isCallValid)
5216 {
5217 context->texParameteriv(targetPacked, pname, params);
5218 }
5219 ANGLE_CAPTURE(TexParameteriv, isCallValid, context, targetPacked, pname, params);
5220 }
5221 }
5222
Translated(GLdouble x,GLdouble y,GLdouble z)5223 void GL_APIENTRY Translated(GLdouble x, GLdouble y, GLdouble z)
5224 {
5225 EVENT("(GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", x, y, z);
5226
5227 Context *context = GetValidGlobalContext();
5228 if (context)
5229 {
5230 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5231 bool isCallValid = (context->skipValidation() || ValidateTranslated(context, x, y, z));
5232 if (isCallValid)
5233 {
5234 context->translated(x, y, z);
5235 }
5236 ANGLE_CAPTURE(Translated, isCallValid, context, x, y, z);
5237 }
5238 }
5239
Translatef(GLfloat x,GLfloat y,GLfloat z)5240 void GL_APIENTRY Translatef(GLfloat x, GLfloat y, GLfloat z)
5241 {
5242 EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
5243
5244 Context *context = GetValidGlobalContext();
5245 if (context)
5246 {
5247 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5248 bool isCallValid = (context->skipValidation() || ValidateTranslatef(context, x, y, z));
5249 if (isCallValid)
5250 {
5251 context->translatef(x, y, z);
5252 }
5253 ANGLE_CAPTURE(Translatef, isCallValid, context, x, y, z);
5254 }
5255 }
5256
Vertex2d(GLdouble x,GLdouble y)5257 void GL_APIENTRY Vertex2d(GLdouble x, GLdouble y)
5258 {
5259 EVENT("(GLdouble x = %f, GLdouble y = %f)", x, y);
5260
5261 Context *context = GetValidGlobalContext();
5262 if (context)
5263 {
5264 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5265 bool isCallValid = (context->skipValidation() || ValidateVertex2d(context, x, y));
5266 if (isCallValid)
5267 {
5268 context->vertex2d(x, y);
5269 }
5270 ANGLE_CAPTURE(Vertex2d, isCallValid, context, x, y);
5271 }
5272 }
5273
Vertex2dv(const GLdouble * v)5274 void GL_APIENTRY Vertex2dv(const GLdouble *v)
5275 {
5276 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5277
5278 Context *context = GetValidGlobalContext();
5279 if (context)
5280 {
5281 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5282 bool isCallValid = (context->skipValidation() || ValidateVertex2dv(context, v));
5283 if (isCallValid)
5284 {
5285 context->vertex2dv(v);
5286 }
5287 ANGLE_CAPTURE(Vertex2dv, isCallValid, context, v);
5288 }
5289 }
5290
Vertex2f(GLfloat x,GLfloat y)5291 void GL_APIENTRY Vertex2f(GLfloat x, GLfloat y)
5292 {
5293 EVENT("(GLfloat x = %f, GLfloat y = %f)", x, y);
5294
5295 Context *context = GetValidGlobalContext();
5296 if (context)
5297 {
5298 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5299 bool isCallValid = (context->skipValidation() || ValidateVertex2f(context, x, y));
5300 if (isCallValid)
5301 {
5302 context->vertex2f(x, y);
5303 }
5304 ANGLE_CAPTURE(Vertex2f, isCallValid, context, x, y);
5305 }
5306 }
5307
Vertex2fv(const GLfloat * v)5308 void GL_APIENTRY Vertex2fv(const GLfloat *v)
5309 {
5310 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5311
5312 Context *context = GetValidGlobalContext();
5313 if (context)
5314 {
5315 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5316 bool isCallValid = (context->skipValidation() || ValidateVertex2fv(context, v));
5317 if (isCallValid)
5318 {
5319 context->vertex2fv(v);
5320 }
5321 ANGLE_CAPTURE(Vertex2fv, isCallValid, context, v);
5322 }
5323 }
5324
Vertex2i(GLint x,GLint y)5325 void GL_APIENTRY Vertex2i(GLint x, GLint y)
5326 {
5327 EVENT("(GLint x = %d, GLint y = %d)", x, y);
5328
5329 Context *context = GetValidGlobalContext();
5330 if (context)
5331 {
5332 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5333 bool isCallValid = (context->skipValidation() || ValidateVertex2i(context, x, y));
5334 if (isCallValid)
5335 {
5336 context->vertex2i(x, y);
5337 }
5338 ANGLE_CAPTURE(Vertex2i, isCallValid, context, x, y);
5339 }
5340 }
5341
Vertex2iv(const GLint * v)5342 void GL_APIENTRY Vertex2iv(const GLint *v)
5343 {
5344 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5345
5346 Context *context = GetValidGlobalContext();
5347 if (context)
5348 {
5349 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5350 bool isCallValid = (context->skipValidation() || ValidateVertex2iv(context, v));
5351 if (isCallValid)
5352 {
5353 context->vertex2iv(v);
5354 }
5355 ANGLE_CAPTURE(Vertex2iv, isCallValid, context, v);
5356 }
5357 }
5358
Vertex2s(GLshort x,GLshort y)5359 void GL_APIENTRY Vertex2s(GLshort x, GLshort y)
5360 {
5361 EVENT("(GLshort x = %d, GLshort y = %d)", x, y);
5362
5363 Context *context = GetValidGlobalContext();
5364 if (context)
5365 {
5366 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5367 bool isCallValid = (context->skipValidation() || ValidateVertex2s(context, x, y));
5368 if (isCallValid)
5369 {
5370 context->vertex2s(x, y);
5371 }
5372 ANGLE_CAPTURE(Vertex2s, isCallValid, context, x, y);
5373 }
5374 }
5375
Vertex2sv(const GLshort * v)5376 void GL_APIENTRY Vertex2sv(const GLshort *v)
5377 {
5378 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5379
5380 Context *context = GetValidGlobalContext();
5381 if (context)
5382 {
5383 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5384 bool isCallValid = (context->skipValidation() || ValidateVertex2sv(context, v));
5385 if (isCallValid)
5386 {
5387 context->vertex2sv(v);
5388 }
5389 ANGLE_CAPTURE(Vertex2sv, isCallValid, context, v);
5390 }
5391 }
5392
Vertex3d(GLdouble x,GLdouble y,GLdouble z)5393 void GL_APIENTRY Vertex3d(GLdouble x, GLdouble y, GLdouble z)
5394 {
5395 EVENT("(GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", x, y, z);
5396
5397 Context *context = GetValidGlobalContext();
5398 if (context)
5399 {
5400 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5401 bool isCallValid = (context->skipValidation() || ValidateVertex3d(context, x, y, z));
5402 if (isCallValid)
5403 {
5404 context->vertex3d(x, y, z);
5405 }
5406 ANGLE_CAPTURE(Vertex3d, isCallValid, context, x, y, z);
5407 }
5408 }
5409
Vertex3dv(const GLdouble * v)5410 void GL_APIENTRY Vertex3dv(const GLdouble *v)
5411 {
5412 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5413
5414 Context *context = GetValidGlobalContext();
5415 if (context)
5416 {
5417 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5418 bool isCallValid = (context->skipValidation() || ValidateVertex3dv(context, v));
5419 if (isCallValid)
5420 {
5421 context->vertex3dv(v);
5422 }
5423 ANGLE_CAPTURE(Vertex3dv, isCallValid, context, v);
5424 }
5425 }
5426
Vertex3f(GLfloat x,GLfloat y,GLfloat z)5427 void GL_APIENTRY Vertex3f(GLfloat x, GLfloat y, GLfloat z)
5428 {
5429 EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
5430
5431 Context *context = GetValidGlobalContext();
5432 if (context)
5433 {
5434 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5435 bool isCallValid = (context->skipValidation() || ValidateVertex3f(context, x, y, z));
5436 if (isCallValid)
5437 {
5438 context->vertex3f(x, y, z);
5439 }
5440 ANGLE_CAPTURE(Vertex3f, isCallValid, context, x, y, z);
5441 }
5442 }
5443
Vertex3fv(const GLfloat * v)5444 void GL_APIENTRY Vertex3fv(const GLfloat *v)
5445 {
5446 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5447
5448 Context *context = GetValidGlobalContext();
5449 if (context)
5450 {
5451 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5452 bool isCallValid = (context->skipValidation() || ValidateVertex3fv(context, v));
5453 if (isCallValid)
5454 {
5455 context->vertex3fv(v);
5456 }
5457 ANGLE_CAPTURE(Vertex3fv, isCallValid, context, v);
5458 }
5459 }
5460
Vertex3i(GLint x,GLint y,GLint z)5461 void GL_APIENTRY Vertex3i(GLint x, GLint y, GLint z)
5462 {
5463 EVENT("(GLint x = %d, GLint y = %d, GLint z = %d)", x, y, z);
5464
5465 Context *context = GetValidGlobalContext();
5466 if (context)
5467 {
5468 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5469 bool isCallValid = (context->skipValidation() || ValidateVertex3i(context, x, y, z));
5470 if (isCallValid)
5471 {
5472 context->vertex3i(x, y, z);
5473 }
5474 ANGLE_CAPTURE(Vertex3i, isCallValid, context, x, y, z);
5475 }
5476 }
5477
Vertex3iv(const GLint * v)5478 void GL_APIENTRY Vertex3iv(const GLint *v)
5479 {
5480 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5481
5482 Context *context = GetValidGlobalContext();
5483 if (context)
5484 {
5485 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5486 bool isCallValid = (context->skipValidation() || ValidateVertex3iv(context, v));
5487 if (isCallValid)
5488 {
5489 context->vertex3iv(v);
5490 }
5491 ANGLE_CAPTURE(Vertex3iv, isCallValid, context, v);
5492 }
5493 }
5494
Vertex3s(GLshort x,GLshort y,GLshort z)5495 void GL_APIENTRY Vertex3s(GLshort x, GLshort y, GLshort z)
5496 {
5497 EVENT("(GLshort x = %d, GLshort y = %d, GLshort z = %d)", x, y, z);
5498
5499 Context *context = GetValidGlobalContext();
5500 if (context)
5501 {
5502 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5503 bool isCallValid = (context->skipValidation() || ValidateVertex3s(context, x, y, z));
5504 if (isCallValid)
5505 {
5506 context->vertex3s(x, y, z);
5507 }
5508 ANGLE_CAPTURE(Vertex3s, isCallValid, context, x, y, z);
5509 }
5510 }
5511
Vertex3sv(const GLshort * v)5512 void GL_APIENTRY Vertex3sv(const GLshort *v)
5513 {
5514 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5515
5516 Context *context = GetValidGlobalContext();
5517 if (context)
5518 {
5519 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5520 bool isCallValid = (context->skipValidation() || ValidateVertex3sv(context, v));
5521 if (isCallValid)
5522 {
5523 context->vertex3sv(v);
5524 }
5525 ANGLE_CAPTURE(Vertex3sv, isCallValid, context, v);
5526 }
5527 }
5528
Vertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)5529 void GL_APIENTRY Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
5530 {
5531 EVENT("(GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, GLdouble w = %f)", x, y, z, w);
5532
5533 Context *context = GetValidGlobalContext();
5534 if (context)
5535 {
5536 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5537 bool isCallValid = (context->skipValidation() || ValidateVertex4d(context, x, y, z, w));
5538 if (isCallValid)
5539 {
5540 context->vertex4d(x, y, z, w);
5541 }
5542 ANGLE_CAPTURE(Vertex4d, isCallValid, context, x, y, z, w);
5543 }
5544 }
5545
Vertex4dv(const GLdouble * v)5546 void GL_APIENTRY Vertex4dv(const GLdouble *v)
5547 {
5548 EVENT("(const GLdouble *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5549
5550 Context *context = GetValidGlobalContext();
5551 if (context)
5552 {
5553 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5554 bool isCallValid = (context->skipValidation() || ValidateVertex4dv(context, v));
5555 if (isCallValid)
5556 {
5557 context->vertex4dv(v);
5558 }
5559 ANGLE_CAPTURE(Vertex4dv, isCallValid, context, v);
5560 }
5561 }
5562
Vertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)5563 void GL_APIENTRY Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5564 {
5565 EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", x, y, z, w);
5566
5567 Context *context = GetValidGlobalContext();
5568 if (context)
5569 {
5570 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5571 bool isCallValid = (context->skipValidation() || ValidateVertex4f(context, x, y, z, w));
5572 if (isCallValid)
5573 {
5574 context->vertex4f(x, y, z, w);
5575 }
5576 ANGLE_CAPTURE(Vertex4f, isCallValid, context, x, y, z, w);
5577 }
5578 }
5579
Vertex4fv(const GLfloat * v)5580 void GL_APIENTRY Vertex4fv(const GLfloat *v)
5581 {
5582 EVENT("(const GLfloat *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5583
5584 Context *context = GetValidGlobalContext();
5585 if (context)
5586 {
5587 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5588 bool isCallValid = (context->skipValidation() || ValidateVertex4fv(context, v));
5589 if (isCallValid)
5590 {
5591 context->vertex4fv(v);
5592 }
5593 ANGLE_CAPTURE(Vertex4fv, isCallValid, context, v);
5594 }
5595 }
5596
Vertex4i(GLint x,GLint y,GLint z,GLint w)5597 void GL_APIENTRY Vertex4i(GLint x, GLint y, GLint z, GLint w)
5598 {
5599 EVENT("(GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)", x, y, z, w);
5600
5601 Context *context = GetValidGlobalContext();
5602 if (context)
5603 {
5604 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5605 bool isCallValid = (context->skipValidation() || ValidateVertex4i(context, x, y, z, w));
5606 if (isCallValid)
5607 {
5608 context->vertex4i(x, y, z, w);
5609 }
5610 ANGLE_CAPTURE(Vertex4i, isCallValid, context, x, y, z, w);
5611 }
5612 }
5613
Vertex4iv(const GLint * v)5614 void GL_APIENTRY Vertex4iv(const GLint *v)
5615 {
5616 EVENT("(const GLint *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5617
5618 Context *context = GetValidGlobalContext();
5619 if (context)
5620 {
5621 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5622 bool isCallValid = (context->skipValidation() || ValidateVertex4iv(context, v));
5623 if (isCallValid)
5624 {
5625 context->vertex4iv(v);
5626 }
5627 ANGLE_CAPTURE(Vertex4iv, isCallValid, context, v);
5628 }
5629 }
5630
Vertex4s(GLshort x,GLshort y,GLshort z,GLshort w)5631 void GL_APIENTRY Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
5632 {
5633 EVENT("(GLshort x = %d, GLshort y = %d, GLshort z = %d, GLshort w = %d)", x, y, z, w);
5634
5635 Context *context = GetValidGlobalContext();
5636 if (context)
5637 {
5638 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5639 bool isCallValid = (context->skipValidation() || ValidateVertex4s(context, x, y, z, w));
5640 if (isCallValid)
5641 {
5642 context->vertex4s(x, y, z, w);
5643 }
5644 ANGLE_CAPTURE(Vertex4s, isCallValid, context, x, y, z, w);
5645 }
5646 }
5647
Vertex4sv(const GLshort * v)5648 void GL_APIENTRY Vertex4sv(const GLshort *v)
5649 {
5650 EVENT("(const GLshort *v = 0x%016" PRIxPTR ")", (uintptr_t)v);
5651
5652 Context *context = GetValidGlobalContext();
5653 if (context)
5654 {
5655 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5656 bool isCallValid = (context->skipValidation() || ValidateVertex4sv(context, v));
5657 if (isCallValid)
5658 {
5659 context->vertex4sv(v);
5660 }
5661 ANGLE_CAPTURE(Vertex4sv, isCallValid, context, v);
5662 }
5663 }
5664
Viewport(GLint x,GLint y,GLsizei width,GLsizei height)5665 void GL_APIENTRY Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
5666 {
5667 EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width,
5668 height);
5669
5670 Context *context = GetValidGlobalContext();
5671 if (context)
5672 {
5673 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
5674 bool isCallValid =
5675 (context->skipValidation() || ValidateViewport(context, x, y, width, height));
5676 if (isCallValid)
5677 {
5678 context->viewport(x, y, width, height);
5679 }
5680 ANGLE_CAPTURE(Viewport, isCallValid, context, x, y, width, height);
5681 }
5682 }
5683 } // namespace gl
5684