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