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_autogen.cpp:
9 // Defines the Desktop GL 1.x entry points.
10
11 #include "libGLESv2/entry_points_gl_1_autogen.h"
12
13 #include "common/gl_enum_utils.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/Context.inl.h"
16 #include "libANGLE/capture/capture_gl_1_autogen.h"
17 #include "libANGLE/context_private_call_gl_autogen.h"
18 #include "libANGLE/context_private_call_gles_autogen.h"
19 #include "libANGLE/entry_points_utils.h"
20 #include "libANGLE/validationEGL.h"
21 #include "libANGLE/validationES.h"
22 #include "libANGLE/validationES1.h"
23 #include "libANGLE/validationES2.h"
24 #include "libANGLE/validationES3.h"
25 #include "libANGLE/validationES31.h"
26 #include "libANGLE/validationES32.h"
27 #include "libANGLE/validationESEXT.h"
28 #include "libANGLE/validationGL1_autogen.h"
29 #include "libGLESv2/global_state.h"
30
31 using namespace gl;
32
33 extern "C" {
34
35 // GL 1.0
GL_Accum(GLenum op,GLfloat value)36 void GL_APIENTRY GL_Accum(GLenum op, GLfloat value)
37 {
38 Context *context = GetValidGlobalContext();
39 EVENT(context, GLAccum, "context = %d, op = %s, value = %f", CID(context),
40 GLenumToString(BigGLEnum::AccumOp, op), value);
41
42 if (context)
43 {
44 SCOPED_SHARE_CONTEXT_LOCK(context);
45 bool isCallValid =
46 (context->skipValidation() ||
47 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
48 context->getMutableErrorSetForValidation(),
49 angle::EntryPoint::GLAccum) &&
50 ValidateAccum(context, angle::EntryPoint::GLAccum, op, value)));
51 if (isCallValid)
52 {
53 context->accum(op, value);
54 }
55 ANGLE_CAPTURE_GL(Accum, isCallValid, context, op, value);
56 }
57 else
58 {
59 GenerateContextLostErrorOnCurrentGlobalContext();
60 }
61 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
62 }
63
GL_Begin(GLenum mode)64 void GL_APIENTRY GL_Begin(GLenum mode)
65 {
66 Context *context = GetValidGlobalContext();
67 EVENT(context, GLBegin, "context = %d, mode = %s", CID(context),
68 GLenumToString(BigGLEnum::PrimitiveType, mode));
69
70 if (context)
71 {
72 SCOPED_SHARE_CONTEXT_LOCK(context);
73 bool isCallValid =
74 (context->skipValidation() ||
75 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
76 context->getMutableErrorSetForValidation(),
77 angle::EntryPoint::GLBegin) &&
78 ValidateBegin(context, angle::EntryPoint::GLBegin, mode)));
79 if (isCallValid)
80 {
81 context->begin(mode);
82 }
83 ANGLE_CAPTURE_GL(Begin, isCallValid, context, mode);
84 }
85 else
86 {
87 GenerateContextLostErrorOnCurrentGlobalContext();
88 }
89 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
90 }
91
GL_Bitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte * bitmap)92 void GL_APIENTRY GL_Bitmap(GLsizei width,
93 GLsizei height,
94 GLfloat xorig,
95 GLfloat yorig,
96 GLfloat xmove,
97 GLfloat ymove,
98 const GLubyte *bitmap)
99 {
100 Context *context = GetValidGlobalContext();
101 EVENT(context, GLBitmap,
102 "context = %d, width = %d, height = %d, xorig = %f, yorig = %f, xmove = %f, ymove = %f, "
103 "bitmap = 0x%016" PRIxPTR "",
104 CID(context), width, height, xorig, yorig, xmove, ymove, (uintptr_t)bitmap);
105
106 if (context)
107 {
108 SCOPED_SHARE_CONTEXT_LOCK(context);
109 bool isCallValid =
110 (context->skipValidation() ||
111 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
112 context->getMutableErrorSetForValidation(),
113 angle::EntryPoint::GLBitmap) &&
114 ValidateBitmap(context, angle::EntryPoint::GLBitmap, width, height, xorig, yorig,
115 xmove, ymove, bitmap)));
116 if (isCallValid)
117 {
118 context->bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
119 }
120 ANGLE_CAPTURE_GL(Bitmap, isCallValid, context, width, height, xorig, yorig, xmove, ymove,
121 bitmap);
122 }
123 else
124 {
125 GenerateContextLostErrorOnCurrentGlobalContext();
126 }
127 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
128 }
129
GL_CallList(GLuint list)130 void GL_APIENTRY GL_CallList(GLuint list)
131 {
132 Context *context = GetValidGlobalContext();
133 EVENT(context, GLCallList, "context = %d, list = %u", CID(context), list);
134
135 if (context)
136 {
137 SCOPED_SHARE_CONTEXT_LOCK(context);
138 bool isCallValid =
139 (context->skipValidation() ||
140 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
141 context->getMutableErrorSetForValidation(),
142 angle::EntryPoint::GLCallList) &&
143 ValidateCallList(context, angle::EntryPoint::GLCallList, list)));
144 if (isCallValid)
145 {
146 context->callList(list);
147 }
148 ANGLE_CAPTURE_GL(CallList, isCallValid, context, list);
149 }
150 else
151 {
152 GenerateContextLostErrorOnCurrentGlobalContext();
153 }
154 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
155 }
156
GL_CallLists(GLsizei n,GLenum type,const void * lists)157 void GL_APIENTRY GL_CallLists(GLsizei n, GLenum type, const void *lists)
158 {
159 Context *context = GetValidGlobalContext();
160 EVENT(context, GLCallLists, "context = %d, n = %d, type = %s, lists = 0x%016" PRIxPTR "",
161 CID(context), n, GLenumToString(BigGLEnum::ListNameType, type), (uintptr_t)lists);
162
163 if (context)
164 {
165 SCOPED_SHARE_CONTEXT_LOCK(context);
166 bool isCallValid =
167 (context->skipValidation() ||
168 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
169 context->getMutableErrorSetForValidation(),
170 angle::EntryPoint::GLCallLists) &&
171 ValidateCallLists(context, angle::EntryPoint::GLCallLists, n, type, lists)));
172 if (isCallValid)
173 {
174 context->callLists(n, type, lists);
175 }
176 ANGLE_CAPTURE_GL(CallLists, isCallValid, context, n, type, lists);
177 }
178 else
179 {
180 GenerateContextLostErrorOnCurrentGlobalContext();
181 }
182 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
183 }
184
GL_ClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)185 void GL_APIENTRY GL_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
186 {
187 Context *context = GetValidGlobalContext();
188 EVENT(context, GLClearAccum, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
189 CID(context), red, green, blue, alpha);
190
191 if (context)
192 {
193 SCOPED_SHARE_CONTEXT_LOCK(context);
194 bool isCallValid =
195 (context->skipValidation() ||
196 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
197 context->getMutableErrorSetForValidation(),
198 angle::EntryPoint::GLClearAccum) &&
199 ValidateClearAccum(context, angle::EntryPoint::GLClearAccum, red, green, blue,
200 alpha)));
201 if (isCallValid)
202 {
203 context->clearAccum(red, green, blue, alpha);
204 }
205 ANGLE_CAPTURE_GL(ClearAccum, isCallValid, context, red, green, blue, alpha);
206 }
207 else
208 {
209 GenerateContextLostErrorOnCurrentGlobalContext();
210 }
211 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
212 }
213
GL_ClearDepth(GLdouble depth)214 void GL_APIENTRY GL_ClearDepth(GLdouble depth)
215 {
216 Context *context = GetValidGlobalContext();
217 EVENT(context, GLClearDepth, "context = %d, depth = %f", CID(context), depth);
218
219 if (context)
220 {
221 SCOPED_SHARE_CONTEXT_LOCK(context);
222 bool isCallValid =
223 (context->skipValidation() ||
224 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
225 context->getMutableErrorSetForValidation(),
226 angle::EntryPoint::GLClearDepth) &&
227 ValidateClearDepth(context, angle::EntryPoint::GLClearDepth, depth)));
228 if (isCallValid)
229 {
230 context->clearDepth(depth);
231 }
232 ANGLE_CAPTURE_GL(ClearDepth, isCallValid, context, depth);
233 }
234 else
235 {
236 GenerateContextLostErrorOnCurrentGlobalContext();
237 }
238 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
239 }
240
GL_ClearIndex(GLfloat c)241 void GL_APIENTRY GL_ClearIndex(GLfloat c)
242 {
243 Context *context = GetValidGlobalContext();
244 EVENT(context, GLClearIndex, "context = %d, c = %f", CID(context), c);
245
246 if (context)
247 {
248 SCOPED_SHARE_CONTEXT_LOCK(context);
249 bool isCallValid =
250 (context->skipValidation() ||
251 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
252 context->getMutableErrorSetForValidation(),
253 angle::EntryPoint::GLClearIndex) &&
254 ValidateClearIndex(context, angle::EntryPoint::GLClearIndex, c)));
255 if (isCallValid)
256 {
257 context->clearIndex(c);
258 }
259 ANGLE_CAPTURE_GL(ClearIndex, isCallValid, context, c);
260 }
261 else
262 {
263 GenerateContextLostErrorOnCurrentGlobalContext();
264 }
265 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
266 }
267
GL_ClipPlane(GLenum plane,const GLdouble * equation)268 void GL_APIENTRY GL_ClipPlane(GLenum plane, const GLdouble *equation)
269 {
270 Context *context = GetValidGlobalContext();
271 EVENT(context, GLClipPlane, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "",
272 CID(context), GLenumToString(BigGLEnum::ClipPlaneName, plane), (uintptr_t)equation);
273
274 if (context)
275 {
276 SCOPED_SHARE_CONTEXT_LOCK(context);
277 bool isCallValid =
278 (context->skipValidation() ||
279 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
280 context->getMutableErrorSetForValidation(),
281 angle::EntryPoint::GLClipPlane) &&
282 ValidateClipPlane(context, angle::EntryPoint::GLClipPlane, plane, equation)));
283 if (isCallValid)
284 {
285 context->clipPlane(plane, equation);
286 }
287 ANGLE_CAPTURE_GL(ClipPlane, isCallValid, context, plane, equation);
288 }
289 else
290 {
291 GenerateContextLostErrorOnCurrentGlobalContext();
292 }
293 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
294 }
295
GL_Color3b(GLbyte red,GLbyte green,GLbyte blue)296 void GL_APIENTRY GL_Color3b(GLbyte red, GLbyte green, GLbyte blue)
297 {
298 Context *context = GetValidGlobalContext();
299 EVENT(context, GLColor3b, "context = %d, red = %d, green = %d, blue = %d", CID(context), red,
300 green, blue);
301
302 if (context)
303 {
304 SCOPED_SHARE_CONTEXT_LOCK(context);
305 bool isCallValid =
306 (context->skipValidation() ||
307 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
308 context->getMutableErrorSetForValidation(),
309 angle::EntryPoint::GLColor3b) &&
310 ValidateColor3b(context, angle::EntryPoint::GLColor3b, red, green, blue)));
311 if (isCallValid)
312 {
313 context->color3b(red, green, blue);
314 }
315 ANGLE_CAPTURE_GL(Color3b, isCallValid, context, red, green, blue);
316 }
317 else
318 {
319 GenerateContextLostErrorOnCurrentGlobalContext();
320 }
321 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
322 }
323
GL_Color3bv(const GLbyte * v)324 void GL_APIENTRY GL_Color3bv(const GLbyte *v)
325 {
326 Context *context = GetValidGlobalContext();
327 EVENT(context, GLColor3bv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
328
329 if (context)
330 {
331 SCOPED_SHARE_CONTEXT_LOCK(context);
332 bool isCallValid =
333 (context->skipValidation() ||
334 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
335 context->getMutableErrorSetForValidation(),
336 angle::EntryPoint::GLColor3bv) &&
337 ValidateColor3bv(context, angle::EntryPoint::GLColor3bv, v)));
338 if (isCallValid)
339 {
340 context->color3bv(v);
341 }
342 ANGLE_CAPTURE_GL(Color3bv, isCallValid, context, v);
343 }
344 else
345 {
346 GenerateContextLostErrorOnCurrentGlobalContext();
347 }
348 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
349 }
350
GL_Color3d(GLdouble red,GLdouble green,GLdouble blue)351 void GL_APIENTRY GL_Color3d(GLdouble red, GLdouble green, GLdouble blue)
352 {
353 Context *context = GetValidGlobalContext();
354 EVENT(context, GLColor3d, "context = %d, red = %f, green = %f, blue = %f", CID(context), red,
355 green, blue);
356
357 if (context)
358 {
359 SCOPED_SHARE_CONTEXT_LOCK(context);
360 bool isCallValid =
361 (context->skipValidation() ||
362 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
363 context->getMutableErrorSetForValidation(),
364 angle::EntryPoint::GLColor3d) &&
365 ValidateColor3d(context, angle::EntryPoint::GLColor3d, red, green, blue)));
366 if (isCallValid)
367 {
368 context->color3d(red, green, blue);
369 }
370 ANGLE_CAPTURE_GL(Color3d, isCallValid, context, red, green, blue);
371 }
372 else
373 {
374 GenerateContextLostErrorOnCurrentGlobalContext();
375 }
376 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
377 }
378
GL_Color3dv(const GLdouble * v)379 void GL_APIENTRY GL_Color3dv(const GLdouble *v)
380 {
381 Context *context = GetValidGlobalContext();
382 EVENT(context, GLColor3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
383
384 if (context)
385 {
386 SCOPED_SHARE_CONTEXT_LOCK(context);
387 bool isCallValid =
388 (context->skipValidation() ||
389 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
390 context->getMutableErrorSetForValidation(),
391 angle::EntryPoint::GLColor3dv) &&
392 ValidateColor3dv(context, angle::EntryPoint::GLColor3dv, v)));
393 if (isCallValid)
394 {
395 context->color3dv(v);
396 }
397 ANGLE_CAPTURE_GL(Color3dv, isCallValid, context, v);
398 }
399 else
400 {
401 GenerateContextLostErrorOnCurrentGlobalContext();
402 }
403 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
404 }
405
GL_Color3f(GLfloat red,GLfloat green,GLfloat blue)406 void GL_APIENTRY GL_Color3f(GLfloat red, GLfloat green, GLfloat blue)
407 {
408 Context *context = GetValidGlobalContext();
409 EVENT(context, GLColor3f, "context = %d, red = %f, green = %f, blue = %f", CID(context), red,
410 green, blue);
411
412 if (context)
413 {
414 SCOPED_SHARE_CONTEXT_LOCK(context);
415 bool isCallValid =
416 (context->skipValidation() ||
417 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
418 context->getMutableErrorSetForValidation(),
419 angle::EntryPoint::GLColor3f) &&
420 ValidateColor3f(context, angle::EntryPoint::GLColor3f, red, green, blue)));
421 if (isCallValid)
422 {
423 context->color3f(red, green, blue);
424 }
425 ANGLE_CAPTURE_GL(Color3f, isCallValid, context, red, green, blue);
426 }
427 else
428 {
429 GenerateContextLostErrorOnCurrentGlobalContext();
430 }
431 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
432 }
433
GL_Color3fv(const GLfloat * v)434 void GL_APIENTRY GL_Color3fv(const GLfloat *v)
435 {
436 Context *context = GetValidGlobalContext();
437 EVENT(context, GLColor3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
438
439 if (context)
440 {
441 SCOPED_SHARE_CONTEXT_LOCK(context);
442 bool isCallValid =
443 (context->skipValidation() ||
444 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
445 context->getMutableErrorSetForValidation(),
446 angle::EntryPoint::GLColor3fv) &&
447 ValidateColor3fv(context, angle::EntryPoint::GLColor3fv, v)));
448 if (isCallValid)
449 {
450 context->color3fv(v);
451 }
452 ANGLE_CAPTURE_GL(Color3fv, isCallValid, context, v);
453 }
454 else
455 {
456 GenerateContextLostErrorOnCurrentGlobalContext();
457 }
458 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
459 }
460
GL_Color3i(GLint red,GLint green,GLint blue)461 void GL_APIENTRY GL_Color3i(GLint red, GLint green, GLint blue)
462 {
463 Context *context = GetValidGlobalContext();
464 EVENT(context, GLColor3i, "context = %d, red = %d, green = %d, blue = %d", CID(context), red,
465 green, blue);
466
467 if (context)
468 {
469 SCOPED_SHARE_CONTEXT_LOCK(context);
470 bool isCallValid =
471 (context->skipValidation() ||
472 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
473 context->getMutableErrorSetForValidation(),
474 angle::EntryPoint::GLColor3i) &&
475 ValidateColor3i(context, angle::EntryPoint::GLColor3i, red, green, blue)));
476 if (isCallValid)
477 {
478 context->color3i(red, green, blue);
479 }
480 ANGLE_CAPTURE_GL(Color3i, isCallValid, context, red, green, blue);
481 }
482 else
483 {
484 GenerateContextLostErrorOnCurrentGlobalContext();
485 }
486 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
487 }
488
GL_Color3iv(const GLint * v)489 void GL_APIENTRY GL_Color3iv(const GLint *v)
490 {
491 Context *context = GetValidGlobalContext();
492 EVENT(context, GLColor3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
493
494 if (context)
495 {
496 SCOPED_SHARE_CONTEXT_LOCK(context);
497 bool isCallValid =
498 (context->skipValidation() ||
499 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
500 context->getMutableErrorSetForValidation(),
501 angle::EntryPoint::GLColor3iv) &&
502 ValidateColor3iv(context, angle::EntryPoint::GLColor3iv, v)));
503 if (isCallValid)
504 {
505 context->color3iv(v);
506 }
507 ANGLE_CAPTURE_GL(Color3iv, isCallValid, context, v);
508 }
509 else
510 {
511 GenerateContextLostErrorOnCurrentGlobalContext();
512 }
513 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
514 }
515
GL_Color3s(GLshort red,GLshort green,GLshort blue)516 void GL_APIENTRY GL_Color3s(GLshort red, GLshort green, GLshort blue)
517 {
518 Context *context = GetValidGlobalContext();
519 EVENT(context, GLColor3s, "context = %d, red = %d, green = %d, blue = %d", CID(context), red,
520 green, blue);
521
522 if (context)
523 {
524 SCOPED_SHARE_CONTEXT_LOCK(context);
525 bool isCallValid =
526 (context->skipValidation() ||
527 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
528 context->getMutableErrorSetForValidation(),
529 angle::EntryPoint::GLColor3s) &&
530 ValidateColor3s(context, angle::EntryPoint::GLColor3s, red, green, blue)));
531 if (isCallValid)
532 {
533 context->color3s(red, green, blue);
534 }
535 ANGLE_CAPTURE_GL(Color3s, isCallValid, context, red, green, blue);
536 }
537 else
538 {
539 GenerateContextLostErrorOnCurrentGlobalContext();
540 }
541 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
542 }
543
GL_Color3sv(const GLshort * v)544 void GL_APIENTRY GL_Color3sv(const GLshort *v)
545 {
546 Context *context = GetValidGlobalContext();
547 EVENT(context, GLColor3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
548
549 if (context)
550 {
551 SCOPED_SHARE_CONTEXT_LOCK(context);
552 bool isCallValid =
553 (context->skipValidation() ||
554 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
555 context->getMutableErrorSetForValidation(),
556 angle::EntryPoint::GLColor3sv) &&
557 ValidateColor3sv(context, angle::EntryPoint::GLColor3sv, v)));
558 if (isCallValid)
559 {
560 context->color3sv(v);
561 }
562 ANGLE_CAPTURE_GL(Color3sv, isCallValid, context, v);
563 }
564 else
565 {
566 GenerateContextLostErrorOnCurrentGlobalContext();
567 }
568 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
569 }
570
GL_Color3ub(GLubyte red,GLubyte green,GLubyte blue)571 void GL_APIENTRY GL_Color3ub(GLubyte red, GLubyte green, GLubyte blue)
572 {
573 Context *context = GetValidGlobalContext();
574 EVENT(context, GLColor3ub, "context = %d, red = %d, green = %d, blue = %d", CID(context), red,
575 green, blue);
576
577 if (context)
578 {
579 SCOPED_SHARE_CONTEXT_LOCK(context);
580 bool isCallValid =
581 (context->skipValidation() ||
582 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
583 context->getMutableErrorSetForValidation(),
584 angle::EntryPoint::GLColor3ub) &&
585 ValidateColor3ub(context, angle::EntryPoint::GLColor3ub, red, green, blue)));
586 if (isCallValid)
587 {
588 context->color3ub(red, green, blue);
589 }
590 ANGLE_CAPTURE_GL(Color3ub, isCallValid, context, red, green, blue);
591 }
592 else
593 {
594 GenerateContextLostErrorOnCurrentGlobalContext();
595 }
596 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
597 }
598
GL_Color3ubv(const GLubyte * v)599 void GL_APIENTRY GL_Color3ubv(const GLubyte *v)
600 {
601 Context *context = GetValidGlobalContext();
602 EVENT(context, GLColor3ubv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
603
604 if (context)
605 {
606 SCOPED_SHARE_CONTEXT_LOCK(context);
607 bool isCallValid =
608 (context->skipValidation() ||
609 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
610 context->getMutableErrorSetForValidation(),
611 angle::EntryPoint::GLColor3ubv) &&
612 ValidateColor3ubv(context, angle::EntryPoint::GLColor3ubv, v)));
613 if (isCallValid)
614 {
615 context->color3ubv(v);
616 }
617 ANGLE_CAPTURE_GL(Color3ubv, isCallValid, context, v);
618 }
619 else
620 {
621 GenerateContextLostErrorOnCurrentGlobalContext();
622 }
623 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
624 }
625
GL_Color3ui(GLuint red,GLuint green,GLuint blue)626 void GL_APIENTRY GL_Color3ui(GLuint red, GLuint green, GLuint blue)
627 {
628 Context *context = GetValidGlobalContext();
629 EVENT(context, GLColor3ui, "context = %d, red = %u, green = %u, blue = %u", CID(context), red,
630 green, blue);
631
632 if (context)
633 {
634 SCOPED_SHARE_CONTEXT_LOCK(context);
635 bool isCallValid =
636 (context->skipValidation() ||
637 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
638 context->getMutableErrorSetForValidation(),
639 angle::EntryPoint::GLColor3ui) &&
640 ValidateColor3ui(context, angle::EntryPoint::GLColor3ui, red, green, blue)));
641 if (isCallValid)
642 {
643 context->color3ui(red, green, blue);
644 }
645 ANGLE_CAPTURE_GL(Color3ui, isCallValid, context, red, green, blue);
646 }
647 else
648 {
649 GenerateContextLostErrorOnCurrentGlobalContext();
650 }
651 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
652 }
653
GL_Color3uiv(const GLuint * v)654 void GL_APIENTRY GL_Color3uiv(const GLuint *v)
655 {
656 Context *context = GetValidGlobalContext();
657 EVENT(context, GLColor3uiv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
658
659 if (context)
660 {
661 SCOPED_SHARE_CONTEXT_LOCK(context);
662 bool isCallValid =
663 (context->skipValidation() ||
664 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
665 context->getMutableErrorSetForValidation(),
666 angle::EntryPoint::GLColor3uiv) &&
667 ValidateColor3uiv(context, angle::EntryPoint::GLColor3uiv, v)));
668 if (isCallValid)
669 {
670 context->color3uiv(v);
671 }
672 ANGLE_CAPTURE_GL(Color3uiv, isCallValid, context, v);
673 }
674 else
675 {
676 GenerateContextLostErrorOnCurrentGlobalContext();
677 }
678 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
679 }
680
GL_Color3us(GLushort red,GLushort green,GLushort blue)681 void GL_APIENTRY GL_Color3us(GLushort red, GLushort green, GLushort blue)
682 {
683 Context *context = GetValidGlobalContext();
684 EVENT(context, GLColor3us, "context = %d, red = %u, green = %u, blue = %u", CID(context), red,
685 green, blue);
686
687 if (context)
688 {
689 SCOPED_SHARE_CONTEXT_LOCK(context);
690 bool isCallValid =
691 (context->skipValidation() ||
692 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
693 context->getMutableErrorSetForValidation(),
694 angle::EntryPoint::GLColor3us) &&
695 ValidateColor3us(context, angle::EntryPoint::GLColor3us, red, green, blue)));
696 if (isCallValid)
697 {
698 context->color3us(red, green, blue);
699 }
700 ANGLE_CAPTURE_GL(Color3us, isCallValid, context, red, green, blue);
701 }
702 else
703 {
704 GenerateContextLostErrorOnCurrentGlobalContext();
705 }
706 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
707 }
708
GL_Color3usv(const GLushort * v)709 void GL_APIENTRY GL_Color3usv(const GLushort *v)
710 {
711 Context *context = GetValidGlobalContext();
712 EVENT(context, GLColor3usv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
713
714 if (context)
715 {
716 SCOPED_SHARE_CONTEXT_LOCK(context);
717 bool isCallValid =
718 (context->skipValidation() ||
719 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
720 context->getMutableErrorSetForValidation(),
721 angle::EntryPoint::GLColor3usv) &&
722 ValidateColor3usv(context, angle::EntryPoint::GLColor3usv, v)));
723 if (isCallValid)
724 {
725 context->color3usv(v);
726 }
727 ANGLE_CAPTURE_GL(Color3usv, isCallValid, context, v);
728 }
729 else
730 {
731 GenerateContextLostErrorOnCurrentGlobalContext();
732 }
733 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
734 }
735
GL_Color4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha)736 void GL_APIENTRY GL_Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
737 {
738 Context *context = GetValidGlobalContext();
739 EVENT(context, GLColor4b, "context = %d, red = %d, green = %d, blue = %d, alpha = %d",
740 CID(context), red, green, blue, alpha);
741
742 if (context)
743 {
744 SCOPED_SHARE_CONTEXT_LOCK(context);
745 bool isCallValid =
746 (context->skipValidation() ||
747 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
748 context->getMutableErrorSetForValidation(),
749 angle::EntryPoint::GLColor4b) &&
750 ValidateColor4b(context, angle::EntryPoint::GLColor4b, red, green, blue, alpha)));
751 if (isCallValid)
752 {
753 context->color4b(red, green, blue, alpha);
754 }
755 ANGLE_CAPTURE_GL(Color4b, isCallValid, context, red, green, blue, alpha);
756 }
757 else
758 {
759 GenerateContextLostErrorOnCurrentGlobalContext();
760 }
761 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
762 }
763
GL_Color4bv(const GLbyte * v)764 void GL_APIENTRY GL_Color4bv(const GLbyte *v)
765 {
766 Context *context = GetValidGlobalContext();
767 EVENT(context, GLColor4bv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
768
769 if (context)
770 {
771 SCOPED_SHARE_CONTEXT_LOCK(context);
772 bool isCallValid =
773 (context->skipValidation() ||
774 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
775 context->getMutableErrorSetForValidation(),
776 angle::EntryPoint::GLColor4bv) &&
777 ValidateColor4bv(context, angle::EntryPoint::GLColor4bv, v)));
778 if (isCallValid)
779 {
780 context->color4bv(v);
781 }
782 ANGLE_CAPTURE_GL(Color4bv, isCallValid, context, v);
783 }
784 else
785 {
786 GenerateContextLostErrorOnCurrentGlobalContext();
787 }
788 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
789 }
790
GL_Color4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha)791 void GL_APIENTRY GL_Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
792 {
793 Context *context = GetValidGlobalContext();
794 EVENT(context, GLColor4d, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
795 CID(context), red, green, blue, alpha);
796
797 if (context)
798 {
799 SCOPED_SHARE_CONTEXT_LOCK(context);
800 bool isCallValid =
801 (context->skipValidation() ||
802 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
803 context->getMutableErrorSetForValidation(),
804 angle::EntryPoint::GLColor4d) &&
805 ValidateColor4d(context, angle::EntryPoint::GLColor4d, red, green, blue, alpha)));
806 if (isCallValid)
807 {
808 context->color4d(red, green, blue, alpha);
809 }
810 ANGLE_CAPTURE_GL(Color4d, isCallValid, context, red, green, blue, alpha);
811 }
812 else
813 {
814 GenerateContextLostErrorOnCurrentGlobalContext();
815 }
816 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
817 }
818
GL_Color4dv(const GLdouble * v)819 void GL_APIENTRY GL_Color4dv(const GLdouble *v)
820 {
821 Context *context = GetValidGlobalContext();
822 EVENT(context, GLColor4dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
823
824 if (context)
825 {
826 SCOPED_SHARE_CONTEXT_LOCK(context);
827 bool isCallValid =
828 (context->skipValidation() ||
829 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
830 context->getMutableErrorSetForValidation(),
831 angle::EntryPoint::GLColor4dv) &&
832 ValidateColor4dv(context, angle::EntryPoint::GLColor4dv, v)));
833 if (isCallValid)
834 {
835 context->color4dv(v);
836 }
837 ANGLE_CAPTURE_GL(Color4dv, isCallValid, context, v);
838 }
839 else
840 {
841 GenerateContextLostErrorOnCurrentGlobalContext();
842 }
843 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
844 }
845
GL_Color4fv(const GLfloat * v)846 void GL_APIENTRY GL_Color4fv(const GLfloat *v)
847 {
848 Context *context = GetValidGlobalContext();
849 EVENT(context, GLColor4fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
850
851 if (context)
852 {
853 SCOPED_SHARE_CONTEXT_LOCK(context);
854 bool isCallValid =
855 (context->skipValidation() ||
856 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
857 context->getMutableErrorSetForValidation(),
858 angle::EntryPoint::GLColor4fv) &&
859 ValidateColor4fv(context, angle::EntryPoint::GLColor4fv, v)));
860 if (isCallValid)
861 {
862 context->color4fv(v);
863 }
864 ANGLE_CAPTURE_GL(Color4fv, isCallValid, context, v);
865 }
866 else
867 {
868 GenerateContextLostErrorOnCurrentGlobalContext();
869 }
870 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
871 }
872
GL_Color4i(GLint red,GLint green,GLint blue,GLint alpha)873 void GL_APIENTRY GL_Color4i(GLint red, GLint green, GLint blue, GLint alpha)
874 {
875 Context *context = GetValidGlobalContext();
876 EVENT(context, GLColor4i, "context = %d, red = %d, green = %d, blue = %d, alpha = %d",
877 CID(context), red, green, blue, alpha);
878
879 if (context)
880 {
881 SCOPED_SHARE_CONTEXT_LOCK(context);
882 bool isCallValid =
883 (context->skipValidation() ||
884 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
885 context->getMutableErrorSetForValidation(),
886 angle::EntryPoint::GLColor4i) &&
887 ValidateColor4i(context, angle::EntryPoint::GLColor4i, red, green, blue, alpha)));
888 if (isCallValid)
889 {
890 context->color4i(red, green, blue, alpha);
891 }
892 ANGLE_CAPTURE_GL(Color4i, isCallValid, context, red, green, blue, alpha);
893 }
894 else
895 {
896 GenerateContextLostErrorOnCurrentGlobalContext();
897 }
898 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
899 }
900
GL_Color4iv(const GLint * v)901 void GL_APIENTRY GL_Color4iv(const GLint *v)
902 {
903 Context *context = GetValidGlobalContext();
904 EVENT(context, GLColor4iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
905
906 if (context)
907 {
908 SCOPED_SHARE_CONTEXT_LOCK(context);
909 bool isCallValid =
910 (context->skipValidation() ||
911 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
912 context->getMutableErrorSetForValidation(),
913 angle::EntryPoint::GLColor4iv) &&
914 ValidateColor4iv(context, angle::EntryPoint::GLColor4iv, v)));
915 if (isCallValid)
916 {
917 context->color4iv(v);
918 }
919 ANGLE_CAPTURE_GL(Color4iv, isCallValid, context, v);
920 }
921 else
922 {
923 GenerateContextLostErrorOnCurrentGlobalContext();
924 }
925 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
926 }
927
GL_Color4s(GLshort red,GLshort green,GLshort blue,GLshort alpha)928 void GL_APIENTRY GL_Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
929 {
930 Context *context = GetValidGlobalContext();
931 EVENT(context, GLColor4s, "context = %d, red = %d, green = %d, blue = %d, alpha = %d",
932 CID(context), red, green, blue, alpha);
933
934 if (context)
935 {
936 SCOPED_SHARE_CONTEXT_LOCK(context);
937 bool isCallValid =
938 (context->skipValidation() ||
939 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
940 context->getMutableErrorSetForValidation(),
941 angle::EntryPoint::GLColor4s) &&
942 ValidateColor4s(context, angle::EntryPoint::GLColor4s, red, green, blue, alpha)));
943 if (isCallValid)
944 {
945 context->color4s(red, green, blue, alpha);
946 }
947 ANGLE_CAPTURE_GL(Color4s, isCallValid, context, red, green, blue, alpha);
948 }
949 else
950 {
951 GenerateContextLostErrorOnCurrentGlobalContext();
952 }
953 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
954 }
955
GL_Color4sv(const GLshort * v)956 void GL_APIENTRY GL_Color4sv(const GLshort *v)
957 {
958 Context *context = GetValidGlobalContext();
959 EVENT(context, GLColor4sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
960
961 if (context)
962 {
963 SCOPED_SHARE_CONTEXT_LOCK(context);
964 bool isCallValid =
965 (context->skipValidation() ||
966 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
967 context->getMutableErrorSetForValidation(),
968 angle::EntryPoint::GLColor4sv) &&
969 ValidateColor4sv(context, angle::EntryPoint::GLColor4sv, v)));
970 if (isCallValid)
971 {
972 context->color4sv(v);
973 }
974 ANGLE_CAPTURE_GL(Color4sv, isCallValid, context, v);
975 }
976 else
977 {
978 GenerateContextLostErrorOnCurrentGlobalContext();
979 }
980 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
981 }
982
GL_Color4ubv(const GLubyte * v)983 void GL_APIENTRY GL_Color4ubv(const GLubyte *v)
984 {
985 Context *context = GetValidGlobalContext();
986 EVENT(context, GLColor4ubv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
987
988 if (context)
989 {
990 SCOPED_SHARE_CONTEXT_LOCK(context);
991 bool isCallValid =
992 (context->skipValidation() ||
993 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
994 context->getMutableErrorSetForValidation(),
995 angle::EntryPoint::GLColor4ubv) &&
996 ValidateColor4ubv(context, angle::EntryPoint::GLColor4ubv, v)));
997 if (isCallValid)
998 {
999 context->color4ubv(v);
1000 }
1001 ANGLE_CAPTURE_GL(Color4ubv, isCallValid, context, v);
1002 }
1003 else
1004 {
1005 GenerateContextLostErrorOnCurrentGlobalContext();
1006 }
1007 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1008 }
1009
GL_Color4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha)1010 void GL_APIENTRY GL_Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
1011 {
1012 Context *context = GetValidGlobalContext();
1013 EVENT(context, GLColor4ui, "context = %d, red = %u, green = %u, blue = %u, alpha = %u",
1014 CID(context), red, green, blue, alpha);
1015
1016 if (context)
1017 {
1018 SCOPED_SHARE_CONTEXT_LOCK(context);
1019 bool isCallValid =
1020 (context->skipValidation() ||
1021 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1022 context->getMutableErrorSetForValidation(),
1023 angle::EntryPoint::GLColor4ui) &&
1024 ValidateColor4ui(context, angle::EntryPoint::GLColor4ui, red, green, blue, alpha)));
1025 if (isCallValid)
1026 {
1027 context->color4ui(red, green, blue, alpha);
1028 }
1029 ANGLE_CAPTURE_GL(Color4ui, isCallValid, context, red, green, blue, alpha);
1030 }
1031 else
1032 {
1033 GenerateContextLostErrorOnCurrentGlobalContext();
1034 }
1035 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1036 }
1037
GL_Color4uiv(const GLuint * v)1038 void GL_APIENTRY GL_Color4uiv(const GLuint *v)
1039 {
1040 Context *context = GetValidGlobalContext();
1041 EVENT(context, GLColor4uiv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
1042
1043 if (context)
1044 {
1045 SCOPED_SHARE_CONTEXT_LOCK(context);
1046 bool isCallValid =
1047 (context->skipValidation() ||
1048 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1049 context->getMutableErrorSetForValidation(),
1050 angle::EntryPoint::GLColor4uiv) &&
1051 ValidateColor4uiv(context, angle::EntryPoint::GLColor4uiv, v)));
1052 if (isCallValid)
1053 {
1054 context->color4uiv(v);
1055 }
1056 ANGLE_CAPTURE_GL(Color4uiv, isCallValid, context, v);
1057 }
1058 else
1059 {
1060 GenerateContextLostErrorOnCurrentGlobalContext();
1061 }
1062 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1063 }
1064
GL_Color4us(GLushort red,GLushort green,GLushort blue,GLushort alpha)1065 void GL_APIENTRY GL_Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
1066 {
1067 Context *context = GetValidGlobalContext();
1068 EVENT(context, GLColor4us, "context = %d, red = %u, green = %u, blue = %u, alpha = %u",
1069 CID(context), red, green, blue, alpha);
1070
1071 if (context)
1072 {
1073 SCOPED_SHARE_CONTEXT_LOCK(context);
1074 bool isCallValid =
1075 (context->skipValidation() ||
1076 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1077 context->getMutableErrorSetForValidation(),
1078 angle::EntryPoint::GLColor4us) &&
1079 ValidateColor4us(context, angle::EntryPoint::GLColor4us, red, green, blue, alpha)));
1080 if (isCallValid)
1081 {
1082 context->color4us(red, green, blue, alpha);
1083 }
1084 ANGLE_CAPTURE_GL(Color4us, isCallValid, context, red, green, blue, alpha);
1085 }
1086 else
1087 {
1088 GenerateContextLostErrorOnCurrentGlobalContext();
1089 }
1090 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1091 }
1092
GL_Color4usv(const GLushort * v)1093 void GL_APIENTRY GL_Color4usv(const GLushort *v)
1094 {
1095 Context *context = GetValidGlobalContext();
1096 EVENT(context, GLColor4usv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
1097
1098 if (context)
1099 {
1100 SCOPED_SHARE_CONTEXT_LOCK(context);
1101 bool isCallValid =
1102 (context->skipValidation() ||
1103 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1104 context->getMutableErrorSetForValidation(),
1105 angle::EntryPoint::GLColor4usv) &&
1106 ValidateColor4usv(context, angle::EntryPoint::GLColor4usv, v)));
1107 if (isCallValid)
1108 {
1109 context->color4usv(v);
1110 }
1111 ANGLE_CAPTURE_GL(Color4usv, isCallValid, context, v);
1112 }
1113 else
1114 {
1115 GenerateContextLostErrorOnCurrentGlobalContext();
1116 }
1117 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1118 }
1119
GL_ColorMaterial(GLenum face,GLenum mode)1120 void GL_APIENTRY GL_ColorMaterial(GLenum face, GLenum mode)
1121 {
1122 Context *context = GetValidGlobalContext();
1123 EVENT(context, GLColorMaterial, "context = %d, face = %s, mode = %s", CID(context),
1124 GLenumToString(BigGLEnum::TriangleFace, face),
1125 GLenumToString(BigGLEnum::ColorMaterialParameter, mode));
1126
1127 if (context)
1128 {
1129 SCOPED_SHARE_CONTEXT_LOCK(context);
1130 bool isCallValid =
1131 (context->skipValidation() ||
1132 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1133 context->getMutableErrorSetForValidation(),
1134 angle::EntryPoint::GLColorMaterial) &&
1135 ValidateColorMaterial(context, angle::EntryPoint::GLColorMaterial, face, mode)));
1136 if (isCallValid)
1137 {
1138 context->colorMaterial(face, mode);
1139 }
1140 ANGLE_CAPTURE_GL(ColorMaterial, isCallValid, context, face, mode);
1141 }
1142 else
1143 {
1144 GenerateContextLostErrorOnCurrentGlobalContext();
1145 }
1146 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1147 }
1148
GL_CopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type)1149 void GL_APIENTRY GL_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
1150 {
1151 Context *context = GetValidGlobalContext();
1152 EVENT(context, GLCopyPixels, "context = %d, x = %d, y = %d, width = %d, height = %d, type = %s",
1153 CID(context), x, y, width, height, GLenumToString(BigGLEnum::PixelCopyType, type));
1154
1155 if (context)
1156 {
1157 SCOPED_SHARE_CONTEXT_LOCK(context);
1158 bool isCallValid =
1159 (context->skipValidation() ||
1160 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1161 context->getMutableErrorSetForValidation(),
1162 angle::EntryPoint::GLCopyPixels) &&
1163 ValidateCopyPixels(context, angle::EntryPoint::GLCopyPixels, x, y, width, height,
1164 type)));
1165 if (isCallValid)
1166 {
1167 context->copyPixels(x, y, width, height, type);
1168 }
1169 ANGLE_CAPTURE_GL(CopyPixels, isCallValid, context, x, y, width, height, type);
1170 }
1171 else
1172 {
1173 GenerateContextLostErrorOnCurrentGlobalContext();
1174 }
1175 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1176 }
1177
GL_DeleteLists(GLuint list,GLsizei range)1178 void GL_APIENTRY GL_DeleteLists(GLuint list, GLsizei range)
1179 {
1180 Context *context = GetValidGlobalContext();
1181 EVENT(context, GLDeleteLists, "context = %d, list = %u, range = %d", CID(context), list, range);
1182
1183 if (context)
1184 {
1185 SCOPED_SHARE_CONTEXT_LOCK(context);
1186 bool isCallValid =
1187 (context->skipValidation() ||
1188 ValidateDeleteLists(context, angle::EntryPoint::GLDeleteLists, list, range));
1189 if (isCallValid)
1190 {
1191 context->deleteLists(list, range);
1192 }
1193 ANGLE_CAPTURE_GL(DeleteLists, isCallValid, context, list, range);
1194 }
1195 else
1196 {
1197 GenerateContextLostErrorOnCurrentGlobalContext();
1198 }
1199 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1200 }
1201
GL_DepthRange(GLdouble n,GLdouble f)1202 void GL_APIENTRY GL_DepthRange(GLdouble n, GLdouble f)
1203 {
1204 Context *context = GetValidGlobalContext();
1205 EVENT(context, GLDepthRange, "context = %d, n = %f, f = %f", CID(context), n, f);
1206
1207 if (context)
1208 {
1209 SCOPED_SHARE_CONTEXT_LOCK(context);
1210 bool isCallValid =
1211 (context->skipValidation() ||
1212 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1213 context->getMutableErrorSetForValidation(),
1214 angle::EntryPoint::GLDepthRange) &&
1215 ValidateDepthRange(context, angle::EntryPoint::GLDepthRange, n, f)));
1216 if (isCallValid)
1217 {
1218 context->depthRange(n, f);
1219 }
1220 ANGLE_CAPTURE_GL(DepthRange, isCallValid, context, n, f);
1221 }
1222 else
1223 {
1224 GenerateContextLostErrorOnCurrentGlobalContext();
1225 }
1226 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1227 }
1228
GL_DrawBuffer(GLenum buf)1229 void GL_APIENTRY GL_DrawBuffer(GLenum buf)
1230 {
1231 Context *context = GetValidGlobalContext();
1232 EVENT(context, GLDrawBuffer, "context = %d, buf = %s", CID(context),
1233 GLenumToString(BigGLEnum::DrawBufferMode, buf));
1234
1235 if (context)
1236 {
1237 SCOPED_SHARE_CONTEXT_LOCK(context);
1238 bool isCallValid =
1239 (context->skipValidation() ||
1240 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1241 context->getMutableErrorSetForValidation(),
1242 angle::EntryPoint::GLDrawBuffer) &&
1243 ValidateDrawBuffer(context, angle::EntryPoint::GLDrawBuffer, buf)));
1244 if (isCallValid)
1245 {
1246 context->drawBuffer(buf);
1247 }
1248 ANGLE_CAPTURE_GL(DrawBuffer, isCallValid, context, buf);
1249 }
1250 else
1251 {
1252 GenerateContextLostErrorOnCurrentGlobalContext();
1253 }
1254 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1255 }
1256
1257 void GL_APIENTRY
GL_DrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)1258 GL_DrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
1259 {
1260 Context *context = GetValidGlobalContext();
1261 EVENT(context, GLDrawPixels,
1262 "context = %d, width = %d, height = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR
1263 "",
1264 CID(context), width, height, GLenumToString(BigGLEnum::PixelFormat, format),
1265 GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels);
1266
1267 if (context)
1268 {
1269 SCOPED_SHARE_CONTEXT_LOCK(context);
1270 bool isCallValid =
1271 (context->skipValidation() ||
1272 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1273 context->getMutableErrorSetForValidation(),
1274 angle::EntryPoint::GLDrawPixels) &&
1275 ValidateDrawPixels(context, angle::EntryPoint::GLDrawPixels, width, height, format,
1276 type, pixels)));
1277 if (isCallValid)
1278 {
1279 context->drawPixels(width, height, format, type, pixels);
1280 }
1281 ANGLE_CAPTURE_GL(DrawPixels, isCallValid, context, width, height, format, type, pixels);
1282 }
1283 else
1284 {
1285 GenerateContextLostErrorOnCurrentGlobalContext();
1286 }
1287 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1288 }
1289
GL_EdgeFlag(GLboolean flag)1290 void GL_APIENTRY GL_EdgeFlag(GLboolean flag)
1291 {
1292 Context *context = GetValidGlobalContext();
1293 EVENT(context, GLEdgeFlag, "context = %d, flag = %s", CID(context), GLbooleanToString(flag));
1294
1295 if (context)
1296 {
1297 SCOPED_SHARE_CONTEXT_LOCK(context);
1298 bool isCallValid =
1299 (context->skipValidation() ||
1300 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1301 context->getMutableErrorSetForValidation(),
1302 angle::EntryPoint::GLEdgeFlag) &&
1303 ValidateEdgeFlag(context, angle::EntryPoint::GLEdgeFlag, flag)));
1304 if (isCallValid)
1305 {
1306 context->edgeFlag(flag);
1307 }
1308 ANGLE_CAPTURE_GL(EdgeFlag, isCallValid, context, flag);
1309 }
1310 else
1311 {
1312 GenerateContextLostErrorOnCurrentGlobalContext();
1313 }
1314 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1315 }
1316
GL_EdgeFlagv(const GLboolean * flag)1317 void GL_APIENTRY GL_EdgeFlagv(const GLboolean *flag)
1318 {
1319 Context *context = GetValidGlobalContext();
1320 EVENT(context, GLEdgeFlagv, "context = %d, flag = 0x%016" PRIxPTR "", CID(context),
1321 (uintptr_t)flag);
1322
1323 if (context)
1324 {
1325 SCOPED_SHARE_CONTEXT_LOCK(context);
1326 bool isCallValid =
1327 (context->skipValidation() ||
1328 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1329 context->getMutableErrorSetForValidation(),
1330 angle::EntryPoint::GLEdgeFlagv) &&
1331 ValidateEdgeFlagv(context, angle::EntryPoint::GLEdgeFlagv, flag)));
1332 if (isCallValid)
1333 {
1334 context->edgeFlagv(flag);
1335 }
1336 ANGLE_CAPTURE_GL(EdgeFlagv, isCallValid, context, flag);
1337 }
1338 else
1339 {
1340 GenerateContextLostErrorOnCurrentGlobalContext();
1341 }
1342 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1343 }
1344
GL_End()1345 void GL_APIENTRY GL_End()
1346 {
1347 Context *context = GetValidGlobalContext();
1348 EVENT(context, GLEnd, "context = %d", CID(context));
1349
1350 if (context)
1351 {
1352 SCOPED_SHARE_CONTEXT_LOCK(context);
1353 bool isCallValid =
1354 (context->skipValidation() ||
1355 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1356 context->getMutableErrorSetForValidation(),
1357 angle::EntryPoint::GLEnd) &&
1358 ValidateEnd(context, angle::EntryPoint::GLEnd)));
1359 if (isCallValid)
1360 {
1361 context->end();
1362 }
1363 ANGLE_CAPTURE_GL(End, isCallValid, context);
1364 }
1365 else
1366 {
1367 GenerateContextLostErrorOnCurrentGlobalContext();
1368 }
1369 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1370 }
1371
GL_EndList()1372 void GL_APIENTRY GL_EndList()
1373 {
1374 Context *context = GetValidGlobalContext();
1375 EVENT(context, GLEndList, "context = %d", CID(context));
1376
1377 if (context)
1378 {
1379 SCOPED_SHARE_CONTEXT_LOCK(context);
1380 bool isCallValid =
1381 (context->skipValidation() ||
1382 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1383 context->getMutableErrorSetForValidation(),
1384 angle::EntryPoint::GLEndList) &&
1385 ValidateEndList(context, angle::EntryPoint::GLEndList)));
1386 if (isCallValid)
1387 {
1388 context->endList();
1389 }
1390 ANGLE_CAPTURE_GL(EndList, isCallValid, context);
1391 }
1392 else
1393 {
1394 GenerateContextLostErrorOnCurrentGlobalContext();
1395 }
1396 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1397 }
1398
GL_EvalCoord1d(GLdouble u)1399 void GL_APIENTRY GL_EvalCoord1d(GLdouble u)
1400 {
1401 Context *context = GetValidGlobalContext();
1402 EVENT(context, GLEvalCoord1d, "context = %d, u = %f", CID(context), u);
1403
1404 if (context)
1405 {
1406 SCOPED_SHARE_CONTEXT_LOCK(context);
1407 bool isCallValid =
1408 (context->skipValidation() ||
1409 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1410 context->getMutableErrorSetForValidation(),
1411 angle::EntryPoint::GLEvalCoord1d) &&
1412 ValidateEvalCoord1d(context, angle::EntryPoint::GLEvalCoord1d, u)));
1413 if (isCallValid)
1414 {
1415 context->evalCoord1d(u);
1416 }
1417 ANGLE_CAPTURE_GL(EvalCoord1d, isCallValid, context, u);
1418 }
1419 else
1420 {
1421 GenerateContextLostErrorOnCurrentGlobalContext();
1422 }
1423 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1424 }
1425
GL_EvalCoord1dv(const GLdouble * u)1426 void GL_APIENTRY GL_EvalCoord1dv(const GLdouble *u)
1427 {
1428 Context *context = GetValidGlobalContext();
1429 EVENT(context, GLEvalCoord1dv, "context = %d, u = 0x%016" PRIxPTR "", CID(context),
1430 (uintptr_t)u);
1431
1432 if (context)
1433 {
1434 SCOPED_SHARE_CONTEXT_LOCK(context);
1435 bool isCallValid =
1436 (context->skipValidation() ||
1437 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1438 context->getMutableErrorSetForValidation(),
1439 angle::EntryPoint::GLEvalCoord1dv) &&
1440 ValidateEvalCoord1dv(context, angle::EntryPoint::GLEvalCoord1dv, u)));
1441 if (isCallValid)
1442 {
1443 context->evalCoord1dv(u);
1444 }
1445 ANGLE_CAPTURE_GL(EvalCoord1dv, isCallValid, context, u);
1446 }
1447 else
1448 {
1449 GenerateContextLostErrorOnCurrentGlobalContext();
1450 }
1451 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1452 }
1453
GL_EvalCoord1f(GLfloat u)1454 void GL_APIENTRY GL_EvalCoord1f(GLfloat u)
1455 {
1456 Context *context = GetValidGlobalContext();
1457 EVENT(context, GLEvalCoord1f, "context = %d, u = %f", CID(context), u);
1458
1459 if (context)
1460 {
1461 SCOPED_SHARE_CONTEXT_LOCK(context);
1462 bool isCallValid =
1463 (context->skipValidation() ||
1464 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1465 context->getMutableErrorSetForValidation(),
1466 angle::EntryPoint::GLEvalCoord1f) &&
1467 ValidateEvalCoord1f(context, angle::EntryPoint::GLEvalCoord1f, u)));
1468 if (isCallValid)
1469 {
1470 context->evalCoord1f(u);
1471 }
1472 ANGLE_CAPTURE_GL(EvalCoord1f, isCallValid, context, u);
1473 }
1474 else
1475 {
1476 GenerateContextLostErrorOnCurrentGlobalContext();
1477 }
1478 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1479 }
1480
GL_EvalCoord1fv(const GLfloat * u)1481 void GL_APIENTRY GL_EvalCoord1fv(const GLfloat *u)
1482 {
1483 Context *context = GetValidGlobalContext();
1484 EVENT(context, GLEvalCoord1fv, "context = %d, u = 0x%016" PRIxPTR "", CID(context),
1485 (uintptr_t)u);
1486
1487 if (context)
1488 {
1489 SCOPED_SHARE_CONTEXT_LOCK(context);
1490 bool isCallValid =
1491 (context->skipValidation() ||
1492 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1493 context->getMutableErrorSetForValidation(),
1494 angle::EntryPoint::GLEvalCoord1fv) &&
1495 ValidateEvalCoord1fv(context, angle::EntryPoint::GLEvalCoord1fv, u)));
1496 if (isCallValid)
1497 {
1498 context->evalCoord1fv(u);
1499 }
1500 ANGLE_CAPTURE_GL(EvalCoord1fv, isCallValid, context, u);
1501 }
1502 else
1503 {
1504 GenerateContextLostErrorOnCurrentGlobalContext();
1505 }
1506 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1507 }
1508
GL_EvalCoord2d(GLdouble u,GLdouble v)1509 void GL_APIENTRY GL_EvalCoord2d(GLdouble u, GLdouble v)
1510 {
1511 Context *context = GetValidGlobalContext();
1512 EVENT(context, GLEvalCoord2d, "context = %d, u = %f, v = %f", CID(context), u, v);
1513
1514 if (context)
1515 {
1516 SCOPED_SHARE_CONTEXT_LOCK(context);
1517 bool isCallValid =
1518 (context->skipValidation() ||
1519 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1520 context->getMutableErrorSetForValidation(),
1521 angle::EntryPoint::GLEvalCoord2d) &&
1522 ValidateEvalCoord2d(context, angle::EntryPoint::GLEvalCoord2d, u, v)));
1523 if (isCallValid)
1524 {
1525 context->evalCoord2d(u, v);
1526 }
1527 ANGLE_CAPTURE_GL(EvalCoord2d, isCallValid, context, u, v);
1528 }
1529 else
1530 {
1531 GenerateContextLostErrorOnCurrentGlobalContext();
1532 }
1533 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1534 }
1535
GL_EvalCoord2dv(const GLdouble * u)1536 void GL_APIENTRY GL_EvalCoord2dv(const GLdouble *u)
1537 {
1538 Context *context = GetValidGlobalContext();
1539 EVENT(context, GLEvalCoord2dv, "context = %d, u = 0x%016" PRIxPTR "", CID(context),
1540 (uintptr_t)u);
1541
1542 if (context)
1543 {
1544 SCOPED_SHARE_CONTEXT_LOCK(context);
1545 bool isCallValid =
1546 (context->skipValidation() ||
1547 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1548 context->getMutableErrorSetForValidation(),
1549 angle::EntryPoint::GLEvalCoord2dv) &&
1550 ValidateEvalCoord2dv(context, angle::EntryPoint::GLEvalCoord2dv, u)));
1551 if (isCallValid)
1552 {
1553 context->evalCoord2dv(u);
1554 }
1555 ANGLE_CAPTURE_GL(EvalCoord2dv, isCallValid, context, u);
1556 }
1557 else
1558 {
1559 GenerateContextLostErrorOnCurrentGlobalContext();
1560 }
1561 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1562 }
1563
GL_EvalCoord2f(GLfloat u,GLfloat v)1564 void GL_APIENTRY GL_EvalCoord2f(GLfloat u, GLfloat v)
1565 {
1566 Context *context = GetValidGlobalContext();
1567 EVENT(context, GLEvalCoord2f, "context = %d, u = %f, v = %f", CID(context), u, v);
1568
1569 if (context)
1570 {
1571 SCOPED_SHARE_CONTEXT_LOCK(context);
1572 bool isCallValid =
1573 (context->skipValidation() ||
1574 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1575 context->getMutableErrorSetForValidation(),
1576 angle::EntryPoint::GLEvalCoord2f) &&
1577 ValidateEvalCoord2f(context, angle::EntryPoint::GLEvalCoord2f, u, v)));
1578 if (isCallValid)
1579 {
1580 context->evalCoord2f(u, v);
1581 }
1582 ANGLE_CAPTURE_GL(EvalCoord2f, isCallValid, context, u, v);
1583 }
1584 else
1585 {
1586 GenerateContextLostErrorOnCurrentGlobalContext();
1587 }
1588 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1589 }
1590
GL_EvalCoord2fv(const GLfloat * u)1591 void GL_APIENTRY GL_EvalCoord2fv(const GLfloat *u)
1592 {
1593 Context *context = GetValidGlobalContext();
1594 EVENT(context, GLEvalCoord2fv, "context = %d, u = 0x%016" PRIxPTR "", CID(context),
1595 (uintptr_t)u);
1596
1597 if (context)
1598 {
1599 SCOPED_SHARE_CONTEXT_LOCK(context);
1600 bool isCallValid =
1601 (context->skipValidation() ||
1602 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1603 context->getMutableErrorSetForValidation(),
1604 angle::EntryPoint::GLEvalCoord2fv) &&
1605 ValidateEvalCoord2fv(context, angle::EntryPoint::GLEvalCoord2fv, u)));
1606 if (isCallValid)
1607 {
1608 context->evalCoord2fv(u);
1609 }
1610 ANGLE_CAPTURE_GL(EvalCoord2fv, isCallValid, context, u);
1611 }
1612 else
1613 {
1614 GenerateContextLostErrorOnCurrentGlobalContext();
1615 }
1616 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1617 }
1618
GL_EvalMesh1(GLenum mode,GLint i1,GLint i2)1619 void GL_APIENTRY GL_EvalMesh1(GLenum mode, GLint i1, GLint i2)
1620 {
1621 Context *context = GetValidGlobalContext();
1622 EVENT(context, GLEvalMesh1, "context = %d, mode = %s, i1 = %d, i2 = %d", CID(context),
1623 GLenumToString(BigGLEnum::MeshMode1, mode), i1, i2);
1624
1625 if (context)
1626 {
1627 SCOPED_SHARE_CONTEXT_LOCK(context);
1628 bool isCallValid =
1629 (context->skipValidation() ||
1630 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1631 context->getMutableErrorSetForValidation(),
1632 angle::EntryPoint::GLEvalMesh1) &&
1633 ValidateEvalMesh1(context, angle::EntryPoint::GLEvalMesh1, mode, i1, i2)));
1634 if (isCallValid)
1635 {
1636 context->evalMesh1(mode, i1, i2);
1637 }
1638 ANGLE_CAPTURE_GL(EvalMesh1, isCallValid, context, mode, i1, i2);
1639 }
1640 else
1641 {
1642 GenerateContextLostErrorOnCurrentGlobalContext();
1643 }
1644 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1645 }
1646
GL_EvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2)1647 void GL_APIENTRY GL_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1648 {
1649 Context *context = GetValidGlobalContext();
1650 EVENT(context, GLEvalMesh2, "context = %d, mode = %s, i1 = %d, i2 = %d, j1 = %d, j2 = %d",
1651 CID(context), GLenumToString(BigGLEnum::MeshMode2, mode), i1, i2, j1, j2);
1652
1653 if (context)
1654 {
1655 SCOPED_SHARE_CONTEXT_LOCK(context);
1656 bool isCallValid =
1657 (context->skipValidation() ||
1658 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1659 context->getMutableErrorSetForValidation(),
1660 angle::EntryPoint::GLEvalMesh2) &&
1661 ValidateEvalMesh2(context, angle::EntryPoint::GLEvalMesh2, mode, i1, i2, j1, j2)));
1662 if (isCallValid)
1663 {
1664 context->evalMesh2(mode, i1, i2, j1, j2);
1665 }
1666 ANGLE_CAPTURE_GL(EvalMesh2, isCallValid, context, mode, i1, i2, j1, j2);
1667 }
1668 else
1669 {
1670 GenerateContextLostErrorOnCurrentGlobalContext();
1671 }
1672 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1673 }
1674
GL_EvalPoint1(GLint i)1675 void GL_APIENTRY GL_EvalPoint1(GLint i)
1676 {
1677 Context *context = GetValidGlobalContext();
1678 EVENT(context, GLEvalPoint1, "context = %d, i = %d", CID(context), i);
1679
1680 if (context)
1681 {
1682 SCOPED_SHARE_CONTEXT_LOCK(context);
1683 bool isCallValid =
1684 (context->skipValidation() ||
1685 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1686 context->getMutableErrorSetForValidation(),
1687 angle::EntryPoint::GLEvalPoint1) &&
1688 ValidateEvalPoint1(context, angle::EntryPoint::GLEvalPoint1, i)));
1689 if (isCallValid)
1690 {
1691 context->evalPoint1(i);
1692 }
1693 ANGLE_CAPTURE_GL(EvalPoint1, isCallValid, context, i);
1694 }
1695 else
1696 {
1697 GenerateContextLostErrorOnCurrentGlobalContext();
1698 }
1699 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1700 }
1701
GL_EvalPoint2(GLint i,GLint j)1702 void GL_APIENTRY GL_EvalPoint2(GLint i, GLint j)
1703 {
1704 Context *context = GetValidGlobalContext();
1705 EVENT(context, GLEvalPoint2, "context = %d, i = %d, j = %d", CID(context), i, j);
1706
1707 if (context)
1708 {
1709 SCOPED_SHARE_CONTEXT_LOCK(context);
1710 bool isCallValid =
1711 (context->skipValidation() ||
1712 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1713 context->getMutableErrorSetForValidation(),
1714 angle::EntryPoint::GLEvalPoint2) &&
1715 ValidateEvalPoint2(context, angle::EntryPoint::GLEvalPoint2, i, j)));
1716 if (isCallValid)
1717 {
1718 context->evalPoint2(i, j);
1719 }
1720 ANGLE_CAPTURE_GL(EvalPoint2, isCallValid, context, i, j);
1721 }
1722 else
1723 {
1724 GenerateContextLostErrorOnCurrentGlobalContext();
1725 }
1726 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1727 }
1728
GL_FeedbackBuffer(GLsizei size,GLenum type,GLfloat * buffer)1729 void GL_APIENTRY GL_FeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
1730 {
1731 Context *context = GetValidGlobalContext();
1732 EVENT(context, GLFeedbackBuffer,
1733 "context = %d, size = %d, type = %s, buffer = 0x%016" PRIxPTR "", CID(context), size,
1734 GLenumToString(BigGLEnum::FeedbackType, type), (uintptr_t)buffer);
1735
1736 if (context)
1737 {
1738 SCOPED_SHARE_CONTEXT_LOCK(context);
1739 bool isCallValid =
1740 (context->skipValidation() ||
1741 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1742 context->getMutableErrorSetForValidation(),
1743 angle::EntryPoint::GLFeedbackBuffer) &&
1744 ValidateFeedbackBuffer(context, angle::EntryPoint::GLFeedbackBuffer, size, type,
1745 buffer)));
1746 if (isCallValid)
1747 {
1748 context->feedbackBuffer(size, type, buffer);
1749 }
1750 ANGLE_CAPTURE_GL(FeedbackBuffer, isCallValid, context, size, type, buffer);
1751 }
1752 else
1753 {
1754 GenerateContextLostErrorOnCurrentGlobalContext();
1755 }
1756 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1757 }
1758
GL_Fogi(GLenum pname,GLint param)1759 void GL_APIENTRY GL_Fogi(GLenum pname, GLint param)
1760 {
1761 Context *context = GetValidGlobalContext();
1762 EVENT(context, GLFogi, "context = %d, pname = %s, param = %d", CID(context),
1763 GLenumToString(BigGLEnum::FogParameter, pname), param);
1764
1765 if (context)
1766 {
1767 SCOPED_SHARE_CONTEXT_LOCK(context);
1768 bool isCallValid =
1769 (context->skipValidation() ||
1770 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1771 context->getMutableErrorSetForValidation(),
1772 angle::EntryPoint::GLFogi) &&
1773 ValidateFogi(context, angle::EntryPoint::GLFogi, pname, param)));
1774 if (isCallValid)
1775 {
1776 context->fogi(pname, param);
1777 }
1778 ANGLE_CAPTURE_GL(Fogi, isCallValid, context, pname, param);
1779 }
1780 else
1781 {
1782 GenerateContextLostErrorOnCurrentGlobalContext();
1783 }
1784 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1785 }
1786
GL_Fogiv(GLenum pname,const GLint * params)1787 void GL_APIENTRY GL_Fogiv(GLenum pname, const GLint *params)
1788 {
1789 Context *context = GetValidGlobalContext();
1790 EVENT(context, GLFogiv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1791 GLenumToString(BigGLEnum::FogParameter, pname), (uintptr_t)params);
1792
1793 if (context)
1794 {
1795 SCOPED_SHARE_CONTEXT_LOCK(context);
1796 bool isCallValid =
1797 (context->skipValidation() ||
1798 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1799 context->getMutableErrorSetForValidation(),
1800 angle::EntryPoint::GLFogiv) &&
1801 ValidateFogiv(context, angle::EntryPoint::GLFogiv, pname, params)));
1802 if (isCallValid)
1803 {
1804 context->fogiv(pname, params);
1805 }
1806 ANGLE_CAPTURE_GL(Fogiv, isCallValid, context, pname, params);
1807 }
1808 else
1809 {
1810 GenerateContextLostErrorOnCurrentGlobalContext();
1811 }
1812 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1813 }
1814
GL_Frustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)1815 void GL_APIENTRY GL_Frustum(GLdouble left,
1816 GLdouble right,
1817 GLdouble bottom,
1818 GLdouble top,
1819 GLdouble zNear,
1820 GLdouble zFar)
1821 {
1822 Context *context = GetValidGlobalContext();
1823 EVENT(context, GLFrustum,
1824 "context = %d, left = %f, right = %f, bottom = %f, top = %f, zNear = %f, zFar = %f",
1825 CID(context), left, right, bottom, top, zNear, zFar);
1826
1827 if (context)
1828 {
1829 SCOPED_SHARE_CONTEXT_LOCK(context);
1830 bool isCallValid =
1831 (context->skipValidation() ||
1832 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1833 context->getMutableErrorSetForValidation(),
1834 angle::EntryPoint::GLFrustum) &&
1835 ValidateFrustum(context, angle::EntryPoint::GLFrustum, left, right, bottom, top,
1836 zNear, zFar)));
1837 if (isCallValid)
1838 {
1839 context->frustum(left, right, bottom, top, zNear, zFar);
1840 }
1841 ANGLE_CAPTURE_GL(Frustum, isCallValid, context, left, right, bottom, top, zNear, zFar);
1842 }
1843 else
1844 {
1845 GenerateContextLostErrorOnCurrentGlobalContext();
1846 }
1847 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1848 }
1849
GL_GenLists(GLsizei range)1850 GLuint GL_APIENTRY GL_GenLists(GLsizei range)
1851 {
1852 Context *context = GetValidGlobalContext();
1853 EVENT(context, GLGenLists, "context = %d, range = %d", CID(context), range);
1854
1855 GLuint returnValue;
1856 if (context)
1857 {
1858 SCOPED_SHARE_CONTEXT_LOCK(context);
1859 bool isCallValid = (context->skipValidation() ||
1860 ValidateGenLists(context, angle::EntryPoint::GLGenLists, range));
1861 if (isCallValid)
1862 {
1863 returnValue = context->genLists(range);
1864 }
1865 else
1866 {
1867 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGenLists, GLuint>();
1868 }
1869 ANGLE_CAPTURE_GL(GenLists, isCallValid, context, range, returnValue);
1870 }
1871 else
1872 {
1873 GenerateContextLostErrorOnCurrentGlobalContext();
1874 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGenLists, GLuint>();
1875 }
1876 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1877 return returnValue;
1878 }
1879
GL_GetClipPlane(GLenum plane,GLdouble * equation)1880 void GL_APIENTRY GL_GetClipPlane(GLenum plane, GLdouble *equation)
1881 {
1882 Context *context = GetValidGlobalContext();
1883 EVENT(context, GLGetClipPlane, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "",
1884 CID(context), GLenumToString(BigGLEnum::ClipPlaneName, plane), (uintptr_t)equation);
1885
1886 if (context)
1887 {
1888 SCOPED_SHARE_CONTEXT_LOCK(context);
1889 bool isCallValid =
1890 (context->skipValidation() ||
1891 ValidateGetClipPlane(context, angle::EntryPoint::GLGetClipPlane, plane, equation));
1892 if (isCallValid)
1893 {
1894 context->getClipPlane(plane, equation);
1895 }
1896 ANGLE_CAPTURE_GL(GetClipPlane, isCallValid, context, plane, equation);
1897 }
1898 else
1899 {
1900 GenerateContextLostErrorOnCurrentGlobalContext();
1901 }
1902 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1903 }
1904
GL_GetDoublev(GLenum pname,GLdouble * data)1905 void GL_APIENTRY GL_GetDoublev(GLenum pname, GLdouble *data)
1906 {
1907 Context *context = GetValidGlobalContext();
1908 EVENT(context, GLGetDoublev, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", CID(context),
1909 GLenumToString(BigGLEnum::GetPName, pname), (uintptr_t)data);
1910
1911 if (context)
1912 {
1913 SCOPED_SHARE_CONTEXT_LOCK(context);
1914 bool isCallValid =
1915 (context->skipValidation() ||
1916 ValidateGetDoublev(context, angle::EntryPoint::GLGetDoublev, pname, data));
1917 if (isCallValid)
1918 {
1919 context->getDoublev(pname, data);
1920 }
1921 ANGLE_CAPTURE_GL(GetDoublev, isCallValid, context, pname, data);
1922 }
1923 else
1924 {
1925 GenerateContextLostErrorOnCurrentGlobalContext();
1926 }
1927 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1928 }
1929
GL_GetLightiv(GLenum light,GLenum pname,GLint * params)1930 void GL_APIENTRY GL_GetLightiv(GLenum light, GLenum pname, GLint *params)
1931 {
1932 Context *context = GetValidGlobalContext();
1933 EVENT(context, GLGetLightiv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "",
1934 CID(context), GLenumToString(BigGLEnum::LightName, light),
1935 GLenumToString(BigGLEnum::LightParameter, pname), (uintptr_t)params);
1936
1937 if (context)
1938 {
1939 SCOPED_SHARE_CONTEXT_LOCK(context);
1940 bool isCallValid =
1941 (context->skipValidation() ||
1942 ValidateGetLightiv(context, angle::EntryPoint::GLGetLightiv, light, pname, params));
1943 if (isCallValid)
1944 {
1945 context->getLightiv(light, pname, params);
1946 }
1947 ANGLE_CAPTURE_GL(GetLightiv, isCallValid, context, light, pname, params);
1948 }
1949 else
1950 {
1951 GenerateContextLostErrorOnCurrentGlobalContext();
1952 }
1953 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1954 }
1955
GL_GetMapdv(GLenum target,GLenum query,GLdouble * v)1956 void GL_APIENTRY GL_GetMapdv(GLenum target, GLenum query, GLdouble *v)
1957 {
1958 Context *context = GetValidGlobalContext();
1959 EVENT(context, GLGetMapdv, "context = %d, target = %s, query = %s, v = 0x%016" PRIxPTR "",
1960 CID(context), GLenumToString(BigGLEnum::MapTarget, target),
1961 GLenumToString(BigGLEnum::GetMapQuery, query), (uintptr_t)v);
1962
1963 if (context)
1964 {
1965 SCOPED_SHARE_CONTEXT_LOCK(context);
1966 bool isCallValid =
1967 (context->skipValidation() ||
1968 ValidateGetMapdv(context, angle::EntryPoint::GLGetMapdv, target, query, v));
1969 if (isCallValid)
1970 {
1971 context->getMapdv(target, query, v);
1972 }
1973 ANGLE_CAPTURE_GL(GetMapdv, isCallValid, context, target, query, v);
1974 }
1975 else
1976 {
1977 GenerateContextLostErrorOnCurrentGlobalContext();
1978 }
1979 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1980 }
1981
GL_GetMapfv(GLenum target,GLenum query,GLfloat * v)1982 void GL_APIENTRY GL_GetMapfv(GLenum target, GLenum query, GLfloat *v)
1983 {
1984 Context *context = GetValidGlobalContext();
1985 EVENT(context, GLGetMapfv, "context = %d, target = %s, query = %s, v = 0x%016" PRIxPTR "",
1986 CID(context), GLenumToString(BigGLEnum::MapTarget, target),
1987 GLenumToString(BigGLEnum::GetMapQuery, query), (uintptr_t)v);
1988
1989 if (context)
1990 {
1991 SCOPED_SHARE_CONTEXT_LOCK(context);
1992 bool isCallValid =
1993 (context->skipValidation() ||
1994 ValidateGetMapfv(context, angle::EntryPoint::GLGetMapfv, target, query, v));
1995 if (isCallValid)
1996 {
1997 context->getMapfv(target, query, v);
1998 }
1999 ANGLE_CAPTURE_GL(GetMapfv, isCallValid, context, target, query, v);
2000 }
2001 else
2002 {
2003 GenerateContextLostErrorOnCurrentGlobalContext();
2004 }
2005 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2006 }
2007
GL_GetMapiv(GLenum target,GLenum query,GLint * v)2008 void GL_APIENTRY GL_GetMapiv(GLenum target, GLenum query, GLint *v)
2009 {
2010 Context *context = GetValidGlobalContext();
2011 EVENT(context, GLGetMapiv, "context = %d, target = %s, query = %s, v = 0x%016" PRIxPTR "",
2012 CID(context), GLenumToString(BigGLEnum::MapTarget, target),
2013 GLenumToString(BigGLEnum::GetMapQuery, query), (uintptr_t)v);
2014
2015 if (context)
2016 {
2017 SCOPED_SHARE_CONTEXT_LOCK(context);
2018 bool isCallValid =
2019 (context->skipValidation() ||
2020 ValidateGetMapiv(context, angle::EntryPoint::GLGetMapiv, target, query, v));
2021 if (isCallValid)
2022 {
2023 context->getMapiv(target, query, v);
2024 }
2025 ANGLE_CAPTURE_GL(GetMapiv, isCallValid, context, target, query, v);
2026 }
2027 else
2028 {
2029 GenerateContextLostErrorOnCurrentGlobalContext();
2030 }
2031 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2032 }
2033
GL_GetMaterialiv(GLenum face,GLenum pname,GLint * params)2034 void GL_APIENTRY GL_GetMaterialiv(GLenum face, GLenum pname, GLint *params)
2035 {
2036 Context *context = GetValidGlobalContext();
2037 EVENT(context, GLGetMaterialiv,
2038 "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2039 GLenumToString(BigGLEnum::TriangleFace, face),
2040 GLenumToString(BigGLEnum::MaterialParameter, pname), (uintptr_t)params);
2041
2042 if (context)
2043 {
2044 SCOPED_SHARE_CONTEXT_LOCK(context);
2045 bool isCallValid = (context->skipValidation() ||
2046 ValidateGetMaterialiv(context, angle::EntryPoint::GLGetMaterialiv, face,
2047 pname, params));
2048 if (isCallValid)
2049 {
2050 context->getMaterialiv(face, pname, params);
2051 }
2052 ANGLE_CAPTURE_GL(GetMaterialiv, isCallValid, context, face, pname, params);
2053 }
2054 else
2055 {
2056 GenerateContextLostErrorOnCurrentGlobalContext();
2057 }
2058 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2059 }
2060
GL_GetPixelMapfv(GLenum map,GLfloat * values)2061 void GL_APIENTRY GL_GetPixelMapfv(GLenum map, GLfloat *values)
2062 {
2063 Context *context = GetValidGlobalContext();
2064 EVENT(context, GLGetPixelMapfv, "context = %d, map = %s, values = 0x%016" PRIxPTR "",
2065 CID(context), GLenumToString(BigGLEnum::PixelMap, map), (uintptr_t)values);
2066
2067 if (context)
2068 {
2069 SCOPED_SHARE_CONTEXT_LOCK(context);
2070 bool isCallValid =
2071 (context->skipValidation() ||
2072 ValidateGetPixelMapfv(context, angle::EntryPoint::GLGetPixelMapfv, map, values));
2073 if (isCallValid)
2074 {
2075 context->getPixelMapfv(map, values);
2076 }
2077 ANGLE_CAPTURE_GL(GetPixelMapfv, isCallValid, context, map, values);
2078 }
2079 else
2080 {
2081 GenerateContextLostErrorOnCurrentGlobalContext();
2082 }
2083 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2084 }
2085
GL_GetPixelMapuiv(GLenum map,GLuint * values)2086 void GL_APIENTRY GL_GetPixelMapuiv(GLenum map, GLuint *values)
2087 {
2088 Context *context = GetValidGlobalContext();
2089 EVENT(context, GLGetPixelMapuiv, "context = %d, map = %s, values = 0x%016" PRIxPTR "",
2090 CID(context), GLenumToString(BigGLEnum::PixelMap, map), (uintptr_t)values);
2091
2092 if (context)
2093 {
2094 SCOPED_SHARE_CONTEXT_LOCK(context);
2095 bool isCallValid =
2096 (context->skipValidation() ||
2097 ValidateGetPixelMapuiv(context, angle::EntryPoint::GLGetPixelMapuiv, map, values));
2098 if (isCallValid)
2099 {
2100 context->getPixelMapuiv(map, values);
2101 }
2102 ANGLE_CAPTURE_GL(GetPixelMapuiv, isCallValid, context, map, values);
2103 }
2104 else
2105 {
2106 GenerateContextLostErrorOnCurrentGlobalContext();
2107 }
2108 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2109 }
2110
GL_GetPixelMapusv(GLenum map,GLushort * values)2111 void GL_APIENTRY GL_GetPixelMapusv(GLenum map, GLushort *values)
2112 {
2113 Context *context = GetValidGlobalContext();
2114 EVENT(context, GLGetPixelMapusv, "context = %d, map = %s, values = 0x%016" PRIxPTR "",
2115 CID(context), GLenumToString(BigGLEnum::PixelMap, map), (uintptr_t)values);
2116
2117 if (context)
2118 {
2119 SCOPED_SHARE_CONTEXT_LOCK(context);
2120 bool isCallValid =
2121 (context->skipValidation() ||
2122 ValidateGetPixelMapusv(context, angle::EntryPoint::GLGetPixelMapusv, map, values));
2123 if (isCallValid)
2124 {
2125 context->getPixelMapusv(map, values);
2126 }
2127 ANGLE_CAPTURE_GL(GetPixelMapusv, isCallValid, context, map, values);
2128 }
2129 else
2130 {
2131 GenerateContextLostErrorOnCurrentGlobalContext();
2132 }
2133 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2134 }
2135
GL_GetPolygonStipple(GLubyte * mask)2136 void GL_APIENTRY GL_GetPolygonStipple(GLubyte *mask)
2137 {
2138 Context *context = GetValidGlobalContext();
2139 EVENT(context, GLGetPolygonStipple, "context = %d, mask = 0x%016" PRIxPTR "", CID(context),
2140 (uintptr_t)mask);
2141
2142 if (context)
2143 {
2144 SCOPED_SHARE_CONTEXT_LOCK(context);
2145 bool isCallValid =
2146 (context->skipValidation() ||
2147 ValidateGetPolygonStipple(context, angle::EntryPoint::GLGetPolygonStipple, mask));
2148 if (isCallValid)
2149 {
2150 context->getPolygonStipple(mask);
2151 }
2152 ANGLE_CAPTURE_GL(GetPolygonStipple, isCallValid, context, mask);
2153 }
2154 else
2155 {
2156 GenerateContextLostErrorOnCurrentGlobalContext();
2157 }
2158 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2159 }
2160
GL_GetTexGendv(GLenum coord,GLenum pname,GLdouble * params)2161 void GL_APIENTRY GL_GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
2162 {
2163 Context *context = GetValidGlobalContext();
2164 EVENT(context, GLGetTexGendv,
2165 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2166 GLenumToString(BigGLEnum::TextureCoordName, coord),
2167 GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params);
2168
2169 if (context)
2170 {
2171 SCOPED_SHARE_CONTEXT_LOCK(context);
2172 bool isCallValid =
2173 (context->skipValidation() ||
2174 ValidateGetTexGendv(context, angle::EntryPoint::GLGetTexGendv, coord, pname, params));
2175 if (isCallValid)
2176 {
2177 context->getTexGendv(coord, pname, params);
2178 }
2179 ANGLE_CAPTURE_GL(GetTexGendv, isCallValid, context, coord, pname, params);
2180 }
2181 else
2182 {
2183 GenerateContextLostErrorOnCurrentGlobalContext();
2184 }
2185 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2186 }
2187
GL_GetTexGenfv(GLenum coord,GLenum pname,GLfloat * params)2188 void GL_APIENTRY GL_GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
2189 {
2190 Context *context = GetValidGlobalContext();
2191 EVENT(context, GLGetTexGenfv,
2192 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2193 GLenumToString(BigGLEnum::TextureCoordName, coord),
2194 GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params);
2195
2196 if (context)
2197 {
2198 SCOPED_SHARE_CONTEXT_LOCK(context);
2199 bool isCallValid =
2200 (context->skipValidation() ||
2201 ValidateGetTexGenfv(context, angle::EntryPoint::GLGetTexGenfv, coord, pname, params));
2202 if (isCallValid)
2203 {
2204 context->getTexGenfv(coord, pname, params);
2205 }
2206 ANGLE_CAPTURE_GL(GetTexGenfv, isCallValid, context, coord, pname, params);
2207 }
2208 else
2209 {
2210 GenerateContextLostErrorOnCurrentGlobalContext();
2211 }
2212 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2213 }
2214
GL_GetTexGeniv(GLenum coord,GLenum pname,GLint * params)2215 void GL_APIENTRY GL_GetTexGeniv(GLenum coord, GLenum pname, GLint *params)
2216 {
2217 Context *context = GetValidGlobalContext();
2218 EVENT(context, GLGetTexGeniv,
2219 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2220 GLenumToString(BigGLEnum::TextureCoordName, coord),
2221 GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params);
2222
2223 if (context)
2224 {
2225 SCOPED_SHARE_CONTEXT_LOCK(context);
2226 bool isCallValid =
2227 (context->skipValidation() ||
2228 ValidateGetTexGeniv(context, angle::EntryPoint::GLGetTexGeniv, coord, pname, params));
2229 if (isCallValid)
2230 {
2231 context->getTexGeniv(coord, pname, params);
2232 }
2233 ANGLE_CAPTURE_GL(GetTexGeniv, isCallValid, context, coord, pname, params);
2234 }
2235 else
2236 {
2237 GenerateContextLostErrorOnCurrentGlobalContext();
2238 }
2239 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2240 }
2241
2242 void GL_APIENTRY
GL_GetTexImage(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)2243 GL_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
2244 {
2245 Context *context = GetValidGlobalContext();
2246 EVENT(context, GLGetTexImage,
2247 "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR
2248 "",
2249 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level,
2250 GLenumToString(BigGLEnum::PixelFormat, format),
2251 GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels);
2252
2253 if (context)
2254 {
2255 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2256 SCOPED_SHARE_CONTEXT_LOCK(context);
2257 bool isCallValid = (context->skipValidation() ||
2258 ValidateGetTexImage(context, angle::EntryPoint::GLGetTexImage,
2259 targetPacked, level, format, type, pixels));
2260 if (isCallValid)
2261 {
2262 context->getTexImage(targetPacked, level, format, type, pixels);
2263 }
2264 ANGLE_CAPTURE_GL(GetTexImage, isCallValid, context, targetPacked, level, format, type,
2265 pixels);
2266 }
2267 else
2268 {
2269 GenerateContextLostErrorOnCurrentGlobalContext();
2270 }
2271 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2272 }
2273
GL_IndexMask(GLuint mask)2274 void GL_APIENTRY GL_IndexMask(GLuint mask)
2275 {
2276 Context *context = GetValidGlobalContext();
2277 EVENT(context, GLIndexMask, "context = %d, mask = %u", CID(context), mask);
2278
2279 if (context)
2280 {
2281 SCOPED_SHARE_CONTEXT_LOCK(context);
2282 bool isCallValid =
2283 (context->skipValidation() ||
2284 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2285 context->getMutableErrorSetForValidation(),
2286 angle::EntryPoint::GLIndexMask) &&
2287 ValidateIndexMask(context, angle::EntryPoint::GLIndexMask, mask)));
2288 if (isCallValid)
2289 {
2290 context->indexMask(mask);
2291 }
2292 ANGLE_CAPTURE_GL(IndexMask, isCallValid, context, mask);
2293 }
2294 else
2295 {
2296 GenerateContextLostErrorOnCurrentGlobalContext();
2297 }
2298 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2299 }
2300
GL_Indexd(GLdouble c)2301 void GL_APIENTRY GL_Indexd(GLdouble c)
2302 {
2303 Context *context = GetValidGlobalContext();
2304 EVENT(context, GLIndexd, "context = %d, c = %f", CID(context), c);
2305
2306 if (context)
2307 {
2308 SCOPED_SHARE_CONTEXT_LOCK(context);
2309 bool isCallValid =
2310 (context->skipValidation() ||
2311 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2312 context->getMutableErrorSetForValidation(),
2313 angle::EntryPoint::GLIndexd) &&
2314 ValidateIndexd(context, angle::EntryPoint::GLIndexd, c)));
2315 if (isCallValid)
2316 {
2317 context->indexd(c);
2318 }
2319 ANGLE_CAPTURE_GL(Indexd, isCallValid, context, c);
2320 }
2321 else
2322 {
2323 GenerateContextLostErrorOnCurrentGlobalContext();
2324 }
2325 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2326 }
2327
GL_Indexdv(const GLdouble * c)2328 void GL_APIENTRY GL_Indexdv(const GLdouble *c)
2329 {
2330 Context *context = GetValidGlobalContext();
2331 EVENT(context, GLIndexdv, "context = %d, c = 0x%016" PRIxPTR "", CID(context), (uintptr_t)c);
2332
2333 if (context)
2334 {
2335 SCOPED_SHARE_CONTEXT_LOCK(context);
2336 bool isCallValid =
2337 (context->skipValidation() ||
2338 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2339 context->getMutableErrorSetForValidation(),
2340 angle::EntryPoint::GLIndexdv) &&
2341 ValidateIndexdv(context, angle::EntryPoint::GLIndexdv, c)));
2342 if (isCallValid)
2343 {
2344 context->indexdv(c);
2345 }
2346 ANGLE_CAPTURE_GL(Indexdv, isCallValid, context, c);
2347 }
2348 else
2349 {
2350 GenerateContextLostErrorOnCurrentGlobalContext();
2351 }
2352 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2353 }
2354
GL_Indexf(GLfloat c)2355 void GL_APIENTRY GL_Indexf(GLfloat c)
2356 {
2357 Context *context = GetValidGlobalContext();
2358 EVENT(context, GLIndexf, "context = %d, c = %f", CID(context), c);
2359
2360 if (context)
2361 {
2362 SCOPED_SHARE_CONTEXT_LOCK(context);
2363 bool isCallValid =
2364 (context->skipValidation() ||
2365 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2366 context->getMutableErrorSetForValidation(),
2367 angle::EntryPoint::GLIndexf) &&
2368 ValidateIndexf(context, angle::EntryPoint::GLIndexf, c)));
2369 if (isCallValid)
2370 {
2371 context->indexf(c);
2372 }
2373 ANGLE_CAPTURE_GL(Indexf, isCallValid, context, c);
2374 }
2375 else
2376 {
2377 GenerateContextLostErrorOnCurrentGlobalContext();
2378 }
2379 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2380 }
2381
GL_Indexfv(const GLfloat * c)2382 void GL_APIENTRY GL_Indexfv(const GLfloat *c)
2383 {
2384 Context *context = GetValidGlobalContext();
2385 EVENT(context, GLIndexfv, "context = %d, c = 0x%016" PRIxPTR "", CID(context), (uintptr_t)c);
2386
2387 if (context)
2388 {
2389 SCOPED_SHARE_CONTEXT_LOCK(context);
2390 bool isCallValid =
2391 (context->skipValidation() ||
2392 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2393 context->getMutableErrorSetForValidation(),
2394 angle::EntryPoint::GLIndexfv) &&
2395 ValidateIndexfv(context, angle::EntryPoint::GLIndexfv, c)));
2396 if (isCallValid)
2397 {
2398 context->indexfv(c);
2399 }
2400 ANGLE_CAPTURE_GL(Indexfv, isCallValid, context, c);
2401 }
2402 else
2403 {
2404 GenerateContextLostErrorOnCurrentGlobalContext();
2405 }
2406 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2407 }
2408
GL_Indexi(GLint c)2409 void GL_APIENTRY GL_Indexi(GLint c)
2410 {
2411 Context *context = GetValidGlobalContext();
2412 EVENT(context, GLIndexi, "context = %d, c = %d", CID(context), c);
2413
2414 if (context)
2415 {
2416 SCOPED_SHARE_CONTEXT_LOCK(context);
2417 bool isCallValid =
2418 (context->skipValidation() ||
2419 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2420 context->getMutableErrorSetForValidation(),
2421 angle::EntryPoint::GLIndexi) &&
2422 ValidateIndexi(context, angle::EntryPoint::GLIndexi, c)));
2423 if (isCallValid)
2424 {
2425 context->indexi(c);
2426 }
2427 ANGLE_CAPTURE_GL(Indexi, isCallValid, context, c);
2428 }
2429 else
2430 {
2431 GenerateContextLostErrorOnCurrentGlobalContext();
2432 }
2433 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2434 }
2435
GL_Indexiv(const GLint * c)2436 void GL_APIENTRY GL_Indexiv(const GLint *c)
2437 {
2438 Context *context = GetValidGlobalContext();
2439 EVENT(context, GLIndexiv, "context = %d, c = 0x%016" PRIxPTR "", CID(context), (uintptr_t)c);
2440
2441 if (context)
2442 {
2443 SCOPED_SHARE_CONTEXT_LOCK(context);
2444 bool isCallValid =
2445 (context->skipValidation() ||
2446 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2447 context->getMutableErrorSetForValidation(),
2448 angle::EntryPoint::GLIndexiv) &&
2449 ValidateIndexiv(context, angle::EntryPoint::GLIndexiv, c)));
2450 if (isCallValid)
2451 {
2452 context->indexiv(c);
2453 }
2454 ANGLE_CAPTURE_GL(Indexiv, isCallValid, context, c);
2455 }
2456 else
2457 {
2458 GenerateContextLostErrorOnCurrentGlobalContext();
2459 }
2460 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2461 }
2462
GL_Indexs(GLshort c)2463 void GL_APIENTRY GL_Indexs(GLshort c)
2464 {
2465 Context *context = GetValidGlobalContext();
2466 EVENT(context, GLIndexs, "context = %d, c = %d", CID(context), c);
2467
2468 if (context)
2469 {
2470 SCOPED_SHARE_CONTEXT_LOCK(context);
2471 bool isCallValid =
2472 (context->skipValidation() ||
2473 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2474 context->getMutableErrorSetForValidation(),
2475 angle::EntryPoint::GLIndexs) &&
2476 ValidateIndexs(context, angle::EntryPoint::GLIndexs, c)));
2477 if (isCallValid)
2478 {
2479 context->indexs(c);
2480 }
2481 ANGLE_CAPTURE_GL(Indexs, isCallValid, context, c);
2482 }
2483 else
2484 {
2485 GenerateContextLostErrorOnCurrentGlobalContext();
2486 }
2487 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2488 }
2489
GL_Indexsv(const GLshort * c)2490 void GL_APIENTRY GL_Indexsv(const GLshort *c)
2491 {
2492 Context *context = GetValidGlobalContext();
2493 EVENT(context, GLIndexsv, "context = %d, c = 0x%016" PRIxPTR "", CID(context), (uintptr_t)c);
2494
2495 if (context)
2496 {
2497 SCOPED_SHARE_CONTEXT_LOCK(context);
2498 bool isCallValid =
2499 (context->skipValidation() ||
2500 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2501 context->getMutableErrorSetForValidation(),
2502 angle::EntryPoint::GLIndexsv) &&
2503 ValidateIndexsv(context, angle::EntryPoint::GLIndexsv, c)));
2504 if (isCallValid)
2505 {
2506 context->indexsv(c);
2507 }
2508 ANGLE_CAPTURE_GL(Indexsv, isCallValid, context, c);
2509 }
2510 else
2511 {
2512 GenerateContextLostErrorOnCurrentGlobalContext();
2513 }
2514 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2515 }
2516
GL_InitNames()2517 void GL_APIENTRY GL_InitNames()
2518 {
2519 Context *context = GetValidGlobalContext();
2520 EVENT(context, GLInitNames, "context = %d", CID(context));
2521
2522 if (context)
2523 {
2524 SCOPED_SHARE_CONTEXT_LOCK(context);
2525 bool isCallValid =
2526 (context->skipValidation() ||
2527 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2528 context->getMutableErrorSetForValidation(),
2529 angle::EntryPoint::GLInitNames) &&
2530 ValidateInitNames(context, angle::EntryPoint::GLInitNames)));
2531 if (isCallValid)
2532 {
2533 context->initNames();
2534 }
2535 ANGLE_CAPTURE_GL(InitNames, isCallValid, context);
2536 }
2537 else
2538 {
2539 GenerateContextLostErrorOnCurrentGlobalContext();
2540 }
2541 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2542 }
2543
GL_IsList(GLuint list)2544 GLboolean GL_APIENTRY GL_IsList(GLuint list)
2545 {
2546 Context *context = GetValidGlobalContext();
2547 EVENT(context, GLIsList, "context = %d, list = %u", CID(context), list);
2548
2549 GLboolean returnValue;
2550 if (context)
2551 {
2552 SCOPED_SHARE_CONTEXT_LOCK(context);
2553 bool isCallValid = (context->skipValidation() ||
2554 ValidateIsList(context, angle::EntryPoint::GLIsList, list));
2555 if (isCallValid)
2556 {
2557 returnValue = context->isList(list);
2558 }
2559 else
2560 {
2561 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsList, GLboolean>();
2562 }
2563 ANGLE_CAPTURE_GL(IsList, isCallValid, context, list, returnValue);
2564 }
2565 else
2566 {
2567 GenerateContextLostErrorOnCurrentGlobalContext();
2568 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsList, GLboolean>();
2569 }
2570 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2571 return returnValue;
2572 }
2573
GL_LightModeli(GLenum pname,GLint param)2574 void GL_APIENTRY GL_LightModeli(GLenum pname, GLint param)
2575 {
2576 Context *context = GetValidGlobalContext();
2577 EVENT(context, GLLightModeli, "context = %d, pname = %s, param = %d", CID(context),
2578 GLenumToString(BigGLEnum::LightModelParameter, pname), param);
2579
2580 if (context)
2581 {
2582 SCOPED_SHARE_CONTEXT_LOCK(context);
2583 bool isCallValid =
2584 (context->skipValidation() ||
2585 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2586 context->getMutableErrorSetForValidation(),
2587 angle::EntryPoint::GLLightModeli) &&
2588 ValidateLightModeli(context, angle::EntryPoint::GLLightModeli, pname, param)));
2589 if (isCallValid)
2590 {
2591 context->lightModeli(pname, param);
2592 }
2593 ANGLE_CAPTURE_GL(LightModeli, isCallValid, context, pname, param);
2594 }
2595 else
2596 {
2597 GenerateContextLostErrorOnCurrentGlobalContext();
2598 }
2599 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2600 }
2601
GL_LightModeliv(GLenum pname,const GLint * params)2602 void GL_APIENTRY GL_LightModeliv(GLenum pname, const GLint *params)
2603 {
2604 Context *context = GetValidGlobalContext();
2605 EVENT(context, GLLightModeliv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
2606 CID(context), GLenumToString(BigGLEnum::LightModelParameter, pname), (uintptr_t)params);
2607
2608 if (context)
2609 {
2610 SCOPED_SHARE_CONTEXT_LOCK(context);
2611 bool isCallValid =
2612 (context->skipValidation() ||
2613 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2614 context->getMutableErrorSetForValidation(),
2615 angle::EntryPoint::GLLightModeliv) &&
2616 ValidateLightModeliv(context, angle::EntryPoint::GLLightModeliv, pname, params)));
2617 if (isCallValid)
2618 {
2619 context->lightModeliv(pname, params);
2620 }
2621 ANGLE_CAPTURE_GL(LightModeliv, isCallValid, context, pname, params);
2622 }
2623 else
2624 {
2625 GenerateContextLostErrorOnCurrentGlobalContext();
2626 }
2627 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2628 }
2629
GL_Lighti(GLenum light,GLenum pname,GLint param)2630 void GL_APIENTRY GL_Lighti(GLenum light, GLenum pname, GLint param)
2631 {
2632 Context *context = GetValidGlobalContext();
2633 EVENT(context, GLLighti, "context = %d, light = %s, pname = %s, param = %d", CID(context),
2634 GLenumToString(BigGLEnum::LightName, light),
2635 GLenumToString(BigGLEnum::LightParameter, pname), param);
2636
2637 if (context)
2638 {
2639 SCOPED_SHARE_CONTEXT_LOCK(context);
2640 bool isCallValid =
2641 (context->skipValidation() ||
2642 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2643 context->getMutableErrorSetForValidation(),
2644 angle::EntryPoint::GLLighti) &&
2645 ValidateLighti(context, angle::EntryPoint::GLLighti, light, pname, param)));
2646 if (isCallValid)
2647 {
2648 context->lighti(light, pname, param);
2649 }
2650 ANGLE_CAPTURE_GL(Lighti, isCallValid, context, light, pname, param);
2651 }
2652 else
2653 {
2654 GenerateContextLostErrorOnCurrentGlobalContext();
2655 }
2656 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2657 }
2658
GL_Lightiv(GLenum light,GLenum pname,const GLint * params)2659 void GL_APIENTRY GL_Lightiv(GLenum light, GLenum pname, const GLint *params)
2660 {
2661 Context *context = GetValidGlobalContext();
2662 EVENT(context, GLLightiv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "",
2663 CID(context), GLenumToString(BigGLEnum::LightName, light),
2664 GLenumToString(BigGLEnum::LightParameter, pname), (uintptr_t)params);
2665
2666 if (context)
2667 {
2668 SCOPED_SHARE_CONTEXT_LOCK(context);
2669 bool isCallValid =
2670 (context->skipValidation() ||
2671 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2672 context->getMutableErrorSetForValidation(),
2673 angle::EntryPoint::GLLightiv) &&
2674 ValidateLightiv(context, angle::EntryPoint::GLLightiv, light, pname, params)));
2675 if (isCallValid)
2676 {
2677 context->lightiv(light, pname, params);
2678 }
2679 ANGLE_CAPTURE_GL(Lightiv, isCallValid, context, light, pname, params);
2680 }
2681 else
2682 {
2683 GenerateContextLostErrorOnCurrentGlobalContext();
2684 }
2685 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2686 }
2687
GL_LineStipple(GLint factor,GLushort pattern)2688 void GL_APIENTRY GL_LineStipple(GLint factor, GLushort pattern)
2689 {
2690 Context *context = GetValidGlobalContext();
2691 EVENT(context, GLLineStipple, "context = %d, factor = %d, pattern = %u", CID(context), factor,
2692 pattern);
2693
2694 if (context)
2695 {
2696 SCOPED_SHARE_CONTEXT_LOCK(context);
2697 bool isCallValid =
2698 (context->skipValidation() ||
2699 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2700 context->getMutableErrorSetForValidation(),
2701 angle::EntryPoint::GLLineStipple) &&
2702 ValidateLineStipple(context, angle::EntryPoint::GLLineStipple, factor, pattern)));
2703 if (isCallValid)
2704 {
2705 context->lineStipple(factor, pattern);
2706 }
2707 ANGLE_CAPTURE_GL(LineStipple, isCallValid, context, factor, pattern);
2708 }
2709 else
2710 {
2711 GenerateContextLostErrorOnCurrentGlobalContext();
2712 }
2713 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2714 }
2715
GL_ListBase(GLuint base)2716 void GL_APIENTRY GL_ListBase(GLuint base)
2717 {
2718 Context *context = GetValidGlobalContext();
2719 EVENT(context, GLListBase, "context = %d, base = %u", CID(context), base);
2720
2721 if (context)
2722 {
2723 SCOPED_SHARE_CONTEXT_LOCK(context);
2724 bool isCallValid =
2725 (context->skipValidation() ||
2726 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2727 context->getMutableErrorSetForValidation(),
2728 angle::EntryPoint::GLListBase) &&
2729 ValidateListBase(context, angle::EntryPoint::GLListBase, base)));
2730 if (isCallValid)
2731 {
2732 context->listBase(base);
2733 }
2734 ANGLE_CAPTURE_GL(ListBase, isCallValid, context, base);
2735 }
2736 else
2737 {
2738 GenerateContextLostErrorOnCurrentGlobalContext();
2739 }
2740 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2741 }
2742
GL_LoadMatrixd(const GLdouble * m)2743 void GL_APIENTRY GL_LoadMatrixd(const GLdouble *m)
2744 {
2745 Context *context = GetValidGlobalContext();
2746 EVENT(context, GLLoadMatrixd, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
2747 (uintptr_t)m);
2748
2749 if (context)
2750 {
2751 SCOPED_SHARE_CONTEXT_LOCK(context);
2752 bool isCallValid =
2753 (context->skipValidation() ||
2754 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2755 context->getMutableErrorSetForValidation(),
2756 angle::EntryPoint::GLLoadMatrixd) &&
2757 ValidateLoadMatrixd(context, angle::EntryPoint::GLLoadMatrixd, m)));
2758 if (isCallValid)
2759 {
2760 context->loadMatrixd(m);
2761 }
2762 ANGLE_CAPTURE_GL(LoadMatrixd, isCallValid, context, m);
2763 }
2764 else
2765 {
2766 GenerateContextLostErrorOnCurrentGlobalContext();
2767 }
2768 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2769 }
2770
GL_LoadName(GLuint name)2771 void GL_APIENTRY GL_LoadName(GLuint name)
2772 {
2773 Context *context = GetValidGlobalContext();
2774 EVENT(context, GLLoadName, "context = %d, name = %u", CID(context), name);
2775
2776 if (context)
2777 {
2778 SCOPED_SHARE_CONTEXT_LOCK(context);
2779 bool isCallValid =
2780 (context->skipValidation() ||
2781 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2782 context->getMutableErrorSetForValidation(),
2783 angle::EntryPoint::GLLoadName) &&
2784 ValidateLoadName(context, angle::EntryPoint::GLLoadName, name)));
2785 if (isCallValid)
2786 {
2787 context->loadName(name);
2788 }
2789 ANGLE_CAPTURE_GL(LoadName, isCallValid, context, name);
2790 }
2791 else
2792 {
2793 GenerateContextLostErrorOnCurrentGlobalContext();
2794 }
2795 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2796 }
2797
2798 void GL_APIENTRY
GL_Map1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble * points)2799 GL_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
2800 {
2801 Context *context = GetValidGlobalContext();
2802 EVENT(context, GLMap1d,
2803 "context = %d, target = %s, u1 = %f, u2 = %f, stride = %d, order = %d, points = "
2804 "0x%016" PRIxPTR "",
2805 CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, stride, order,
2806 (uintptr_t)points);
2807
2808 if (context)
2809 {
2810 SCOPED_SHARE_CONTEXT_LOCK(context);
2811 bool isCallValid =
2812 (context->skipValidation() ||
2813 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2814 context->getMutableErrorSetForValidation(),
2815 angle::EntryPoint::GLMap1d) &&
2816 ValidateMap1d(context, angle::EntryPoint::GLMap1d, target, u1, u2, stride, order,
2817 points)));
2818 if (isCallValid)
2819 {
2820 context->map1d(target, u1, u2, stride, order, points);
2821 }
2822 ANGLE_CAPTURE_GL(Map1d, isCallValid, context, target, u1, u2, stride, order, points);
2823 }
2824 else
2825 {
2826 GenerateContextLostErrorOnCurrentGlobalContext();
2827 }
2828 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2829 }
2830
2831 void GL_APIENTRY
GL_Map1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat * points)2832 GL_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
2833 {
2834 Context *context = GetValidGlobalContext();
2835 EVENT(context, GLMap1f,
2836 "context = %d, target = %s, u1 = %f, u2 = %f, stride = %d, order = %d, points = "
2837 "0x%016" PRIxPTR "",
2838 CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, stride, order,
2839 (uintptr_t)points);
2840
2841 if (context)
2842 {
2843 SCOPED_SHARE_CONTEXT_LOCK(context);
2844 bool isCallValid =
2845 (context->skipValidation() ||
2846 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2847 context->getMutableErrorSetForValidation(),
2848 angle::EntryPoint::GLMap1f) &&
2849 ValidateMap1f(context, angle::EntryPoint::GLMap1f, target, u1, u2, stride, order,
2850 points)));
2851 if (isCallValid)
2852 {
2853 context->map1f(target, u1, u2, stride, order, points);
2854 }
2855 ANGLE_CAPTURE_GL(Map1f, isCallValid, context, target, u1, u2, stride, order, points);
2856 }
2857 else
2858 {
2859 GenerateContextLostErrorOnCurrentGlobalContext();
2860 }
2861 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2862 }
2863
GL_Map2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble * points)2864 void GL_APIENTRY GL_Map2d(GLenum target,
2865 GLdouble u1,
2866 GLdouble u2,
2867 GLint ustride,
2868 GLint uorder,
2869 GLdouble v1,
2870 GLdouble v2,
2871 GLint vstride,
2872 GLint vorder,
2873 const GLdouble *points)
2874 {
2875 Context *context = GetValidGlobalContext();
2876 EVENT(context, GLMap2d,
2877 "context = %d, target = %s, u1 = %f, u2 = %f, ustride = %d, uorder = %d, v1 = %f, v2 = "
2878 "%f, vstride = %d, vorder = %d, points = 0x%016" PRIxPTR "",
2879 CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, ustride, uorder, v1,
2880 v2, vstride, vorder, (uintptr_t)points);
2881
2882 if (context)
2883 {
2884 SCOPED_SHARE_CONTEXT_LOCK(context);
2885 bool isCallValid =
2886 (context->skipValidation() ||
2887 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2888 context->getMutableErrorSetForValidation(),
2889 angle::EntryPoint::GLMap2d) &&
2890 ValidateMap2d(context, angle::EntryPoint::GLMap2d, target, u1, u2, ustride, uorder,
2891 v1, v2, vstride, vorder, points)));
2892 if (isCallValid)
2893 {
2894 context->map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
2895 }
2896 ANGLE_CAPTURE_GL(Map2d, isCallValid, context, target, u1, u2, ustride, uorder, v1, v2,
2897 vstride, vorder, points);
2898 }
2899 else
2900 {
2901 GenerateContextLostErrorOnCurrentGlobalContext();
2902 }
2903 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2904 }
2905
GL_Map2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat * points)2906 void GL_APIENTRY GL_Map2f(GLenum target,
2907 GLfloat u1,
2908 GLfloat u2,
2909 GLint ustride,
2910 GLint uorder,
2911 GLfloat v1,
2912 GLfloat v2,
2913 GLint vstride,
2914 GLint vorder,
2915 const GLfloat *points)
2916 {
2917 Context *context = GetValidGlobalContext();
2918 EVENT(context, GLMap2f,
2919 "context = %d, target = %s, u1 = %f, u2 = %f, ustride = %d, uorder = %d, v1 = %f, v2 = "
2920 "%f, vstride = %d, vorder = %d, points = 0x%016" PRIxPTR "",
2921 CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, ustride, uorder, v1,
2922 v2, vstride, vorder, (uintptr_t)points);
2923
2924 if (context)
2925 {
2926 SCOPED_SHARE_CONTEXT_LOCK(context);
2927 bool isCallValid =
2928 (context->skipValidation() ||
2929 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2930 context->getMutableErrorSetForValidation(),
2931 angle::EntryPoint::GLMap2f) &&
2932 ValidateMap2f(context, angle::EntryPoint::GLMap2f, target, u1, u2, ustride, uorder,
2933 v1, v2, vstride, vorder, points)));
2934 if (isCallValid)
2935 {
2936 context->map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
2937 }
2938 ANGLE_CAPTURE_GL(Map2f, isCallValid, context, target, u1, u2, ustride, uorder, v1, v2,
2939 vstride, vorder, points);
2940 }
2941 else
2942 {
2943 GenerateContextLostErrorOnCurrentGlobalContext();
2944 }
2945 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2946 }
2947
GL_MapGrid1d(GLint un,GLdouble u1,GLdouble u2)2948 void GL_APIENTRY GL_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2949 {
2950 Context *context = GetValidGlobalContext();
2951 EVENT(context, GLMapGrid1d, "context = %d, un = %d, u1 = %f, u2 = %f", CID(context), un, u1,
2952 u2);
2953
2954 if (context)
2955 {
2956 SCOPED_SHARE_CONTEXT_LOCK(context);
2957 bool isCallValid =
2958 (context->skipValidation() ||
2959 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2960 context->getMutableErrorSetForValidation(),
2961 angle::EntryPoint::GLMapGrid1d) &&
2962 ValidateMapGrid1d(context, angle::EntryPoint::GLMapGrid1d, un, u1, u2)));
2963 if (isCallValid)
2964 {
2965 context->mapGrid1d(un, u1, u2);
2966 }
2967 ANGLE_CAPTURE_GL(MapGrid1d, isCallValid, context, un, u1, u2);
2968 }
2969 else
2970 {
2971 GenerateContextLostErrorOnCurrentGlobalContext();
2972 }
2973 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2974 }
2975
GL_MapGrid1f(GLint un,GLfloat u1,GLfloat u2)2976 void GL_APIENTRY GL_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2977 {
2978 Context *context = GetValidGlobalContext();
2979 EVENT(context, GLMapGrid1f, "context = %d, un = %d, u1 = %f, u2 = %f", CID(context), un, u1,
2980 u2);
2981
2982 if (context)
2983 {
2984 SCOPED_SHARE_CONTEXT_LOCK(context);
2985 bool isCallValid =
2986 (context->skipValidation() ||
2987 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2988 context->getMutableErrorSetForValidation(),
2989 angle::EntryPoint::GLMapGrid1f) &&
2990 ValidateMapGrid1f(context, angle::EntryPoint::GLMapGrid1f, un, u1, u2)));
2991 if (isCallValid)
2992 {
2993 context->mapGrid1f(un, u1, u2);
2994 }
2995 ANGLE_CAPTURE_GL(MapGrid1f, isCallValid, context, un, u1, u2);
2996 }
2997 else
2998 {
2999 GenerateContextLostErrorOnCurrentGlobalContext();
3000 }
3001 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3002 }
3003
3004 void GL_APIENTRY
GL_MapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2)3005 GL_MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
3006 {
3007 Context *context = GetValidGlobalContext();
3008 EVENT(context, GLMapGrid2d,
3009 "context = %d, un = %d, u1 = %f, u2 = %f, vn = %d, v1 = %f, v2 = %f", CID(context), un,
3010 u1, u2, vn, v1, v2);
3011
3012 if (context)
3013 {
3014 SCOPED_SHARE_CONTEXT_LOCK(context);
3015 bool isCallValid =
3016 (context->skipValidation() ||
3017 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3018 context->getMutableErrorSetForValidation(),
3019 angle::EntryPoint::GLMapGrid2d) &&
3020 ValidateMapGrid2d(context, angle::EntryPoint::GLMapGrid2d, un, u1, u2, vn, v1, v2)));
3021 if (isCallValid)
3022 {
3023 context->mapGrid2d(un, u1, u2, vn, v1, v2);
3024 }
3025 ANGLE_CAPTURE_GL(MapGrid2d, isCallValid, context, un, u1, u2, vn, v1, v2);
3026 }
3027 else
3028 {
3029 GenerateContextLostErrorOnCurrentGlobalContext();
3030 }
3031 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3032 }
3033
GL_MapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2)3034 void GL_APIENTRY GL_MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
3035 {
3036 Context *context = GetValidGlobalContext();
3037 EVENT(context, GLMapGrid2f,
3038 "context = %d, un = %d, u1 = %f, u2 = %f, vn = %d, v1 = %f, v2 = %f", CID(context), un,
3039 u1, u2, vn, v1, v2);
3040
3041 if (context)
3042 {
3043 SCOPED_SHARE_CONTEXT_LOCK(context);
3044 bool isCallValid =
3045 (context->skipValidation() ||
3046 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3047 context->getMutableErrorSetForValidation(),
3048 angle::EntryPoint::GLMapGrid2f) &&
3049 ValidateMapGrid2f(context, angle::EntryPoint::GLMapGrid2f, un, u1, u2, vn, v1, v2)));
3050 if (isCallValid)
3051 {
3052 context->mapGrid2f(un, u1, u2, vn, v1, v2);
3053 }
3054 ANGLE_CAPTURE_GL(MapGrid2f, isCallValid, context, un, u1, u2, vn, v1, v2);
3055 }
3056 else
3057 {
3058 GenerateContextLostErrorOnCurrentGlobalContext();
3059 }
3060 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3061 }
3062
GL_Materiali(GLenum face,GLenum pname,GLint param)3063 void GL_APIENTRY GL_Materiali(GLenum face, GLenum pname, GLint param)
3064 {
3065 Context *context = GetValidGlobalContext();
3066 EVENT(context, GLMateriali, "context = %d, face = %s, pname = %s, param = %d", CID(context),
3067 GLenumToString(BigGLEnum::TriangleFace, face),
3068 GLenumToString(BigGLEnum::MaterialParameter, pname), param);
3069
3070 if (context)
3071 {
3072 SCOPED_SHARE_CONTEXT_LOCK(context);
3073 bool isCallValid =
3074 (context->skipValidation() ||
3075 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3076 context->getMutableErrorSetForValidation(),
3077 angle::EntryPoint::GLMateriali) &&
3078 ValidateMateriali(context, angle::EntryPoint::GLMateriali, face, pname, param)));
3079 if (isCallValid)
3080 {
3081 context->materiali(face, pname, param);
3082 }
3083 ANGLE_CAPTURE_GL(Materiali, isCallValid, context, face, pname, param);
3084 }
3085 else
3086 {
3087 GenerateContextLostErrorOnCurrentGlobalContext();
3088 }
3089 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3090 }
3091
GL_Materialiv(GLenum face,GLenum pname,const GLint * params)3092 void GL_APIENTRY GL_Materialiv(GLenum face, GLenum pname, const GLint *params)
3093 {
3094 Context *context = GetValidGlobalContext();
3095 EVENT(context, GLMaterialiv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "",
3096 CID(context), GLenumToString(BigGLEnum::TriangleFace, face),
3097 GLenumToString(BigGLEnum::MaterialParameter, pname), (uintptr_t)params);
3098
3099 if (context)
3100 {
3101 SCOPED_SHARE_CONTEXT_LOCK(context);
3102 bool isCallValid =
3103 (context->skipValidation() ||
3104 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3105 context->getMutableErrorSetForValidation(),
3106 angle::EntryPoint::GLMaterialiv) &&
3107 ValidateMaterialiv(context, angle::EntryPoint::GLMaterialiv, face, pname, params)));
3108 if (isCallValid)
3109 {
3110 context->materialiv(face, pname, params);
3111 }
3112 ANGLE_CAPTURE_GL(Materialiv, isCallValid, context, face, pname, params);
3113 }
3114 else
3115 {
3116 GenerateContextLostErrorOnCurrentGlobalContext();
3117 }
3118 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3119 }
3120
GL_MultMatrixd(const GLdouble * m)3121 void GL_APIENTRY GL_MultMatrixd(const GLdouble *m)
3122 {
3123 Context *context = GetValidGlobalContext();
3124 EVENT(context, GLMultMatrixd, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
3125 (uintptr_t)m);
3126
3127 if (context)
3128 {
3129 SCOPED_SHARE_CONTEXT_LOCK(context);
3130 bool isCallValid =
3131 (context->skipValidation() ||
3132 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3133 context->getMutableErrorSetForValidation(),
3134 angle::EntryPoint::GLMultMatrixd) &&
3135 ValidateMultMatrixd(context, angle::EntryPoint::GLMultMatrixd, m)));
3136 if (isCallValid)
3137 {
3138 context->multMatrixd(m);
3139 }
3140 ANGLE_CAPTURE_GL(MultMatrixd, isCallValid, context, m);
3141 }
3142 else
3143 {
3144 GenerateContextLostErrorOnCurrentGlobalContext();
3145 }
3146 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3147 }
3148
GL_NewList(GLuint list,GLenum mode)3149 void GL_APIENTRY GL_NewList(GLuint list, GLenum mode)
3150 {
3151 Context *context = GetValidGlobalContext();
3152 EVENT(context, GLNewList, "context = %d, list = %u, mode = %s", CID(context), list,
3153 GLenumToString(BigGLEnum::ListMode, mode));
3154
3155 if (context)
3156 {
3157 SCOPED_SHARE_CONTEXT_LOCK(context);
3158 bool isCallValid =
3159 (context->skipValidation() ||
3160 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3161 context->getMutableErrorSetForValidation(),
3162 angle::EntryPoint::GLNewList) &&
3163 ValidateNewList(context, angle::EntryPoint::GLNewList, list, mode)));
3164 if (isCallValid)
3165 {
3166 context->newList(list, mode);
3167 }
3168 ANGLE_CAPTURE_GL(NewList, isCallValid, context, list, mode);
3169 }
3170 else
3171 {
3172 GenerateContextLostErrorOnCurrentGlobalContext();
3173 }
3174 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3175 }
3176
GL_Normal3b(GLbyte nx,GLbyte ny,GLbyte nz)3177 void GL_APIENTRY GL_Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
3178 {
3179 Context *context = GetValidGlobalContext();
3180 EVENT(context, GLNormal3b, "context = %d, nx = %d, ny = %d, nz = %d", CID(context), nx, ny, nz);
3181
3182 if (context)
3183 {
3184 SCOPED_SHARE_CONTEXT_LOCK(context);
3185 bool isCallValid =
3186 (context->skipValidation() ||
3187 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3188 context->getMutableErrorSetForValidation(),
3189 angle::EntryPoint::GLNormal3b) &&
3190 ValidateNormal3b(context, angle::EntryPoint::GLNormal3b, nx, ny, nz)));
3191 if (isCallValid)
3192 {
3193 context->normal3b(nx, ny, nz);
3194 }
3195 ANGLE_CAPTURE_GL(Normal3b, isCallValid, context, nx, ny, nz);
3196 }
3197 else
3198 {
3199 GenerateContextLostErrorOnCurrentGlobalContext();
3200 }
3201 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3202 }
3203
GL_Normal3bv(const GLbyte * v)3204 void GL_APIENTRY GL_Normal3bv(const GLbyte *v)
3205 {
3206 Context *context = GetValidGlobalContext();
3207 EVENT(context, GLNormal3bv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
3208
3209 if (context)
3210 {
3211 SCOPED_SHARE_CONTEXT_LOCK(context);
3212 bool isCallValid =
3213 (context->skipValidation() ||
3214 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3215 context->getMutableErrorSetForValidation(),
3216 angle::EntryPoint::GLNormal3bv) &&
3217 ValidateNormal3bv(context, angle::EntryPoint::GLNormal3bv, v)));
3218 if (isCallValid)
3219 {
3220 context->normal3bv(v);
3221 }
3222 ANGLE_CAPTURE_GL(Normal3bv, isCallValid, context, v);
3223 }
3224 else
3225 {
3226 GenerateContextLostErrorOnCurrentGlobalContext();
3227 }
3228 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3229 }
3230
GL_Normal3d(GLdouble nx,GLdouble ny,GLdouble nz)3231 void GL_APIENTRY GL_Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
3232 {
3233 Context *context = GetValidGlobalContext();
3234 EVENT(context, GLNormal3d, "context = %d, nx = %f, ny = %f, nz = %f", CID(context), nx, ny, nz);
3235
3236 if (context)
3237 {
3238 SCOPED_SHARE_CONTEXT_LOCK(context);
3239 bool isCallValid =
3240 (context->skipValidation() ||
3241 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3242 context->getMutableErrorSetForValidation(),
3243 angle::EntryPoint::GLNormal3d) &&
3244 ValidateNormal3d(context, angle::EntryPoint::GLNormal3d, nx, ny, nz)));
3245 if (isCallValid)
3246 {
3247 context->normal3d(nx, ny, nz);
3248 }
3249 ANGLE_CAPTURE_GL(Normal3d, isCallValid, context, nx, ny, nz);
3250 }
3251 else
3252 {
3253 GenerateContextLostErrorOnCurrentGlobalContext();
3254 }
3255 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3256 }
3257
GL_Normal3dv(const GLdouble * v)3258 void GL_APIENTRY GL_Normal3dv(const GLdouble *v)
3259 {
3260 Context *context = GetValidGlobalContext();
3261 EVENT(context, GLNormal3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
3262
3263 if (context)
3264 {
3265 SCOPED_SHARE_CONTEXT_LOCK(context);
3266 bool isCallValid =
3267 (context->skipValidation() ||
3268 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3269 context->getMutableErrorSetForValidation(),
3270 angle::EntryPoint::GLNormal3dv) &&
3271 ValidateNormal3dv(context, angle::EntryPoint::GLNormal3dv, v)));
3272 if (isCallValid)
3273 {
3274 context->normal3dv(v);
3275 }
3276 ANGLE_CAPTURE_GL(Normal3dv, isCallValid, context, v);
3277 }
3278 else
3279 {
3280 GenerateContextLostErrorOnCurrentGlobalContext();
3281 }
3282 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3283 }
3284
GL_Normal3fv(const GLfloat * v)3285 void GL_APIENTRY GL_Normal3fv(const GLfloat *v)
3286 {
3287 Context *context = GetValidGlobalContext();
3288 EVENT(context, GLNormal3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
3289
3290 if (context)
3291 {
3292 SCOPED_SHARE_CONTEXT_LOCK(context);
3293 bool isCallValid =
3294 (context->skipValidation() ||
3295 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3296 context->getMutableErrorSetForValidation(),
3297 angle::EntryPoint::GLNormal3fv) &&
3298 ValidateNormal3fv(context, angle::EntryPoint::GLNormal3fv, v)));
3299 if (isCallValid)
3300 {
3301 context->normal3fv(v);
3302 }
3303 ANGLE_CAPTURE_GL(Normal3fv, isCallValid, context, v);
3304 }
3305 else
3306 {
3307 GenerateContextLostErrorOnCurrentGlobalContext();
3308 }
3309 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3310 }
3311
GL_Normal3i(GLint nx,GLint ny,GLint nz)3312 void GL_APIENTRY GL_Normal3i(GLint nx, GLint ny, GLint nz)
3313 {
3314 Context *context = GetValidGlobalContext();
3315 EVENT(context, GLNormal3i, "context = %d, nx = %d, ny = %d, nz = %d", CID(context), nx, ny, nz);
3316
3317 if (context)
3318 {
3319 SCOPED_SHARE_CONTEXT_LOCK(context);
3320 bool isCallValid =
3321 (context->skipValidation() ||
3322 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3323 context->getMutableErrorSetForValidation(),
3324 angle::EntryPoint::GLNormal3i) &&
3325 ValidateNormal3i(context, angle::EntryPoint::GLNormal3i, nx, ny, nz)));
3326 if (isCallValid)
3327 {
3328 context->normal3i(nx, ny, nz);
3329 }
3330 ANGLE_CAPTURE_GL(Normal3i, isCallValid, context, nx, ny, nz);
3331 }
3332 else
3333 {
3334 GenerateContextLostErrorOnCurrentGlobalContext();
3335 }
3336 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3337 }
3338
GL_Normal3iv(const GLint * v)3339 void GL_APIENTRY GL_Normal3iv(const GLint *v)
3340 {
3341 Context *context = GetValidGlobalContext();
3342 EVENT(context, GLNormal3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
3343
3344 if (context)
3345 {
3346 SCOPED_SHARE_CONTEXT_LOCK(context);
3347 bool isCallValid =
3348 (context->skipValidation() ||
3349 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3350 context->getMutableErrorSetForValidation(),
3351 angle::EntryPoint::GLNormal3iv) &&
3352 ValidateNormal3iv(context, angle::EntryPoint::GLNormal3iv, v)));
3353 if (isCallValid)
3354 {
3355 context->normal3iv(v);
3356 }
3357 ANGLE_CAPTURE_GL(Normal3iv, isCallValid, context, v);
3358 }
3359 else
3360 {
3361 GenerateContextLostErrorOnCurrentGlobalContext();
3362 }
3363 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3364 }
3365
GL_Normal3s(GLshort nx,GLshort ny,GLshort nz)3366 void GL_APIENTRY GL_Normal3s(GLshort nx, GLshort ny, GLshort nz)
3367 {
3368 Context *context = GetValidGlobalContext();
3369 EVENT(context, GLNormal3s, "context = %d, nx = %d, ny = %d, nz = %d", CID(context), nx, ny, nz);
3370
3371 if (context)
3372 {
3373 SCOPED_SHARE_CONTEXT_LOCK(context);
3374 bool isCallValid =
3375 (context->skipValidation() ||
3376 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3377 context->getMutableErrorSetForValidation(),
3378 angle::EntryPoint::GLNormal3s) &&
3379 ValidateNormal3s(context, angle::EntryPoint::GLNormal3s, nx, ny, nz)));
3380 if (isCallValid)
3381 {
3382 context->normal3s(nx, ny, nz);
3383 }
3384 ANGLE_CAPTURE_GL(Normal3s, isCallValid, context, nx, ny, nz);
3385 }
3386 else
3387 {
3388 GenerateContextLostErrorOnCurrentGlobalContext();
3389 }
3390 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3391 }
3392
GL_Normal3sv(const GLshort * v)3393 void GL_APIENTRY GL_Normal3sv(const GLshort *v)
3394 {
3395 Context *context = GetValidGlobalContext();
3396 EVENT(context, GLNormal3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
3397
3398 if (context)
3399 {
3400 SCOPED_SHARE_CONTEXT_LOCK(context);
3401 bool isCallValid =
3402 (context->skipValidation() ||
3403 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3404 context->getMutableErrorSetForValidation(),
3405 angle::EntryPoint::GLNormal3sv) &&
3406 ValidateNormal3sv(context, angle::EntryPoint::GLNormal3sv, v)));
3407 if (isCallValid)
3408 {
3409 context->normal3sv(v);
3410 }
3411 ANGLE_CAPTURE_GL(Normal3sv, isCallValid, context, v);
3412 }
3413 else
3414 {
3415 GenerateContextLostErrorOnCurrentGlobalContext();
3416 }
3417 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3418 }
3419
GL_Ortho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)3420 void GL_APIENTRY GL_Ortho(GLdouble left,
3421 GLdouble right,
3422 GLdouble bottom,
3423 GLdouble top,
3424 GLdouble zNear,
3425 GLdouble zFar)
3426 {
3427 Context *context = GetValidGlobalContext();
3428 EVENT(context, GLOrtho,
3429 "context = %d, left = %f, right = %f, bottom = %f, top = %f, zNear = %f, zFar = %f",
3430 CID(context), left, right, bottom, top, zNear, zFar);
3431
3432 if (context)
3433 {
3434 SCOPED_SHARE_CONTEXT_LOCK(context);
3435 bool isCallValid =
3436 (context->skipValidation() ||
3437 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3438 context->getMutableErrorSetForValidation(),
3439 angle::EntryPoint::GLOrtho) &&
3440 ValidateOrtho(context, angle::EntryPoint::GLOrtho, left, right, bottom, top, zNear,
3441 zFar)));
3442 if (isCallValid)
3443 {
3444 context->ortho(left, right, bottom, top, zNear, zFar);
3445 }
3446 ANGLE_CAPTURE_GL(Ortho, isCallValid, context, left, right, bottom, top, zNear, zFar);
3447 }
3448 else
3449 {
3450 GenerateContextLostErrorOnCurrentGlobalContext();
3451 }
3452 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3453 }
3454
GL_PassThrough(GLfloat token)3455 void GL_APIENTRY GL_PassThrough(GLfloat token)
3456 {
3457 Context *context = GetValidGlobalContext();
3458 EVENT(context, GLPassThrough, "context = %d, token = %f", CID(context), token);
3459
3460 if (context)
3461 {
3462 SCOPED_SHARE_CONTEXT_LOCK(context);
3463 bool isCallValid =
3464 (context->skipValidation() ||
3465 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3466 context->getMutableErrorSetForValidation(),
3467 angle::EntryPoint::GLPassThrough) &&
3468 ValidatePassThrough(context, angle::EntryPoint::GLPassThrough, token)));
3469 if (isCallValid)
3470 {
3471 context->passThrough(token);
3472 }
3473 ANGLE_CAPTURE_GL(PassThrough, isCallValid, context, token);
3474 }
3475 else
3476 {
3477 GenerateContextLostErrorOnCurrentGlobalContext();
3478 }
3479 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3480 }
3481
GL_PixelMapfv(GLenum map,GLsizei mapsize,const GLfloat * values)3482 void GL_APIENTRY GL_PixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
3483 {
3484 Context *context = GetValidGlobalContext();
3485 EVENT(context, GLPixelMapfv, "context = %d, map = %s, mapsize = %d, values = 0x%016" PRIxPTR "",
3486 CID(context), GLenumToString(BigGLEnum::PixelMap, map), mapsize, (uintptr_t)values);
3487
3488 if (context)
3489 {
3490 SCOPED_SHARE_CONTEXT_LOCK(context);
3491 bool isCallValid =
3492 (context->skipValidation() ||
3493 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3494 context->getMutableErrorSetForValidation(),
3495 angle::EntryPoint::GLPixelMapfv) &&
3496 ValidatePixelMapfv(context, angle::EntryPoint::GLPixelMapfv, map, mapsize, values)));
3497 if (isCallValid)
3498 {
3499 context->pixelMapfv(map, mapsize, values);
3500 }
3501 ANGLE_CAPTURE_GL(PixelMapfv, isCallValid, context, map, mapsize, values);
3502 }
3503 else
3504 {
3505 GenerateContextLostErrorOnCurrentGlobalContext();
3506 }
3507 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3508 }
3509
GL_PixelMapuiv(GLenum map,GLsizei mapsize,const GLuint * values)3510 void GL_APIENTRY GL_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
3511 {
3512 Context *context = GetValidGlobalContext();
3513 EVENT(context, GLPixelMapuiv,
3514 "context = %d, map = %s, mapsize = %d, values = 0x%016" PRIxPTR "", CID(context),
3515 GLenumToString(BigGLEnum::PixelMap, map), mapsize, (uintptr_t)values);
3516
3517 if (context)
3518 {
3519 SCOPED_SHARE_CONTEXT_LOCK(context);
3520 bool isCallValid =
3521 (context->skipValidation() ||
3522 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3523 context->getMutableErrorSetForValidation(),
3524 angle::EntryPoint::GLPixelMapuiv) &&
3525 ValidatePixelMapuiv(context, angle::EntryPoint::GLPixelMapuiv, map, mapsize,
3526 values)));
3527 if (isCallValid)
3528 {
3529 context->pixelMapuiv(map, mapsize, values);
3530 }
3531 ANGLE_CAPTURE_GL(PixelMapuiv, isCallValid, context, map, mapsize, values);
3532 }
3533 else
3534 {
3535 GenerateContextLostErrorOnCurrentGlobalContext();
3536 }
3537 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3538 }
3539
GL_PixelMapusv(GLenum map,GLsizei mapsize,const GLushort * values)3540 void GL_APIENTRY GL_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
3541 {
3542 Context *context = GetValidGlobalContext();
3543 EVENT(context, GLPixelMapusv,
3544 "context = %d, map = %s, mapsize = %d, values = 0x%016" PRIxPTR "", CID(context),
3545 GLenumToString(BigGLEnum::PixelMap, map), mapsize, (uintptr_t)values);
3546
3547 if (context)
3548 {
3549 SCOPED_SHARE_CONTEXT_LOCK(context);
3550 bool isCallValid =
3551 (context->skipValidation() ||
3552 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3553 context->getMutableErrorSetForValidation(),
3554 angle::EntryPoint::GLPixelMapusv) &&
3555 ValidatePixelMapusv(context, angle::EntryPoint::GLPixelMapusv, map, mapsize,
3556 values)));
3557 if (isCallValid)
3558 {
3559 context->pixelMapusv(map, mapsize, values);
3560 }
3561 ANGLE_CAPTURE_GL(PixelMapusv, isCallValid, context, map, mapsize, values);
3562 }
3563 else
3564 {
3565 GenerateContextLostErrorOnCurrentGlobalContext();
3566 }
3567 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3568 }
3569
GL_PixelStoref(GLenum pname,GLfloat param)3570 void GL_APIENTRY GL_PixelStoref(GLenum pname, GLfloat param)
3571 {
3572 Context *context = GetValidGlobalContext();
3573 EVENT(context, GLPixelStoref, "context = %d, pname = %s, param = %f", CID(context),
3574 GLenumToString(BigGLEnum::PixelStoreParameter, pname), param);
3575
3576 if (context)
3577 {
3578 SCOPED_SHARE_CONTEXT_LOCK(context);
3579 bool isCallValid =
3580 (context->skipValidation() ||
3581 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3582 context->getMutableErrorSetForValidation(),
3583 angle::EntryPoint::GLPixelStoref) &&
3584 ValidatePixelStoref(context, angle::EntryPoint::GLPixelStoref, pname, param)));
3585 if (isCallValid)
3586 {
3587 context->pixelStoref(pname, param);
3588 }
3589 ANGLE_CAPTURE_GL(PixelStoref, isCallValid, context, pname, param);
3590 }
3591 else
3592 {
3593 GenerateContextLostErrorOnCurrentGlobalContext();
3594 }
3595 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3596 }
3597
GL_PixelTransferf(GLenum pname,GLfloat param)3598 void GL_APIENTRY GL_PixelTransferf(GLenum pname, GLfloat param)
3599 {
3600 Context *context = GetValidGlobalContext();
3601 EVENT(context, GLPixelTransferf, "context = %d, pname = %s, param = %f", CID(context),
3602 GLenumToString(BigGLEnum::PixelTransferParameter, pname), param);
3603
3604 if (context)
3605 {
3606 SCOPED_SHARE_CONTEXT_LOCK(context);
3607 bool isCallValid =
3608 (context->skipValidation() ||
3609 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3610 context->getMutableErrorSetForValidation(),
3611 angle::EntryPoint::GLPixelTransferf) &&
3612 ValidatePixelTransferf(context, angle::EntryPoint::GLPixelTransferf, pname, param)));
3613 if (isCallValid)
3614 {
3615 context->pixelTransferf(pname, param);
3616 }
3617 ANGLE_CAPTURE_GL(PixelTransferf, isCallValid, context, pname, param);
3618 }
3619 else
3620 {
3621 GenerateContextLostErrorOnCurrentGlobalContext();
3622 }
3623 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3624 }
3625
GL_PixelTransferi(GLenum pname,GLint param)3626 void GL_APIENTRY GL_PixelTransferi(GLenum pname, GLint param)
3627 {
3628 Context *context = GetValidGlobalContext();
3629 EVENT(context, GLPixelTransferi, "context = %d, pname = %s, param = %d", CID(context),
3630 GLenumToString(BigGLEnum::PixelTransferParameter, pname), param);
3631
3632 if (context)
3633 {
3634 SCOPED_SHARE_CONTEXT_LOCK(context);
3635 bool isCallValid =
3636 (context->skipValidation() ||
3637 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3638 context->getMutableErrorSetForValidation(),
3639 angle::EntryPoint::GLPixelTransferi) &&
3640 ValidatePixelTransferi(context, angle::EntryPoint::GLPixelTransferi, pname, param)));
3641 if (isCallValid)
3642 {
3643 context->pixelTransferi(pname, param);
3644 }
3645 ANGLE_CAPTURE_GL(PixelTransferi, isCallValid, context, pname, param);
3646 }
3647 else
3648 {
3649 GenerateContextLostErrorOnCurrentGlobalContext();
3650 }
3651 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3652 }
3653
GL_PixelZoom(GLfloat xfactor,GLfloat yfactor)3654 void GL_APIENTRY GL_PixelZoom(GLfloat xfactor, GLfloat yfactor)
3655 {
3656 Context *context = GetValidGlobalContext();
3657 EVENT(context, GLPixelZoom, "context = %d, xfactor = %f, yfactor = %f", CID(context), xfactor,
3658 yfactor);
3659
3660 if (context)
3661 {
3662 SCOPED_SHARE_CONTEXT_LOCK(context);
3663 bool isCallValid =
3664 (context->skipValidation() ||
3665 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3666 context->getMutableErrorSetForValidation(),
3667 angle::EntryPoint::GLPixelZoom) &&
3668 ValidatePixelZoom(context, angle::EntryPoint::GLPixelZoom, xfactor, yfactor)));
3669 if (isCallValid)
3670 {
3671 context->pixelZoom(xfactor, yfactor);
3672 }
3673 ANGLE_CAPTURE_GL(PixelZoom, isCallValid, context, xfactor, yfactor);
3674 }
3675 else
3676 {
3677 GenerateContextLostErrorOnCurrentGlobalContext();
3678 }
3679 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3680 }
3681
GL_PolygonMode(GLenum face,GLenum mode)3682 void GL_APIENTRY GL_PolygonMode(GLenum face, GLenum mode)
3683 {
3684 Context *context = GetValidGlobalContext();
3685 EVENT(context, GLPolygonMode, "context = %d, face = %s, mode = %s", CID(context),
3686 GLenumToString(BigGLEnum::TriangleFace, face),
3687 GLenumToString(BigGLEnum::PolygonMode, mode));
3688
3689 if (context)
3690 {
3691 PolygonMode modePacked = PackParam<PolygonMode>(mode);
3692 bool isCallValid =
3693 (context->skipValidation() ||
3694 ValidatePolygonMode(context->getPrivateState(),
3695 context->getMutableErrorSetForValidation(),
3696 angle::EntryPoint::GLPolygonMode, face, modePacked));
3697 if (isCallValid)
3698 {
3699 ContextPrivatePolygonMode(context->getMutablePrivateState(),
3700 context->getMutablePrivateStateCache(), face, modePacked);
3701 }
3702 ANGLE_CAPTURE_GL(PolygonMode, isCallValid, context, face, modePacked);
3703 }
3704 else
3705 {
3706 GenerateContextLostErrorOnCurrentGlobalContext();
3707 }
3708 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3709 }
3710
GL_PolygonStipple(const GLubyte * mask)3711 void GL_APIENTRY GL_PolygonStipple(const GLubyte *mask)
3712 {
3713 Context *context = GetValidGlobalContext();
3714 EVENT(context, GLPolygonStipple, "context = %d, mask = 0x%016" PRIxPTR "", CID(context),
3715 (uintptr_t)mask);
3716
3717 if (context)
3718 {
3719 SCOPED_SHARE_CONTEXT_LOCK(context);
3720 bool isCallValid =
3721 (context->skipValidation() ||
3722 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3723 context->getMutableErrorSetForValidation(),
3724 angle::EntryPoint::GLPolygonStipple) &&
3725 ValidatePolygonStipple(context, angle::EntryPoint::GLPolygonStipple, mask)));
3726 if (isCallValid)
3727 {
3728 context->polygonStipple(mask);
3729 }
3730 ANGLE_CAPTURE_GL(PolygonStipple, isCallValid, context, mask);
3731 }
3732 else
3733 {
3734 GenerateContextLostErrorOnCurrentGlobalContext();
3735 }
3736 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3737 }
3738
GL_PopAttrib()3739 void GL_APIENTRY GL_PopAttrib()
3740 {
3741 Context *context = GetValidGlobalContext();
3742 EVENT(context, GLPopAttrib, "context = %d", CID(context));
3743
3744 if (context)
3745 {
3746 SCOPED_SHARE_CONTEXT_LOCK(context);
3747 bool isCallValid =
3748 (context->skipValidation() ||
3749 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3750 context->getMutableErrorSetForValidation(),
3751 angle::EntryPoint::GLPopAttrib) &&
3752 ValidatePopAttrib(context, angle::EntryPoint::GLPopAttrib)));
3753 if (isCallValid)
3754 {
3755 context->popAttrib();
3756 }
3757 ANGLE_CAPTURE_GL(PopAttrib, isCallValid, context);
3758 }
3759 else
3760 {
3761 GenerateContextLostErrorOnCurrentGlobalContext();
3762 }
3763 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3764 }
3765
GL_PopName()3766 void GL_APIENTRY GL_PopName()
3767 {
3768 Context *context = GetValidGlobalContext();
3769 EVENT(context, GLPopName, "context = %d", CID(context));
3770
3771 if (context)
3772 {
3773 SCOPED_SHARE_CONTEXT_LOCK(context);
3774 bool isCallValid =
3775 (context->skipValidation() ||
3776 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3777 context->getMutableErrorSetForValidation(),
3778 angle::EntryPoint::GLPopName) &&
3779 ValidatePopName(context, angle::EntryPoint::GLPopName)));
3780 if (isCallValid)
3781 {
3782 context->popName();
3783 }
3784 ANGLE_CAPTURE_GL(PopName, isCallValid, context);
3785 }
3786 else
3787 {
3788 GenerateContextLostErrorOnCurrentGlobalContext();
3789 }
3790 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3791 }
3792
GL_PushAttrib(GLbitfield mask)3793 void GL_APIENTRY GL_PushAttrib(GLbitfield mask)
3794 {
3795 Context *context = GetValidGlobalContext();
3796 EVENT(context, GLPushAttrib, "context = %d, mask = %s", CID(context),
3797 GLbitfieldToString(BigGLEnum::AttribMask, mask).c_str());
3798
3799 if (context)
3800 {
3801 SCOPED_SHARE_CONTEXT_LOCK(context);
3802 bool isCallValid =
3803 (context->skipValidation() ||
3804 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3805 context->getMutableErrorSetForValidation(),
3806 angle::EntryPoint::GLPushAttrib) &&
3807 ValidatePushAttrib(context, angle::EntryPoint::GLPushAttrib, mask)));
3808 if (isCallValid)
3809 {
3810 context->pushAttrib(mask);
3811 }
3812 ANGLE_CAPTURE_GL(PushAttrib, isCallValid, context, mask);
3813 }
3814 else
3815 {
3816 GenerateContextLostErrorOnCurrentGlobalContext();
3817 }
3818 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3819 }
3820
GL_PushName(GLuint name)3821 void GL_APIENTRY GL_PushName(GLuint name)
3822 {
3823 Context *context = GetValidGlobalContext();
3824 EVENT(context, GLPushName, "context = %d, name = %u", CID(context), name);
3825
3826 if (context)
3827 {
3828 SCOPED_SHARE_CONTEXT_LOCK(context);
3829 bool isCallValid =
3830 (context->skipValidation() ||
3831 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3832 context->getMutableErrorSetForValidation(),
3833 angle::EntryPoint::GLPushName) &&
3834 ValidatePushName(context, angle::EntryPoint::GLPushName, name)));
3835 if (isCallValid)
3836 {
3837 context->pushName(name);
3838 }
3839 ANGLE_CAPTURE_GL(PushName, isCallValid, context, name);
3840 }
3841 else
3842 {
3843 GenerateContextLostErrorOnCurrentGlobalContext();
3844 }
3845 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3846 }
3847
GL_RasterPos2d(GLdouble x,GLdouble y)3848 void GL_APIENTRY GL_RasterPos2d(GLdouble x, GLdouble y)
3849 {
3850 Context *context = GetValidGlobalContext();
3851 EVENT(context, GLRasterPos2d, "context = %d, x = %f, y = %f", CID(context), x, y);
3852
3853 if (context)
3854 {
3855 SCOPED_SHARE_CONTEXT_LOCK(context);
3856 bool isCallValid =
3857 (context->skipValidation() ||
3858 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3859 context->getMutableErrorSetForValidation(),
3860 angle::EntryPoint::GLRasterPos2d) &&
3861 ValidateRasterPos2d(context, angle::EntryPoint::GLRasterPos2d, x, y)));
3862 if (isCallValid)
3863 {
3864 context->rasterPos2d(x, y);
3865 }
3866 ANGLE_CAPTURE_GL(RasterPos2d, isCallValid, context, x, y);
3867 }
3868 else
3869 {
3870 GenerateContextLostErrorOnCurrentGlobalContext();
3871 }
3872 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3873 }
3874
GL_RasterPos2dv(const GLdouble * v)3875 void GL_APIENTRY GL_RasterPos2dv(const GLdouble *v)
3876 {
3877 Context *context = GetValidGlobalContext();
3878 EVENT(context, GLRasterPos2dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
3879 (uintptr_t)v);
3880
3881 if (context)
3882 {
3883 SCOPED_SHARE_CONTEXT_LOCK(context);
3884 bool isCallValid =
3885 (context->skipValidation() ||
3886 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3887 context->getMutableErrorSetForValidation(),
3888 angle::EntryPoint::GLRasterPos2dv) &&
3889 ValidateRasterPos2dv(context, angle::EntryPoint::GLRasterPos2dv, v)));
3890 if (isCallValid)
3891 {
3892 context->rasterPos2dv(v);
3893 }
3894 ANGLE_CAPTURE_GL(RasterPos2dv, isCallValid, context, v);
3895 }
3896 else
3897 {
3898 GenerateContextLostErrorOnCurrentGlobalContext();
3899 }
3900 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3901 }
3902
GL_RasterPos2f(GLfloat x,GLfloat y)3903 void GL_APIENTRY GL_RasterPos2f(GLfloat x, GLfloat y)
3904 {
3905 Context *context = GetValidGlobalContext();
3906 EVENT(context, GLRasterPos2f, "context = %d, x = %f, y = %f", CID(context), x, y);
3907
3908 if (context)
3909 {
3910 SCOPED_SHARE_CONTEXT_LOCK(context);
3911 bool isCallValid =
3912 (context->skipValidation() ||
3913 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3914 context->getMutableErrorSetForValidation(),
3915 angle::EntryPoint::GLRasterPos2f) &&
3916 ValidateRasterPos2f(context, angle::EntryPoint::GLRasterPos2f, x, y)));
3917 if (isCallValid)
3918 {
3919 context->rasterPos2f(x, y);
3920 }
3921 ANGLE_CAPTURE_GL(RasterPos2f, isCallValid, context, x, y);
3922 }
3923 else
3924 {
3925 GenerateContextLostErrorOnCurrentGlobalContext();
3926 }
3927 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3928 }
3929
GL_RasterPos2fv(const GLfloat * v)3930 void GL_APIENTRY GL_RasterPos2fv(const GLfloat *v)
3931 {
3932 Context *context = GetValidGlobalContext();
3933 EVENT(context, GLRasterPos2fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
3934 (uintptr_t)v);
3935
3936 if (context)
3937 {
3938 SCOPED_SHARE_CONTEXT_LOCK(context);
3939 bool isCallValid =
3940 (context->skipValidation() ||
3941 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3942 context->getMutableErrorSetForValidation(),
3943 angle::EntryPoint::GLRasterPos2fv) &&
3944 ValidateRasterPos2fv(context, angle::EntryPoint::GLRasterPos2fv, v)));
3945 if (isCallValid)
3946 {
3947 context->rasterPos2fv(v);
3948 }
3949 ANGLE_CAPTURE_GL(RasterPos2fv, isCallValid, context, v);
3950 }
3951 else
3952 {
3953 GenerateContextLostErrorOnCurrentGlobalContext();
3954 }
3955 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3956 }
3957
GL_RasterPos2i(GLint x,GLint y)3958 void GL_APIENTRY GL_RasterPos2i(GLint x, GLint y)
3959 {
3960 Context *context = GetValidGlobalContext();
3961 EVENT(context, GLRasterPos2i, "context = %d, x = %d, y = %d", CID(context), x, y);
3962
3963 if (context)
3964 {
3965 SCOPED_SHARE_CONTEXT_LOCK(context);
3966 bool isCallValid =
3967 (context->skipValidation() ||
3968 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3969 context->getMutableErrorSetForValidation(),
3970 angle::EntryPoint::GLRasterPos2i) &&
3971 ValidateRasterPos2i(context, angle::EntryPoint::GLRasterPos2i, x, y)));
3972 if (isCallValid)
3973 {
3974 context->rasterPos2i(x, y);
3975 }
3976 ANGLE_CAPTURE_GL(RasterPos2i, isCallValid, context, x, y);
3977 }
3978 else
3979 {
3980 GenerateContextLostErrorOnCurrentGlobalContext();
3981 }
3982 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3983 }
3984
GL_RasterPos2iv(const GLint * v)3985 void GL_APIENTRY GL_RasterPos2iv(const GLint *v)
3986 {
3987 Context *context = GetValidGlobalContext();
3988 EVENT(context, GLRasterPos2iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
3989 (uintptr_t)v);
3990
3991 if (context)
3992 {
3993 SCOPED_SHARE_CONTEXT_LOCK(context);
3994 bool isCallValid =
3995 (context->skipValidation() ||
3996 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3997 context->getMutableErrorSetForValidation(),
3998 angle::EntryPoint::GLRasterPos2iv) &&
3999 ValidateRasterPos2iv(context, angle::EntryPoint::GLRasterPos2iv, v)));
4000 if (isCallValid)
4001 {
4002 context->rasterPos2iv(v);
4003 }
4004 ANGLE_CAPTURE_GL(RasterPos2iv, isCallValid, context, v);
4005 }
4006 else
4007 {
4008 GenerateContextLostErrorOnCurrentGlobalContext();
4009 }
4010 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4011 }
4012
GL_RasterPos2s(GLshort x,GLshort y)4013 void GL_APIENTRY GL_RasterPos2s(GLshort x, GLshort y)
4014 {
4015 Context *context = GetValidGlobalContext();
4016 EVENT(context, GLRasterPos2s, "context = %d, x = %d, y = %d", CID(context), x, y);
4017
4018 if (context)
4019 {
4020 SCOPED_SHARE_CONTEXT_LOCK(context);
4021 bool isCallValid =
4022 (context->skipValidation() ||
4023 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4024 context->getMutableErrorSetForValidation(),
4025 angle::EntryPoint::GLRasterPos2s) &&
4026 ValidateRasterPos2s(context, angle::EntryPoint::GLRasterPos2s, x, y)));
4027 if (isCallValid)
4028 {
4029 context->rasterPos2s(x, y);
4030 }
4031 ANGLE_CAPTURE_GL(RasterPos2s, isCallValid, context, x, y);
4032 }
4033 else
4034 {
4035 GenerateContextLostErrorOnCurrentGlobalContext();
4036 }
4037 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4038 }
4039
GL_RasterPos2sv(const GLshort * v)4040 void GL_APIENTRY GL_RasterPos2sv(const GLshort *v)
4041 {
4042 Context *context = GetValidGlobalContext();
4043 EVENT(context, GLRasterPos2sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4044 (uintptr_t)v);
4045
4046 if (context)
4047 {
4048 SCOPED_SHARE_CONTEXT_LOCK(context);
4049 bool isCallValid =
4050 (context->skipValidation() ||
4051 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4052 context->getMutableErrorSetForValidation(),
4053 angle::EntryPoint::GLRasterPos2sv) &&
4054 ValidateRasterPos2sv(context, angle::EntryPoint::GLRasterPos2sv, v)));
4055 if (isCallValid)
4056 {
4057 context->rasterPos2sv(v);
4058 }
4059 ANGLE_CAPTURE_GL(RasterPos2sv, isCallValid, context, v);
4060 }
4061 else
4062 {
4063 GenerateContextLostErrorOnCurrentGlobalContext();
4064 }
4065 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4066 }
4067
GL_RasterPos3d(GLdouble x,GLdouble y,GLdouble z)4068 void GL_APIENTRY GL_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
4069 {
4070 Context *context = GetValidGlobalContext();
4071 EVENT(context, GLRasterPos3d, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
4072
4073 if (context)
4074 {
4075 SCOPED_SHARE_CONTEXT_LOCK(context);
4076 bool isCallValid =
4077 (context->skipValidation() ||
4078 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4079 context->getMutableErrorSetForValidation(),
4080 angle::EntryPoint::GLRasterPos3d) &&
4081 ValidateRasterPos3d(context, angle::EntryPoint::GLRasterPos3d, x, y, z)));
4082 if (isCallValid)
4083 {
4084 context->rasterPos3d(x, y, z);
4085 }
4086 ANGLE_CAPTURE_GL(RasterPos3d, isCallValid, context, x, y, z);
4087 }
4088 else
4089 {
4090 GenerateContextLostErrorOnCurrentGlobalContext();
4091 }
4092 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4093 }
4094
GL_RasterPos3dv(const GLdouble * v)4095 void GL_APIENTRY GL_RasterPos3dv(const GLdouble *v)
4096 {
4097 Context *context = GetValidGlobalContext();
4098 EVENT(context, GLRasterPos3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4099 (uintptr_t)v);
4100
4101 if (context)
4102 {
4103 SCOPED_SHARE_CONTEXT_LOCK(context);
4104 bool isCallValid =
4105 (context->skipValidation() ||
4106 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4107 context->getMutableErrorSetForValidation(),
4108 angle::EntryPoint::GLRasterPos3dv) &&
4109 ValidateRasterPos3dv(context, angle::EntryPoint::GLRasterPos3dv, v)));
4110 if (isCallValid)
4111 {
4112 context->rasterPos3dv(v);
4113 }
4114 ANGLE_CAPTURE_GL(RasterPos3dv, isCallValid, context, v);
4115 }
4116 else
4117 {
4118 GenerateContextLostErrorOnCurrentGlobalContext();
4119 }
4120 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4121 }
4122
GL_RasterPos3f(GLfloat x,GLfloat y,GLfloat z)4123 void GL_APIENTRY GL_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
4124 {
4125 Context *context = GetValidGlobalContext();
4126 EVENT(context, GLRasterPos3f, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
4127
4128 if (context)
4129 {
4130 SCOPED_SHARE_CONTEXT_LOCK(context);
4131 bool isCallValid =
4132 (context->skipValidation() ||
4133 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4134 context->getMutableErrorSetForValidation(),
4135 angle::EntryPoint::GLRasterPos3f) &&
4136 ValidateRasterPos3f(context, angle::EntryPoint::GLRasterPos3f, x, y, z)));
4137 if (isCallValid)
4138 {
4139 context->rasterPos3f(x, y, z);
4140 }
4141 ANGLE_CAPTURE_GL(RasterPos3f, isCallValid, context, x, y, z);
4142 }
4143 else
4144 {
4145 GenerateContextLostErrorOnCurrentGlobalContext();
4146 }
4147 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4148 }
4149
GL_RasterPos3fv(const GLfloat * v)4150 void GL_APIENTRY GL_RasterPos3fv(const GLfloat *v)
4151 {
4152 Context *context = GetValidGlobalContext();
4153 EVENT(context, GLRasterPos3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4154 (uintptr_t)v);
4155
4156 if (context)
4157 {
4158 SCOPED_SHARE_CONTEXT_LOCK(context);
4159 bool isCallValid =
4160 (context->skipValidation() ||
4161 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4162 context->getMutableErrorSetForValidation(),
4163 angle::EntryPoint::GLRasterPos3fv) &&
4164 ValidateRasterPos3fv(context, angle::EntryPoint::GLRasterPos3fv, v)));
4165 if (isCallValid)
4166 {
4167 context->rasterPos3fv(v);
4168 }
4169 ANGLE_CAPTURE_GL(RasterPos3fv, isCallValid, context, v);
4170 }
4171 else
4172 {
4173 GenerateContextLostErrorOnCurrentGlobalContext();
4174 }
4175 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4176 }
4177
GL_RasterPos3i(GLint x,GLint y,GLint z)4178 void GL_APIENTRY GL_RasterPos3i(GLint x, GLint y, GLint z)
4179 {
4180 Context *context = GetValidGlobalContext();
4181 EVENT(context, GLRasterPos3i, "context = %d, x = %d, y = %d, z = %d", CID(context), x, y, z);
4182
4183 if (context)
4184 {
4185 SCOPED_SHARE_CONTEXT_LOCK(context);
4186 bool isCallValid =
4187 (context->skipValidation() ||
4188 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4189 context->getMutableErrorSetForValidation(),
4190 angle::EntryPoint::GLRasterPos3i) &&
4191 ValidateRasterPos3i(context, angle::EntryPoint::GLRasterPos3i, x, y, z)));
4192 if (isCallValid)
4193 {
4194 context->rasterPos3i(x, y, z);
4195 }
4196 ANGLE_CAPTURE_GL(RasterPos3i, isCallValid, context, x, y, z);
4197 }
4198 else
4199 {
4200 GenerateContextLostErrorOnCurrentGlobalContext();
4201 }
4202 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4203 }
4204
GL_RasterPos3iv(const GLint * v)4205 void GL_APIENTRY GL_RasterPos3iv(const GLint *v)
4206 {
4207 Context *context = GetValidGlobalContext();
4208 EVENT(context, GLRasterPos3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4209 (uintptr_t)v);
4210
4211 if (context)
4212 {
4213 SCOPED_SHARE_CONTEXT_LOCK(context);
4214 bool isCallValid =
4215 (context->skipValidation() ||
4216 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4217 context->getMutableErrorSetForValidation(),
4218 angle::EntryPoint::GLRasterPos3iv) &&
4219 ValidateRasterPos3iv(context, angle::EntryPoint::GLRasterPos3iv, v)));
4220 if (isCallValid)
4221 {
4222 context->rasterPos3iv(v);
4223 }
4224 ANGLE_CAPTURE_GL(RasterPos3iv, isCallValid, context, v);
4225 }
4226 else
4227 {
4228 GenerateContextLostErrorOnCurrentGlobalContext();
4229 }
4230 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4231 }
4232
GL_RasterPos3s(GLshort x,GLshort y,GLshort z)4233 void GL_APIENTRY GL_RasterPos3s(GLshort x, GLshort y, GLshort z)
4234 {
4235 Context *context = GetValidGlobalContext();
4236 EVENT(context, GLRasterPos3s, "context = %d, x = %d, y = %d, z = %d", CID(context), x, y, z);
4237
4238 if (context)
4239 {
4240 SCOPED_SHARE_CONTEXT_LOCK(context);
4241 bool isCallValid =
4242 (context->skipValidation() ||
4243 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4244 context->getMutableErrorSetForValidation(),
4245 angle::EntryPoint::GLRasterPos3s) &&
4246 ValidateRasterPos3s(context, angle::EntryPoint::GLRasterPos3s, x, y, z)));
4247 if (isCallValid)
4248 {
4249 context->rasterPos3s(x, y, z);
4250 }
4251 ANGLE_CAPTURE_GL(RasterPos3s, isCallValid, context, x, y, z);
4252 }
4253 else
4254 {
4255 GenerateContextLostErrorOnCurrentGlobalContext();
4256 }
4257 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4258 }
4259
GL_RasterPos3sv(const GLshort * v)4260 void GL_APIENTRY GL_RasterPos3sv(const GLshort *v)
4261 {
4262 Context *context = GetValidGlobalContext();
4263 EVENT(context, GLRasterPos3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4264 (uintptr_t)v);
4265
4266 if (context)
4267 {
4268 SCOPED_SHARE_CONTEXT_LOCK(context);
4269 bool isCallValid =
4270 (context->skipValidation() ||
4271 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4272 context->getMutableErrorSetForValidation(),
4273 angle::EntryPoint::GLRasterPos3sv) &&
4274 ValidateRasterPos3sv(context, angle::EntryPoint::GLRasterPos3sv, v)));
4275 if (isCallValid)
4276 {
4277 context->rasterPos3sv(v);
4278 }
4279 ANGLE_CAPTURE_GL(RasterPos3sv, isCallValid, context, v);
4280 }
4281 else
4282 {
4283 GenerateContextLostErrorOnCurrentGlobalContext();
4284 }
4285 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4286 }
4287
GL_RasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)4288 void GL_APIENTRY GL_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
4289 {
4290 Context *context = GetValidGlobalContext();
4291 EVENT(context, GLRasterPos4d, "context = %d, x = %f, y = %f, z = %f, w = %f", CID(context), x,
4292 y, z, w);
4293
4294 if (context)
4295 {
4296 SCOPED_SHARE_CONTEXT_LOCK(context);
4297 bool isCallValid =
4298 (context->skipValidation() ||
4299 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4300 context->getMutableErrorSetForValidation(),
4301 angle::EntryPoint::GLRasterPos4d) &&
4302 ValidateRasterPos4d(context, angle::EntryPoint::GLRasterPos4d, x, y, z, w)));
4303 if (isCallValid)
4304 {
4305 context->rasterPos4d(x, y, z, w);
4306 }
4307 ANGLE_CAPTURE_GL(RasterPos4d, isCallValid, context, x, y, z, w);
4308 }
4309 else
4310 {
4311 GenerateContextLostErrorOnCurrentGlobalContext();
4312 }
4313 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4314 }
4315
GL_RasterPos4dv(const GLdouble * v)4316 void GL_APIENTRY GL_RasterPos4dv(const GLdouble *v)
4317 {
4318 Context *context = GetValidGlobalContext();
4319 EVENT(context, GLRasterPos4dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4320 (uintptr_t)v);
4321
4322 if (context)
4323 {
4324 SCOPED_SHARE_CONTEXT_LOCK(context);
4325 bool isCallValid =
4326 (context->skipValidation() ||
4327 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4328 context->getMutableErrorSetForValidation(),
4329 angle::EntryPoint::GLRasterPos4dv) &&
4330 ValidateRasterPos4dv(context, angle::EntryPoint::GLRasterPos4dv, v)));
4331 if (isCallValid)
4332 {
4333 context->rasterPos4dv(v);
4334 }
4335 ANGLE_CAPTURE_GL(RasterPos4dv, isCallValid, context, v);
4336 }
4337 else
4338 {
4339 GenerateContextLostErrorOnCurrentGlobalContext();
4340 }
4341 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4342 }
4343
GL_RasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)4344 void GL_APIENTRY GL_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4345 {
4346 Context *context = GetValidGlobalContext();
4347 EVENT(context, GLRasterPos4f, "context = %d, x = %f, y = %f, z = %f, w = %f", CID(context), x,
4348 y, z, w);
4349
4350 if (context)
4351 {
4352 SCOPED_SHARE_CONTEXT_LOCK(context);
4353 bool isCallValid =
4354 (context->skipValidation() ||
4355 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4356 context->getMutableErrorSetForValidation(),
4357 angle::EntryPoint::GLRasterPos4f) &&
4358 ValidateRasterPos4f(context, angle::EntryPoint::GLRasterPos4f, x, y, z, w)));
4359 if (isCallValid)
4360 {
4361 context->rasterPos4f(x, y, z, w);
4362 }
4363 ANGLE_CAPTURE_GL(RasterPos4f, isCallValid, context, x, y, z, w);
4364 }
4365 else
4366 {
4367 GenerateContextLostErrorOnCurrentGlobalContext();
4368 }
4369 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4370 }
4371
GL_RasterPos4fv(const GLfloat * v)4372 void GL_APIENTRY GL_RasterPos4fv(const GLfloat *v)
4373 {
4374 Context *context = GetValidGlobalContext();
4375 EVENT(context, GLRasterPos4fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4376 (uintptr_t)v);
4377
4378 if (context)
4379 {
4380 SCOPED_SHARE_CONTEXT_LOCK(context);
4381 bool isCallValid =
4382 (context->skipValidation() ||
4383 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4384 context->getMutableErrorSetForValidation(),
4385 angle::EntryPoint::GLRasterPos4fv) &&
4386 ValidateRasterPos4fv(context, angle::EntryPoint::GLRasterPos4fv, v)));
4387 if (isCallValid)
4388 {
4389 context->rasterPos4fv(v);
4390 }
4391 ANGLE_CAPTURE_GL(RasterPos4fv, isCallValid, context, v);
4392 }
4393 else
4394 {
4395 GenerateContextLostErrorOnCurrentGlobalContext();
4396 }
4397 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4398 }
4399
GL_RasterPos4i(GLint x,GLint y,GLint z,GLint w)4400 void GL_APIENTRY GL_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
4401 {
4402 Context *context = GetValidGlobalContext();
4403 EVENT(context, GLRasterPos4i, "context = %d, x = %d, y = %d, z = %d, w = %d", CID(context), x,
4404 y, z, w);
4405
4406 if (context)
4407 {
4408 SCOPED_SHARE_CONTEXT_LOCK(context);
4409 bool isCallValid =
4410 (context->skipValidation() ||
4411 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4412 context->getMutableErrorSetForValidation(),
4413 angle::EntryPoint::GLRasterPos4i) &&
4414 ValidateRasterPos4i(context, angle::EntryPoint::GLRasterPos4i, x, y, z, w)));
4415 if (isCallValid)
4416 {
4417 context->rasterPos4i(x, y, z, w);
4418 }
4419 ANGLE_CAPTURE_GL(RasterPos4i, isCallValid, context, x, y, z, w);
4420 }
4421 else
4422 {
4423 GenerateContextLostErrorOnCurrentGlobalContext();
4424 }
4425 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4426 }
4427
GL_RasterPos4iv(const GLint * v)4428 void GL_APIENTRY GL_RasterPos4iv(const GLint *v)
4429 {
4430 Context *context = GetValidGlobalContext();
4431 EVENT(context, GLRasterPos4iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4432 (uintptr_t)v);
4433
4434 if (context)
4435 {
4436 SCOPED_SHARE_CONTEXT_LOCK(context);
4437 bool isCallValid =
4438 (context->skipValidation() ||
4439 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4440 context->getMutableErrorSetForValidation(),
4441 angle::EntryPoint::GLRasterPos4iv) &&
4442 ValidateRasterPos4iv(context, angle::EntryPoint::GLRasterPos4iv, v)));
4443 if (isCallValid)
4444 {
4445 context->rasterPos4iv(v);
4446 }
4447 ANGLE_CAPTURE_GL(RasterPos4iv, isCallValid, context, v);
4448 }
4449 else
4450 {
4451 GenerateContextLostErrorOnCurrentGlobalContext();
4452 }
4453 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4454 }
4455
GL_RasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w)4456 void GL_APIENTRY GL_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
4457 {
4458 Context *context = GetValidGlobalContext();
4459 EVENT(context, GLRasterPos4s, "context = %d, x = %d, y = %d, z = %d, w = %d", CID(context), x,
4460 y, z, w);
4461
4462 if (context)
4463 {
4464 SCOPED_SHARE_CONTEXT_LOCK(context);
4465 bool isCallValid =
4466 (context->skipValidation() ||
4467 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4468 context->getMutableErrorSetForValidation(),
4469 angle::EntryPoint::GLRasterPos4s) &&
4470 ValidateRasterPos4s(context, angle::EntryPoint::GLRasterPos4s, x, y, z, w)));
4471 if (isCallValid)
4472 {
4473 context->rasterPos4s(x, y, z, w);
4474 }
4475 ANGLE_CAPTURE_GL(RasterPos4s, isCallValid, context, x, y, z, w);
4476 }
4477 else
4478 {
4479 GenerateContextLostErrorOnCurrentGlobalContext();
4480 }
4481 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4482 }
4483
GL_RasterPos4sv(const GLshort * v)4484 void GL_APIENTRY GL_RasterPos4sv(const GLshort *v)
4485 {
4486 Context *context = GetValidGlobalContext();
4487 EVENT(context, GLRasterPos4sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4488 (uintptr_t)v);
4489
4490 if (context)
4491 {
4492 SCOPED_SHARE_CONTEXT_LOCK(context);
4493 bool isCallValid =
4494 (context->skipValidation() ||
4495 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4496 context->getMutableErrorSetForValidation(),
4497 angle::EntryPoint::GLRasterPos4sv) &&
4498 ValidateRasterPos4sv(context, angle::EntryPoint::GLRasterPos4sv, v)));
4499 if (isCallValid)
4500 {
4501 context->rasterPos4sv(v);
4502 }
4503 ANGLE_CAPTURE_GL(RasterPos4sv, isCallValid, context, v);
4504 }
4505 else
4506 {
4507 GenerateContextLostErrorOnCurrentGlobalContext();
4508 }
4509 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4510 }
4511
GL_Rectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2)4512 void GL_APIENTRY GL_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
4513 {
4514 Context *context = GetValidGlobalContext();
4515 EVENT(context, GLRectd, "context = %d, x1 = %f, y1 = %f, x2 = %f, y2 = %f", CID(context), x1,
4516 y1, x2, y2);
4517
4518 if (context)
4519 {
4520 SCOPED_SHARE_CONTEXT_LOCK(context);
4521 bool isCallValid =
4522 (context->skipValidation() ||
4523 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4524 context->getMutableErrorSetForValidation(),
4525 angle::EntryPoint::GLRectd) &&
4526 ValidateRectd(context, angle::EntryPoint::GLRectd, x1, y1, x2, y2)));
4527 if (isCallValid)
4528 {
4529 context->rectd(x1, y1, x2, y2);
4530 }
4531 ANGLE_CAPTURE_GL(Rectd, isCallValid, context, x1, y1, x2, y2);
4532 }
4533 else
4534 {
4535 GenerateContextLostErrorOnCurrentGlobalContext();
4536 }
4537 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4538 }
4539
GL_Rectdv(const GLdouble * v1,const GLdouble * v2)4540 void GL_APIENTRY GL_Rectdv(const GLdouble *v1, const GLdouble *v2)
4541 {
4542 Context *context = GetValidGlobalContext();
4543 EVENT(context, GLRectdv, "context = %d, v1 = 0x%016" PRIxPTR ", v2 = 0x%016" PRIxPTR "",
4544 CID(context), (uintptr_t)v1, (uintptr_t)v2);
4545
4546 if (context)
4547 {
4548 SCOPED_SHARE_CONTEXT_LOCK(context);
4549 bool isCallValid =
4550 (context->skipValidation() ||
4551 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4552 context->getMutableErrorSetForValidation(),
4553 angle::EntryPoint::GLRectdv) &&
4554 ValidateRectdv(context, angle::EntryPoint::GLRectdv, v1, v2)));
4555 if (isCallValid)
4556 {
4557 context->rectdv(v1, v2);
4558 }
4559 ANGLE_CAPTURE_GL(Rectdv, isCallValid, context, v1, v2);
4560 }
4561 else
4562 {
4563 GenerateContextLostErrorOnCurrentGlobalContext();
4564 }
4565 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4566 }
4567
GL_Rectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2)4568 void GL_APIENTRY GL_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
4569 {
4570 Context *context = GetValidGlobalContext();
4571 EVENT(context, GLRectf, "context = %d, x1 = %f, y1 = %f, x2 = %f, y2 = %f", CID(context), x1,
4572 y1, x2, y2);
4573
4574 if (context)
4575 {
4576 SCOPED_SHARE_CONTEXT_LOCK(context);
4577 bool isCallValid =
4578 (context->skipValidation() ||
4579 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4580 context->getMutableErrorSetForValidation(),
4581 angle::EntryPoint::GLRectf) &&
4582 ValidateRectf(context, angle::EntryPoint::GLRectf, x1, y1, x2, y2)));
4583 if (isCallValid)
4584 {
4585 context->rectf(x1, y1, x2, y2);
4586 }
4587 ANGLE_CAPTURE_GL(Rectf, isCallValid, context, x1, y1, x2, y2);
4588 }
4589 else
4590 {
4591 GenerateContextLostErrorOnCurrentGlobalContext();
4592 }
4593 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4594 }
4595
GL_Rectfv(const GLfloat * v1,const GLfloat * v2)4596 void GL_APIENTRY GL_Rectfv(const GLfloat *v1, const GLfloat *v2)
4597 {
4598 Context *context = GetValidGlobalContext();
4599 EVENT(context, GLRectfv, "context = %d, v1 = 0x%016" PRIxPTR ", v2 = 0x%016" PRIxPTR "",
4600 CID(context), (uintptr_t)v1, (uintptr_t)v2);
4601
4602 if (context)
4603 {
4604 SCOPED_SHARE_CONTEXT_LOCK(context);
4605 bool isCallValid =
4606 (context->skipValidation() ||
4607 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4608 context->getMutableErrorSetForValidation(),
4609 angle::EntryPoint::GLRectfv) &&
4610 ValidateRectfv(context, angle::EntryPoint::GLRectfv, v1, v2)));
4611 if (isCallValid)
4612 {
4613 context->rectfv(v1, v2);
4614 }
4615 ANGLE_CAPTURE_GL(Rectfv, isCallValid, context, v1, v2);
4616 }
4617 else
4618 {
4619 GenerateContextLostErrorOnCurrentGlobalContext();
4620 }
4621 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4622 }
4623
GL_Recti(GLint x1,GLint y1,GLint x2,GLint y2)4624 void GL_APIENTRY GL_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
4625 {
4626 Context *context = GetValidGlobalContext();
4627 EVENT(context, GLRecti, "context = %d, x1 = %d, y1 = %d, x2 = %d, y2 = %d", CID(context), x1,
4628 y1, x2, y2);
4629
4630 if (context)
4631 {
4632 SCOPED_SHARE_CONTEXT_LOCK(context);
4633 bool isCallValid =
4634 (context->skipValidation() ||
4635 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4636 context->getMutableErrorSetForValidation(),
4637 angle::EntryPoint::GLRecti) &&
4638 ValidateRecti(context, angle::EntryPoint::GLRecti, x1, y1, x2, y2)));
4639 if (isCallValid)
4640 {
4641 context->recti(x1, y1, x2, y2);
4642 }
4643 ANGLE_CAPTURE_GL(Recti, isCallValid, context, x1, y1, x2, y2);
4644 }
4645 else
4646 {
4647 GenerateContextLostErrorOnCurrentGlobalContext();
4648 }
4649 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4650 }
4651
GL_Rectiv(const GLint * v1,const GLint * v2)4652 void GL_APIENTRY GL_Rectiv(const GLint *v1, const GLint *v2)
4653 {
4654 Context *context = GetValidGlobalContext();
4655 EVENT(context, GLRectiv, "context = %d, v1 = 0x%016" PRIxPTR ", v2 = 0x%016" PRIxPTR "",
4656 CID(context), (uintptr_t)v1, (uintptr_t)v2);
4657
4658 if (context)
4659 {
4660 SCOPED_SHARE_CONTEXT_LOCK(context);
4661 bool isCallValid =
4662 (context->skipValidation() ||
4663 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4664 context->getMutableErrorSetForValidation(),
4665 angle::EntryPoint::GLRectiv) &&
4666 ValidateRectiv(context, angle::EntryPoint::GLRectiv, v1, v2)));
4667 if (isCallValid)
4668 {
4669 context->rectiv(v1, v2);
4670 }
4671 ANGLE_CAPTURE_GL(Rectiv, isCallValid, context, v1, v2);
4672 }
4673 else
4674 {
4675 GenerateContextLostErrorOnCurrentGlobalContext();
4676 }
4677 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4678 }
4679
GL_Rects(GLshort x1,GLshort y1,GLshort x2,GLshort y2)4680 void GL_APIENTRY GL_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
4681 {
4682 Context *context = GetValidGlobalContext();
4683 EVENT(context, GLRects, "context = %d, x1 = %d, y1 = %d, x2 = %d, y2 = %d", CID(context), x1,
4684 y1, x2, y2);
4685
4686 if (context)
4687 {
4688 SCOPED_SHARE_CONTEXT_LOCK(context);
4689 bool isCallValid =
4690 (context->skipValidation() ||
4691 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4692 context->getMutableErrorSetForValidation(),
4693 angle::EntryPoint::GLRects) &&
4694 ValidateRects(context, angle::EntryPoint::GLRects, x1, y1, x2, y2)));
4695 if (isCallValid)
4696 {
4697 context->rects(x1, y1, x2, y2);
4698 }
4699 ANGLE_CAPTURE_GL(Rects, isCallValid, context, x1, y1, x2, y2);
4700 }
4701 else
4702 {
4703 GenerateContextLostErrorOnCurrentGlobalContext();
4704 }
4705 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4706 }
4707
GL_Rectsv(const GLshort * v1,const GLshort * v2)4708 void GL_APIENTRY GL_Rectsv(const GLshort *v1, const GLshort *v2)
4709 {
4710 Context *context = GetValidGlobalContext();
4711 EVENT(context, GLRectsv, "context = %d, v1 = 0x%016" PRIxPTR ", v2 = 0x%016" PRIxPTR "",
4712 CID(context), (uintptr_t)v1, (uintptr_t)v2);
4713
4714 if (context)
4715 {
4716 SCOPED_SHARE_CONTEXT_LOCK(context);
4717 bool isCallValid =
4718 (context->skipValidation() ||
4719 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4720 context->getMutableErrorSetForValidation(),
4721 angle::EntryPoint::GLRectsv) &&
4722 ValidateRectsv(context, angle::EntryPoint::GLRectsv, v1, v2)));
4723 if (isCallValid)
4724 {
4725 context->rectsv(v1, v2);
4726 }
4727 ANGLE_CAPTURE_GL(Rectsv, isCallValid, context, v1, v2);
4728 }
4729 else
4730 {
4731 GenerateContextLostErrorOnCurrentGlobalContext();
4732 }
4733 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4734 }
4735
GL_RenderMode(GLenum mode)4736 GLint GL_APIENTRY GL_RenderMode(GLenum mode)
4737 {
4738 Context *context = GetValidGlobalContext();
4739 EVENT(context, GLRenderMode, "context = %d, mode = %s", CID(context),
4740 GLenumToString(BigGLEnum::RenderingMode, mode));
4741
4742 GLint returnValue;
4743 if (context)
4744 {
4745 SCOPED_SHARE_CONTEXT_LOCK(context);
4746 bool isCallValid =
4747 (context->skipValidation() ||
4748 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4749 context->getMutableErrorSetForValidation(),
4750 angle::EntryPoint::GLRenderMode) &&
4751 ValidateRenderMode(context, angle::EntryPoint::GLRenderMode, mode)));
4752 if (isCallValid)
4753 {
4754 returnValue = context->renderMode(mode);
4755 }
4756 else
4757 {
4758 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLRenderMode, GLint>();
4759 }
4760 ANGLE_CAPTURE_GL(RenderMode, isCallValid, context, mode, returnValue);
4761 }
4762 else
4763 {
4764 GenerateContextLostErrorOnCurrentGlobalContext();
4765 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLRenderMode, GLint>();
4766 }
4767 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4768 return returnValue;
4769 }
4770
GL_Rotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z)4771 void GL_APIENTRY GL_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
4772 {
4773 Context *context = GetValidGlobalContext();
4774 EVENT(context, GLRotated, "context = %d, angle = %f, x = %f, y = %f, z = %f", CID(context),
4775 angle, x, y, z);
4776
4777 if (context)
4778 {
4779 SCOPED_SHARE_CONTEXT_LOCK(context);
4780 bool isCallValid =
4781 (context->skipValidation() ||
4782 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4783 context->getMutableErrorSetForValidation(),
4784 angle::EntryPoint::GLRotated) &&
4785 ValidateRotated(context, angle::EntryPoint::GLRotated, angle, x, y, z)));
4786 if (isCallValid)
4787 {
4788 context->rotated(angle, x, y, z);
4789 }
4790 ANGLE_CAPTURE_GL(Rotated, isCallValid, context, angle, x, y, z);
4791 }
4792 else
4793 {
4794 GenerateContextLostErrorOnCurrentGlobalContext();
4795 }
4796 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4797 }
4798
GL_Scaled(GLdouble x,GLdouble y,GLdouble z)4799 void GL_APIENTRY GL_Scaled(GLdouble x, GLdouble y, GLdouble z)
4800 {
4801 Context *context = GetValidGlobalContext();
4802 EVENT(context, GLScaled, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
4803
4804 if (context)
4805 {
4806 SCOPED_SHARE_CONTEXT_LOCK(context);
4807 bool isCallValid =
4808 (context->skipValidation() ||
4809 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4810 context->getMutableErrorSetForValidation(),
4811 angle::EntryPoint::GLScaled) &&
4812 ValidateScaled(context, angle::EntryPoint::GLScaled, x, y, z)));
4813 if (isCallValid)
4814 {
4815 context->scaled(x, y, z);
4816 }
4817 ANGLE_CAPTURE_GL(Scaled, isCallValid, context, x, y, z);
4818 }
4819 else
4820 {
4821 GenerateContextLostErrorOnCurrentGlobalContext();
4822 }
4823 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4824 }
4825
GL_SelectBuffer(GLsizei size,GLuint * buffer)4826 void GL_APIENTRY GL_SelectBuffer(GLsizei size, GLuint *buffer)
4827 {
4828 Context *context = GetValidGlobalContext();
4829 EVENT(context, GLSelectBuffer, "context = %d, size = %d, buffer = 0x%016" PRIxPTR "",
4830 CID(context), size, (uintptr_t)buffer);
4831
4832 if (context)
4833 {
4834 SCOPED_SHARE_CONTEXT_LOCK(context);
4835 bool isCallValid =
4836 (context->skipValidation() ||
4837 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4838 context->getMutableErrorSetForValidation(),
4839 angle::EntryPoint::GLSelectBuffer) &&
4840 ValidateSelectBuffer(context, angle::EntryPoint::GLSelectBuffer, size, buffer)));
4841 if (isCallValid)
4842 {
4843 context->selectBuffer(size, buffer);
4844 }
4845 ANGLE_CAPTURE_GL(SelectBuffer, isCallValid, context, size, buffer);
4846 }
4847 else
4848 {
4849 GenerateContextLostErrorOnCurrentGlobalContext();
4850 }
4851 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4852 }
4853
GL_TexCoord1d(GLdouble s)4854 void GL_APIENTRY GL_TexCoord1d(GLdouble s)
4855 {
4856 Context *context = GetValidGlobalContext();
4857 EVENT(context, GLTexCoord1d, "context = %d, s = %f", CID(context), s);
4858
4859 if (context)
4860 {
4861 SCOPED_SHARE_CONTEXT_LOCK(context);
4862 bool isCallValid =
4863 (context->skipValidation() ||
4864 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4865 context->getMutableErrorSetForValidation(),
4866 angle::EntryPoint::GLTexCoord1d) &&
4867 ValidateTexCoord1d(context, angle::EntryPoint::GLTexCoord1d, s)));
4868 if (isCallValid)
4869 {
4870 context->texCoord1d(s);
4871 }
4872 ANGLE_CAPTURE_GL(TexCoord1d, isCallValid, context, s);
4873 }
4874 else
4875 {
4876 GenerateContextLostErrorOnCurrentGlobalContext();
4877 }
4878 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4879 }
4880
GL_TexCoord1dv(const GLdouble * v)4881 void GL_APIENTRY GL_TexCoord1dv(const GLdouble *v)
4882 {
4883 Context *context = GetValidGlobalContext();
4884 EVENT(context, GLTexCoord1dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4885 (uintptr_t)v);
4886
4887 if (context)
4888 {
4889 SCOPED_SHARE_CONTEXT_LOCK(context);
4890 bool isCallValid =
4891 (context->skipValidation() ||
4892 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4893 context->getMutableErrorSetForValidation(),
4894 angle::EntryPoint::GLTexCoord1dv) &&
4895 ValidateTexCoord1dv(context, angle::EntryPoint::GLTexCoord1dv, v)));
4896 if (isCallValid)
4897 {
4898 context->texCoord1dv(v);
4899 }
4900 ANGLE_CAPTURE_GL(TexCoord1dv, isCallValid, context, v);
4901 }
4902 else
4903 {
4904 GenerateContextLostErrorOnCurrentGlobalContext();
4905 }
4906 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4907 }
4908
GL_TexCoord1f(GLfloat s)4909 void GL_APIENTRY GL_TexCoord1f(GLfloat s)
4910 {
4911 Context *context = GetValidGlobalContext();
4912 EVENT(context, GLTexCoord1f, "context = %d, s = %f", CID(context), s);
4913
4914 if (context)
4915 {
4916 SCOPED_SHARE_CONTEXT_LOCK(context);
4917 bool isCallValid =
4918 (context->skipValidation() ||
4919 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4920 context->getMutableErrorSetForValidation(),
4921 angle::EntryPoint::GLTexCoord1f) &&
4922 ValidateTexCoord1f(context, angle::EntryPoint::GLTexCoord1f, s)));
4923 if (isCallValid)
4924 {
4925 context->texCoord1f(s);
4926 }
4927 ANGLE_CAPTURE_GL(TexCoord1f, isCallValid, context, s);
4928 }
4929 else
4930 {
4931 GenerateContextLostErrorOnCurrentGlobalContext();
4932 }
4933 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4934 }
4935
GL_TexCoord1fv(const GLfloat * v)4936 void GL_APIENTRY GL_TexCoord1fv(const GLfloat *v)
4937 {
4938 Context *context = GetValidGlobalContext();
4939 EVENT(context, GLTexCoord1fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4940 (uintptr_t)v);
4941
4942 if (context)
4943 {
4944 SCOPED_SHARE_CONTEXT_LOCK(context);
4945 bool isCallValid =
4946 (context->skipValidation() ||
4947 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4948 context->getMutableErrorSetForValidation(),
4949 angle::EntryPoint::GLTexCoord1fv) &&
4950 ValidateTexCoord1fv(context, angle::EntryPoint::GLTexCoord1fv, v)));
4951 if (isCallValid)
4952 {
4953 context->texCoord1fv(v);
4954 }
4955 ANGLE_CAPTURE_GL(TexCoord1fv, isCallValid, context, v);
4956 }
4957 else
4958 {
4959 GenerateContextLostErrorOnCurrentGlobalContext();
4960 }
4961 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4962 }
4963
GL_TexCoord1i(GLint s)4964 void GL_APIENTRY GL_TexCoord1i(GLint s)
4965 {
4966 Context *context = GetValidGlobalContext();
4967 EVENT(context, GLTexCoord1i, "context = %d, s = %d", CID(context), s);
4968
4969 if (context)
4970 {
4971 SCOPED_SHARE_CONTEXT_LOCK(context);
4972 bool isCallValid =
4973 (context->skipValidation() ||
4974 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4975 context->getMutableErrorSetForValidation(),
4976 angle::EntryPoint::GLTexCoord1i) &&
4977 ValidateTexCoord1i(context, angle::EntryPoint::GLTexCoord1i, s)));
4978 if (isCallValid)
4979 {
4980 context->texCoord1i(s);
4981 }
4982 ANGLE_CAPTURE_GL(TexCoord1i, isCallValid, context, s);
4983 }
4984 else
4985 {
4986 GenerateContextLostErrorOnCurrentGlobalContext();
4987 }
4988 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4989 }
4990
GL_TexCoord1iv(const GLint * v)4991 void GL_APIENTRY GL_TexCoord1iv(const GLint *v)
4992 {
4993 Context *context = GetValidGlobalContext();
4994 EVENT(context, GLTexCoord1iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
4995 (uintptr_t)v);
4996
4997 if (context)
4998 {
4999 SCOPED_SHARE_CONTEXT_LOCK(context);
5000 bool isCallValid =
5001 (context->skipValidation() ||
5002 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5003 context->getMutableErrorSetForValidation(),
5004 angle::EntryPoint::GLTexCoord1iv) &&
5005 ValidateTexCoord1iv(context, angle::EntryPoint::GLTexCoord1iv, v)));
5006 if (isCallValid)
5007 {
5008 context->texCoord1iv(v);
5009 }
5010 ANGLE_CAPTURE_GL(TexCoord1iv, isCallValid, context, v);
5011 }
5012 else
5013 {
5014 GenerateContextLostErrorOnCurrentGlobalContext();
5015 }
5016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5017 }
5018
GL_TexCoord1s(GLshort s)5019 void GL_APIENTRY GL_TexCoord1s(GLshort s)
5020 {
5021 Context *context = GetValidGlobalContext();
5022 EVENT(context, GLTexCoord1s, "context = %d, s = %d", CID(context), s);
5023
5024 if (context)
5025 {
5026 SCOPED_SHARE_CONTEXT_LOCK(context);
5027 bool isCallValid =
5028 (context->skipValidation() ||
5029 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5030 context->getMutableErrorSetForValidation(),
5031 angle::EntryPoint::GLTexCoord1s) &&
5032 ValidateTexCoord1s(context, angle::EntryPoint::GLTexCoord1s, s)));
5033 if (isCallValid)
5034 {
5035 context->texCoord1s(s);
5036 }
5037 ANGLE_CAPTURE_GL(TexCoord1s, isCallValid, context, s);
5038 }
5039 else
5040 {
5041 GenerateContextLostErrorOnCurrentGlobalContext();
5042 }
5043 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5044 }
5045
GL_TexCoord1sv(const GLshort * v)5046 void GL_APIENTRY GL_TexCoord1sv(const GLshort *v)
5047 {
5048 Context *context = GetValidGlobalContext();
5049 EVENT(context, GLTexCoord1sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5050 (uintptr_t)v);
5051
5052 if (context)
5053 {
5054 SCOPED_SHARE_CONTEXT_LOCK(context);
5055 bool isCallValid =
5056 (context->skipValidation() ||
5057 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5058 context->getMutableErrorSetForValidation(),
5059 angle::EntryPoint::GLTexCoord1sv) &&
5060 ValidateTexCoord1sv(context, angle::EntryPoint::GLTexCoord1sv, v)));
5061 if (isCallValid)
5062 {
5063 context->texCoord1sv(v);
5064 }
5065 ANGLE_CAPTURE_GL(TexCoord1sv, isCallValid, context, v);
5066 }
5067 else
5068 {
5069 GenerateContextLostErrorOnCurrentGlobalContext();
5070 }
5071 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5072 }
5073
GL_TexCoord2d(GLdouble s,GLdouble t)5074 void GL_APIENTRY GL_TexCoord2d(GLdouble s, GLdouble t)
5075 {
5076 Context *context = GetValidGlobalContext();
5077 EVENT(context, GLTexCoord2d, "context = %d, s = %f, t = %f", CID(context), s, t);
5078
5079 if (context)
5080 {
5081 SCOPED_SHARE_CONTEXT_LOCK(context);
5082 bool isCallValid =
5083 (context->skipValidation() ||
5084 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5085 context->getMutableErrorSetForValidation(),
5086 angle::EntryPoint::GLTexCoord2d) &&
5087 ValidateTexCoord2d(context, angle::EntryPoint::GLTexCoord2d, s, t)));
5088 if (isCallValid)
5089 {
5090 context->texCoord2d(s, t);
5091 }
5092 ANGLE_CAPTURE_GL(TexCoord2d, isCallValid, context, s, t);
5093 }
5094 else
5095 {
5096 GenerateContextLostErrorOnCurrentGlobalContext();
5097 }
5098 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5099 }
5100
GL_TexCoord2dv(const GLdouble * v)5101 void GL_APIENTRY GL_TexCoord2dv(const GLdouble *v)
5102 {
5103 Context *context = GetValidGlobalContext();
5104 EVENT(context, GLTexCoord2dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5105 (uintptr_t)v);
5106
5107 if (context)
5108 {
5109 SCOPED_SHARE_CONTEXT_LOCK(context);
5110 bool isCallValid =
5111 (context->skipValidation() ||
5112 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5113 context->getMutableErrorSetForValidation(),
5114 angle::EntryPoint::GLTexCoord2dv) &&
5115 ValidateTexCoord2dv(context, angle::EntryPoint::GLTexCoord2dv, v)));
5116 if (isCallValid)
5117 {
5118 context->texCoord2dv(v);
5119 }
5120 ANGLE_CAPTURE_GL(TexCoord2dv, isCallValid, context, v);
5121 }
5122 else
5123 {
5124 GenerateContextLostErrorOnCurrentGlobalContext();
5125 }
5126 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5127 }
5128
GL_TexCoord2f(GLfloat s,GLfloat t)5129 void GL_APIENTRY GL_TexCoord2f(GLfloat s, GLfloat t)
5130 {
5131 Context *context = GetValidGlobalContext();
5132 EVENT(context, GLTexCoord2f, "context = %d, s = %f, t = %f", CID(context), s, t);
5133
5134 if (context)
5135 {
5136 SCOPED_SHARE_CONTEXT_LOCK(context);
5137 bool isCallValid =
5138 (context->skipValidation() ||
5139 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5140 context->getMutableErrorSetForValidation(),
5141 angle::EntryPoint::GLTexCoord2f) &&
5142 ValidateTexCoord2f(context, angle::EntryPoint::GLTexCoord2f, s, t)));
5143 if (isCallValid)
5144 {
5145 context->texCoord2f(s, t);
5146 }
5147 ANGLE_CAPTURE_GL(TexCoord2f, isCallValid, context, s, t);
5148 }
5149 else
5150 {
5151 GenerateContextLostErrorOnCurrentGlobalContext();
5152 }
5153 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5154 }
5155
GL_TexCoord2fv(const GLfloat * v)5156 void GL_APIENTRY GL_TexCoord2fv(const GLfloat *v)
5157 {
5158 Context *context = GetValidGlobalContext();
5159 EVENT(context, GLTexCoord2fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5160 (uintptr_t)v);
5161
5162 if (context)
5163 {
5164 SCOPED_SHARE_CONTEXT_LOCK(context);
5165 bool isCallValid =
5166 (context->skipValidation() ||
5167 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5168 context->getMutableErrorSetForValidation(),
5169 angle::EntryPoint::GLTexCoord2fv) &&
5170 ValidateTexCoord2fv(context, angle::EntryPoint::GLTexCoord2fv, v)));
5171 if (isCallValid)
5172 {
5173 context->texCoord2fv(v);
5174 }
5175 ANGLE_CAPTURE_GL(TexCoord2fv, isCallValid, context, v);
5176 }
5177 else
5178 {
5179 GenerateContextLostErrorOnCurrentGlobalContext();
5180 }
5181 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5182 }
5183
GL_TexCoord2i(GLint s,GLint t)5184 void GL_APIENTRY GL_TexCoord2i(GLint s, GLint t)
5185 {
5186 Context *context = GetValidGlobalContext();
5187 EVENT(context, GLTexCoord2i, "context = %d, s = %d, t = %d", CID(context), s, t);
5188
5189 if (context)
5190 {
5191 SCOPED_SHARE_CONTEXT_LOCK(context);
5192 bool isCallValid =
5193 (context->skipValidation() ||
5194 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5195 context->getMutableErrorSetForValidation(),
5196 angle::EntryPoint::GLTexCoord2i) &&
5197 ValidateTexCoord2i(context, angle::EntryPoint::GLTexCoord2i, s, t)));
5198 if (isCallValid)
5199 {
5200 context->texCoord2i(s, t);
5201 }
5202 ANGLE_CAPTURE_GL(TexCoord2i, isCallValid, context, s, t);
5203 }
5204 else
5205 {
5206 GenerateContextLostErrorOnCurrentGlobalContext();
5207 }
5208 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5209 }
5210
GL_TexCoord2iv(const GLint * v)5211 void GL_APIENTRY GL_TexCoord2iv(const GLint *v)
5212 {
5213 Context *context = GetValidGlobalContext();
5214 EVENT(context, GLTexCoord2iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5215 (uintptr_t)v);
5216
5217 if (context)
5218 {
5219 SCOPED_SHARE_CONTEXT_LOCK(context);
5220 bool isCallValid =
5221 (context->skipValidation() ||
5222 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5223 context->getMutableErrorSetForValidation(),
5224 angle::EntryPoint::GLTexCoord2iv) &&
5225 ValidateTexCoord2iv(context, angle::EntryPoint::GLTexCoord2iv, v)));
5226 if (isCallValid)
5227 {
5228 context->texCoord2iv(v);
5229 }
5230 ANGLE_CAPTURE_GL(TexCoord2iv, isCallValid, context, v);
5231 }
5232 else
5233 {
5234 GenerateContextLostErrorOnCurrentGlobalContext();
5235 }
5236 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5237 }
5238
GL_TexCoord2s(GLshort s,GLshort t)5239 void GL_APIENTRY GL_TexCoord2s(GLshort s, GLshort t)
5240 {
5241 Context *context = GetValidGlobalContext();
5242 EVENT(context, GLTexCoord2s, "context = %d, s = %d, t = %d", CID(context), s, t);
5243
5244 if (context)
5245 {
5246 SCOPED_SHARE_CONTEXT_LOCK(context);
5247 bool isCallValid =
5248 (context->skipValidation() ||
5249 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5250 context->getMutableErrorSetForValidation(),
5251 angle::EntryPoint::GLTexCoord2s) &&
5252 ValidateTexCoord2s(context, angle::EntryPoint::GLTexCoord2s, s, t)));
5253 if (isCallValid)
5254 {
5255 context->texCoord2s(s, t);
5256 }
5257 ANGLE_CAPTURE_GL(TexCoord2s, isCallValid, context, s, t);
5258 }
5259 else
5260 {
5261 GenerateContextLostErrorOnCurrentGlobalContext();
5262 }
5263 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5264 }
5265
GL_TexCoord2sv(const GLshort * v)5266 void GL_APIENTRY GL_TexCoord2sv(const GLshort *v)
5267 {
5268 Context *context = GetValidGlobalContext();
5269 EVENT(context, GLTexCoord2sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5270 (uintptr_t)v);
5271
5272 if (context)
5273 {
5274 SCOPED_SHARE_CONTEXT_LOCK(context);
5275 bool isCallValid =
5276 (context->skipValidation() ||
5277 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5278 context->getMutableErrorSetForValidation(),
5279 angle::EntryPoint::GLTexCoord2sv) &&
5280 ValidateTexCoord2sv(context, angle::EntryPoint::GLTexCoord2sv, v)));
5281 if (isCallValid)
5282 {
5283 context->texCoord2sv(v);
5284 }
5285 ANGLE_CAPTURE_GL(TexCoord2sv, isCallValid, context, v);
5286 }
5287 else
5288 {
5289 GenerateContextLostErrorOnCurrentGlobalContext();
5290 }
5291 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5292 }
5293
GL_TexCoord3d(GLdouble s,GLdouble t,GLdouble r)5294 void GL_APIENTRY GL_TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
5295 {
5296 Context *context = GetValidGlobalContext();
5297 EVENT(context, GLTexCoord3d, "context = %d, s = %f, t = %f, r = %f", CID(context), s, t, r);
5298
5299 if (context)
5300 {
5301 SCOPED_SHARE_CONTEXT_LOCK(context);
5302 bool isCallValid =
5303 (context->skipValidation() ||
5304 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5305 context->getMutableErrorSetForValidation(),
5306 angle::EntryPoint::GLTexCoord3d) &&
5307 ValidateTexCoord3d(context, angle::EntryPoint::GLTexCoord3d, s, t, r)));
5308 if (isCallValid)
5309 {
5310 context->texCoord3d(s, t, r);
5311 }
5312 ANGLE_CAPTURE_GL(TexCoord3d, isCallValid, context, s, t, r);
5313 }
5314 else
5315 {
5316 GenerateContextLostErrorOnCurrentGlobalContext();
5317 }
5318 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5319 }
5320
GL_TexCoord3dv(const GLdouble * v)5321 void GL_APIENTRY GL_TexCoord3dv(const GLdouble *v)
5322 {
5323 Context *context = GetValidGlobalContext();
5324 EVENT(context, GLTexCoord3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5325 (uintptr_t)v);
5326
5327 if (context)
5328 {
5329 SCOPED_SHARE_CONTEXT_LOCK(context);
5330 bool isCallValid =
5331 (context->skipValidation() ||
5332 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5333 context->getMutableErrorSetForValidation(),
5334 angle::EntryPoint::GLTexCoord3dv) &&
5335 ValidateTexCoord3dv(context, angle::EntryPoint::GLTexCoord3dv, v)));
5336 if (isCallValid)
5337 {
5338 context->texCoord3dv(v);
5339 }
5340 ANGLE_CAPTURE_GL(TexCoord3dv, isCallValid, context, v);
5341 }
5342 else
5343 {
5344 GenerateContextLostErrorOnCurrentGlobalContext();
5345 }
5346 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5347 }
5348
GL_TexCoord3f(GLfloat s,GLfloat t,GLfloat r)5349 void GL_APIENTRY GL_TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
5350 {
5351 Context *context = GetValidGlobalContext();
5352 EVENT(context, GLTexCoord3f, "context = %d, s = %f, t = %f, r = %f", CID(context), s, t, r);
5353
5354 if (context)
5355 {
5356 SCOPED_SHARE_CONTEXT_LOCK(context);
5357 bool isCallValid =
5358 (context->skipValidation() ||
5359 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5360 context->getMutableErrorSetForValidation(),
5361 angle::EntryPoint::GLTexCoord3f) &&
5362 ValidateTexCoord3f(context, angle::EntryPoint::GLTexCoord3f, s, t, r)));
5363 if (isCallValid)
5364 {
5365 context->texCoord3f(s, t, r);
5366 }
5367 ANGLE_CAPTURE_GL(TexCoord3f, isCallValid, context, s, t, r);
5368 }
5369 else
5370 {
5371 GenerateContextLostErrorOnCurrentGlobalContext();
5372 }
5373 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5374 }
5375
GL_TexCoord3fv(const GLfloat * v)5376 void GL_APIENTRY GL_TexCoord3fv(const GLfloat *v)
5377 {
5378 Context *context = GetValidGlobalContext();
5379 EVENT(context, GLTexCoord3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5380 (uintptr_t)v);
5381
5382 if (context)
5383 {
5384 SCOPED_SHARE_CONTEXT_LOCK(context);
5385 bool isCallValid =
5386 (context->skipValidation() ||
5387 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5388 context->getMutableErrorSetForValidation(),
5389 angle::EntryPoint::GLTexCoord3fv) &&
5390 ValidateTexCoord3fv(context, angle::EntryPoint::GLTexCoord3fv, v)));
5391 if (isCallValid)
5392 {
5393 context->texCoord3fv(v);
5394 }
5395 ANGLE_CAPTURE_GL(TexCoord3fv, isCallValid, context, v);
5396 }
5397 else
5398 {
5399 GenerateContextLostErrorOnCurrentGlobalContext();
5400 }
5401 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5402 }
5403
GL_TexCoord3i(GLint s,GLint t,GLint r)5404 void GL_APIENTRY GL_TexCoord3i(GLint s, GLint t, GLint r)
5405 {
5406 Context *context = GetValidGlobalContext();
5407 EVENT(context, GLTexCoord3i, "context = %d, s = %d, t = %d, r = %d", CID(context), s, t, r);
5408
5409 if (context)
5410 {
5411 SCOPED_SHARE_CONTEXT_LOCK(context);
5412 bool isCallValid =
5413 (context->skipValidation() ||
5414 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5415 context->getMutableErrorSetForValidation(),
5416 angle::EntryPoint::GLTexCoord3i) &&
5417 ValidateTexCoord3i(context, angle::EntryPoint::GLTexCoord3i, s, t, r)));
5418 if (isCallValid)
5419 {
5420 context->texCoord3i(s, t, r);
5421 }
5422 ANGLE_CAPTURE_GL(TexCoord3i, isCallValid, context, s, t, r);
5423 }
5424 else
5425 {
5426 GenerateContextLostErrorOnCurrentGlobalContext();
5427 }
5428 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5429 }
5430
GL_TexCoord3iv(const GLint * v)5431 void GL_APIENTRY GL_TexCoord3iv(const GLint *v)
5432 {
5433 Context *context = GetValidGlobalContext();
5434 EVENT(context, GLTexCoord3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5435 (uintptr_t)v);
5436
5437 if (context)
5438 {
5439 SCOPED_SHARE_CONTEXT_LOCK(context);
5440 bool isCallValid =
5441 (context->skipValidation() ||
5442 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5443 context->getMutableErrorSetForValidation(),
5444 angle::EntryPoint::GLTexCoord3iv) &&
5445 ValidateTexCoord3iv(context, angle::EntryPoint::GLTexCoord3iv, v)));
5446 if (isCallValid)
5447 {
5448 context->texCoord3iv(v);
5449 }
5450 ANGLE_CAPTURE_GL(TexCoord3iv, isCallValid, context, v);
5451 }
5452 else
5453 {
5454 GenerateContextLostErrorOnCurrentGlobalContext();
5455 }
5456 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5457 }
5458
GL_TexCoord3s(GLshort s,GLshort t,GLshort r)5459 void GL_APIENTRY GL_TexCoord3s(GLshort s, GLshort t, GLshort r)
5460 {
5461 Context *context = GetValidGlobalContext();
5462 EVENT(context, GLTexCoord3s, "context = %d, s = %d, t = %d, r = %d", CID(context), s, t, r);
5463
5464 if (context)
5465 {
5466 SCOPED_SHARE_CONTEXT_LOCK(context);
5467 bool isCallValid =
5468 (context->skipValidation() ||
5469 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5470 context->getMutableErrorSetForValidation(),
5471 angle::EntryPoint::GLTexCoord3s) &&
5472 ValidateTexCoord3s(context, angle::EntryPoint::GLTexCoord3s, s, t, r)));
5473 if (isCallValid)
5474 {
5475 context->texCoord3s(s, t, r);
5476 }
5477 ANGLE_CAPTURE_GL(TexCoord3s, isCallValid, context, s, t, r);
5478 }
5479 else
5480 {
5481 GenerateContextLostErrorOnCurrentGlobalContext();
5482 }
5483 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5484 }
5485
GL_TexCoord3sv(const GLshort * v)5486 void GL_APIENTRY GL_TexCoord3sv(const GLshort *v)
5487 {
5488 Context *context = GetValidGlobalContext();
5489 EVENT(context, GLTexCoord3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5490 (uintptr_t)v);
5491
5492 if (context)
5493 {
5494 SCOPED_SHARE_CONTEXT_LOCK(context);
5495 bool isCallValid =
5496 (context->skipValidation() ||
5497 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5498 context->getMutableErrorSetForValidation(),
5499 angle::EntryPoint::GLTexCoord3sv) &&
5500 ValidateTexCoord3sv(context, angle::EntryPoint::GLTexCoord3sv, v)));
5501 if (isCallValid)
5502 {
5503 context->texCoord3sv(v);
5504 }
5505 ANGLE_CAPTURE_GL(TexCoord3sv, isCallValid, context, v);
5506 }
5507 else
5508 {
5509 GenerateContextLostErrorOnCurrentGlobalContext();
5510 }
5511 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5512 }
5513
GL_TexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q)5514 void GL_APIENTRY GL_TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
5515 {
5516 Context *context = GetValidGlobalContext();
5517 EVENT(context, GLTexCoord4d, "context = %d, s = %f, t = %f, r = %f, q = %f", CID(context), s, t,
5518 r, q);
5519
5520 if (context)
5521 {
5522 SCOPED_SHARE_CONTEXT_LOCK(context);
5523 bool isCallValid =
5524 (context->skipValidation() ||
5525 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5526 context->getMutableErrorSetForValidation(),
5527 angle::EntryPoint::GLTexCoord4d) &&
5528 ValidateTexCoord4d(context, angle::EntryPoint::GLTexCoord4d, s, t, r, q)));
5529 if (isCallValid)
5530 {
5531 context->texCoord4d(s, t, r, q);
5532 }
5533 ANGLE_CAPTURE_GL(TexCoord4d, isCallValid, context, s, t, r, q);
5534 }
5535 else
5536 {
5537 GenerateContextLostErrorOnCurrentGlobalContext();
5538 }
5539 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5540 }
5541
GL_TexCoord4dv(const GLdouble * v)5542 void GL_APIENTRY GL_TexCoord4dv(const GLdouble *v)
5543 {
5544 Context *context = GetValidGlobalContext();
5545 EVENT(context, GLTexCoord4dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5546 (uintptr_t)v);
5547
5548 if (context)
5549 {
5550 SCOPED_SHARE_CONTEXT_LOCK(context);
5551 bool isCallValid =
5552 (context->skipValidation() ||
5553 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5554 context->getMutableErrorSetForValidation(),
5555 angle::EntryPoint::GLTexCoord4dv) &&
5556 ValidateTexCoord4dv(context, angle::EntryPoint::GLTexCoord4dv, v)));
5557 if (isCallValid)
5558 {
5559 context->texCoord4dv(v);
5560 }
5561 ANGLE_CAPTURE_GL(TexCoord4dv, isCallValid, context, v);
5562 }
5563 else
5564 {
5565 GenerateContextLostErrorOnCurrentGlobalContext();
5566 }
5567 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5568 }
5569
GL_TexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q)5570 void GL_APIENTRY GL_TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
5571 {
5572 Context *context = GetValidGlobalContext();
5573 EVENT(context, GLTexCoord4f, "context = %d, s = %f, t = %f, r = %f, q = %f", CID(context), s, t,
5574 r, q);
5575
5576 if (context)
5577 {
5578 SCOPED_SHARE_CONTEXT_LOCK(context);
5579 bool isCallValid =
5580 (context->skipValidation() ||
5581 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5582 context->getMutableErrorSetForValidation(),
5583 angle::EntryPoint::GLTexCoord4f) &&
5584 ValidateTexCoord4f(context, angle::EntryPoint::GLTexCoord4f, s, t, r, q)));
5585 if (isCallValid)
5586 {
5587 context->texCoord4f(s, t, r, q);
5588 }
5589 ANGLE_CAPTURE_GL(TexCoord4f, isCallValid, context, s, t, r, q);
5590 }
5591 else
5592 {
5593 GenerateContextLostErrorOnCurrentGlobalContext();
5594 }
5595 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5596 }
5597
GL_TexCoord4fv(const GLfloat * v)5598 void GL_APIENTRY GL_TexCoord4fv(const GLfloat *v)
5599 {
5600 Context *context = GetValidGlobalContext();
5601 EVENT(context, GLTexCoord4fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5602 (uintptr_t)v);
5603
5604 if (context)
5605 {
5606 SCOPED_SHARE_CONTEXT_LOCK(context);
5607 bool isCallValid =
5608 (context->skipValidation() ||
5609 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5610 context->getMutableErrorSetForValidation(),
5611 angle::EntryPoint::GLTexCoord4fv) &&
5612 ValidateTexCoord4fv(context, angle::EntryPoint::GLTexCoord4fv, v)));
5613 if (isCallValid)
5614 {
5615 context->texCoord4fv(v);
5616 }
5617 ANGLE_CAPTURE_GL(TexCoord4fv, isCallValid, context, v);
5618 }
5619 else
5620 {
5621 GenerateContextLostErrorOnCurrentGlobalContext();
5622 }
5623 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5624 }
5625
GL_TexCoord4i(GLint s,GLint t,GLint r,GLint q)5626 void GL_APIENTRY GL_TexCoord4i(GLint s, GLint t, GLint r, GLint q)
5627 {
5628 Context *context = GetValidGlobalContext();
5629 EVENT(context, GLTexCoord4i, "context = %d, s = %d, t = %d, r = %d, q = %d", CID(context), s, t,
5630 r, q);
5631
5632 if (context)
5633 {
5634 SCOPED_SHARE_CONTEXT_LOCK(context);
5635 bool isCallValid =
5636 (context->skipValidation() ||
5637 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5638 context->getMutableErrorSetForValidation(),
5639 angle::EntryPoint::GLTexCoord4i) &&
5640 ValidateTexCoord4i(context, angle::EntryPoint::GLTexCoord4i, s, t, r, q)));
5641 if (isCallValid)
5642 {
5643 context->texCoord4i(s, t, r, q);
5644 }
5645 ANGLE_CAPTURE_GL(TexCoord4i, isCallValid, context, s, t, r, q);
5646 }
5647 else
5648 {
5649 GenerateContextLostErrorOnCurrentGlobalContext();
5650 }
5651 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5652 }
5653
GL_TexCoord4iv(const GLint * v)5654 void GL_APIENTRY GL_TexCoord4iv(const GLint *v)
5655 {
5656 Context *context = GetValidGlobalContext();
5657 EVENT(context, GLTexCoord4iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5658 (uintptr_t)v);
5659
5660 if (context)
5661 {
5662 SCOPED_SHARE_CONTEXT_LOCK(context);
5663 bool isCallValid =
5664 (context->skipValidation() ||
5665 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5666 context->getMutableErrorSetForValidation(),
5667 angle::EntryPoint::GLTexCoord4iv) &&
5668 ValidateTexCoord4iv(context, angle::EntryPoint::GLTexCoord4iv, v)));
5669 if (isCallValid)
5670 {
5671 context->texCoord4iv(v);
5672 }
5673 ANGLE_CAPTURE_GL(TexCoord4iv, isCallValid, context, v);
5674 }
5675 else
5676 {
5677 GenerateContextLostErrorOnCurrentGlobalContext();
5678 }
5679 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5680 }
5681
GL_TexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q)5682 void GL_APIENTRY GL_TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
5683 {
5684 Context *context = GetValidGlobalContext();
5685 EVENT(context, GLTexCoord4s, "context = %d, s = %d, t = %d, r = %d, q = %d", CID(context), s, t,
5686 r, q);
5687
5688 if (context)
5689 {
5690 SCOPED_SHARE_CONTEXT_LOCK(context);
5691 bool isCallValid =
5692 (context->skipValidation() ||
5693 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5694 context->getMutableErrorSetForValidation(),
5695 angle::EntryPoint::GLTexCoord4s) &&
5696 ValidateTexCoord4s(context, angle::EntryPoint::GLTexCoord4s, s, t, r, q)));
5697 if (isCallValid)
5698 {
5699 context->texCoord4s(s, t, r, q);
5700 }
5701 ANGLE_CAPTURE_GL(TexCoord4s, isCallValid, context, s, t, r, q);
5702 }
5703 else
5704 {
5705 GenerateContextLostErrorOnCurrentGlobalContext();
5706 }
5707 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5708 }
5709
GL_TexCoord4sv(const GLshort * v)5710 void GL_APIENTRY GL_TexCoord4sv(const GLshort *v)
5711 {
5712 Context *context = GetValidGlobalContext();
5713 EVENT(context, GLTexCoord4sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
5714 (uintptr_t)v);
5715
5716 if (context)
5717 {
5718 SCOPED_SHARE_CONTEXT_LOCK(context);
5719 bool isCallValid =
5720 (context->skipValidation() ||
5721 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5722 context->getMutableErrorSetForValidation(),
5723 angle::EntryPoint::GLTexCoord4sv) &&
5724 ValidateTexCoord4sv(context, angle::EntryPoint::GLTexCoord4sv, v)));
5725 if (isCallValid)
5726 {
5727 context->texCoord4sv(v);
5728 }
5729 ANGLE_CAPTURE_GL(TexCoord4sv, isCallValid, context, v);
5730 }
5731 else
5732 {
5733 GenerateContextLostErrorOnCurrentGlobalContext();
5734 }
5735 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5736 }
5737
GL_TexGend(GLenum coord,GLenum pname,GLdouble param)5738 void GL_APIENTRY GL_TexGend(GLenum coord, GLenum pname, GLdouble param)
5739 {
5740 Context *context = GetValidGlobalContext();
5741 EVENT(context, GLTexGend, "context = %d, coord = %s, pname = %s, param = %f", CID(context),
5742 GLenumToString(BigGLEnum::TextureCoordName, coord),
5743 GLenumToString(BigGLEnum::TextureGenParameter, pname), param);
5744
5745 if (context)
5746 {
5747 SCOPED_SHARE_CONTEXT_LOCK(context);
5748 bool isCallValid =
5749 (context->skipValidation() ||
5750 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5751 context->getMutableErrorSetForValidation(),
5752 angle::EntryPoint::GLTexGend) &&
5753 ValidateTexGend(context, angle::EntryPoint::GLTexGend, coord, pname, param)));
5754 if (isCallValid)
5755 {
5756 context->texGend(coord, pname, param);
5757 }
5758 ANGLE_CAPTURE_GL(TexGend, isCallValid, context, coord, pname, param);
5759 }
5760 else
5761 {
5762 GenerateContextLostErrorOnCurrentGlobalContext();
5763 }
5764 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5765 }
5766
GL_TexGendv(GLenum coord,GLenum pname,const GLdouble * params)5767 void GL_APIENTRY GL_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
5768 {
5769 Context *context = GetValidGlobalContext();
5770 EVENT(context, GLTexGendv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "",
5771 CID(context), GLenumToString(BigGLEnum::TextureCoordName, coord),
5772 GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params);
5773
5774 if (context)
5775 {
5776 SCOPED_SHARE_CONTEXT_LOCK(context);
5777 bool isCallValid =
5778 (context->skipValidation() ||
5779 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5780 context->getMutableErrorSetForValidation(),
5781 angle::EntryPoint::GLTexGendv) &&
5782 ValidateTexGendv(context, angle::EntryPoint::GLTexGendv, coord, pname, params)));
5783 if (isCallValid)
5784 {
5785 context->texGendv(coord, pname, params);
5786 }
5787 ANGLE_CAPTURE_GL(TexGendv, isCallValid, context, coord, pname, params);
5788 }
5789 else
5790 {
5791 GenerateContextLostErrorOnCurrentGlobalContext();
5792 }
5793 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5794 }
5795
GL_TexGenf(GLenum coord,GLenum pname,GLfloat param)5796 void GL_APIENTRY GL_TexGenf(GLenum coord, GLenum pname, GLfloat param)
5797 {
5798 Context *context = GetValidGlobalContext();
5799 EVENT(context, GLTexGenf, "context = %d, coord = %s, pname = %s, param = %f", CID(context),
5800 GLenumToString(BigGLEnum::TextureCoordName, coord),
5801 GLenumToString(BigGLEnum::TextureGenParameter, pname), param);
5802
5803 if (context)
5804 {
5805 SCOPED_SHARE_CONTEXT_LOCK(context);
5806 bool isCallValid =
5807 (context->skipValidation() ||
5808 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5809 context->getMutableErrorSetForValidation(),
5810 angle::EntryPoint::GLTexGenf) &&
5811 ValidateTexGenf(context, angle::EntryPoint::GLTexGenf, coord, pname, param)));
5812 if (isCallValid)
5813 {
5814 context->texGenf(coord, pname, param);
5815 }
5816 ANGLE_CAPTURE_GL(TexGenf, isCallValid, context, coord, pname, param);
5817 }
5818 else
5819 {
5820 GenerateContextLostErrorOnCurrentGlobalContext();
5821 }
5822 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5823 }
5824
GL_TexGenfv(GLenum coord,GLenum pname,const GLfloat * params)5825 void GL_APIENTRY GL_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
5826 {
5827 Context *context = GetValidGlobalContext();
5828 EVENT(context, GLTexGenfv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "",
5829 CID(context), GLenumToString(BigGLEnum::TextureCoordName, coord),
5830 GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params);
5831
5832 if (context)
5833 {
5834 SCOPED_SHARE_CONTEXT_LOCK(context);
5835 bool isCallValid =
5836 (context->skipValidation() ||
5837 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5838 context->getMutableErrorSetForValidation(),
5839 angle::EntryPoint::GLTexGenfv) &&
5840 ValidateTexGenfv(context, angle::EntryPoint::GLTexGenfv, coord, pname, params)));
5841 if (isCallValid)
5842 {
5843 context->texGenfv(coord, pname, params);
5844 }
5845 ANGLE_CAPTURE_GL(TexGenfv, isCallValid, context, coord, pname, params);
5846 }
5847 else
5848 {
5849 GenerateContextLostErrorOnCurrentGlobalContext();
5850 }
5851 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5852 }
5853
GL_TexGeni(GLenum coord,GLenum pname,GLint param)5854 void GL_APIENTRY GL_TexGeni(GLenum coord, GLenum pname, GLint param)
5855 {
5856 Context *context = GetValidGlobalContext();
5857 EVENT(context, GLTexGeni, "context = %d, coord = %s, pname = %s, param = %d", CID(context),
5858 GLenumToString(BigGLEnum::TextureCoordName, coord),
5859 GLenumToString(BigGLEnum::TextureGenParameter, pname), param);
5860
5861 if (context)
5862 {
5863 SCOPED_SHARE_CONTEXT_LOCK(context);
5864 bool isCallValid =
5865 (context->skipValidation() ||
5866 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5867 context->getMutableErrorSetForValidation(),
5868 angle::EntryPoint::GLTexGeni) &&
5869 ValidateTexGeni(context, angle::EntryPoint::GLTexGeni, coord, pname, param)));
5870 if (isCallValid)
5871 {
5872 context->texGeni(coord, pname, param);
5873 }
5874 ANGLE_CAPTURE_GL(TexGeni, isCallValid, context, coord, pname, param);
5875 }
5876 else
5877 {
5878 GenerateContextLostErrorOnCurrentGlobalContext();
5879 }
5880 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5881 }
5882
GL_TexGeniv(GLenum coord,GLenum pname,const GLint * params)5883 void GL_APIENTRY GL_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
5884 {
5885 Context *context = GetValidGlobalContext();
5886 EVENT(context, GLTexGeniv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "",
5887 CID(context), GLenumToString(BigGLEnum::TextureCoordName, coord),
5888 GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params);
5889
5890 if (context)
5891 {
5892 SCOPED_SHARE_CONTEXT_LOCK(context);
5893 bool isCallValid =
5894 (context->skipValidation() ||
5895 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5896 context->getMutableErrorSetForValidation(),
5897 angle::EntryPoint::GLTexGeniv) &&
5898 ValidateTexGeniv(context, angle::EntryPoint::GLTexGeniv, coord, pname, params)));
5899 if (isCallValid)
5900 {
5901 context->texGeniv(coord, pname, params);
5902 }
5903 ANGLE_CAPTURE_GL(TexGeniv, isCallValid, context, coord, pname, params);
5904 }
5905 else
5906 {
5907 GenerateContextLostErrorOnCurrentGlobalContext();
5908 }
5909 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5910 }
5911
GL_TexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void * pixels)5912 void GL_APIENTRY GL_TexImage1D(GLenum target,
5913 GLint level,
5914 GLint internalformat,
5915 GLsizei width,
5916 GLint border,
5917 GLenum format,
5918 GLenum type,
5919 const void *pixels)
5920 {
5921 Context *context = GetValidGlobalContext();
5922 EVENT(context, GLTexImage1D,
5923 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, border = %d, "
5924 "format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
5925 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, internalformat,
5926 width, border, GLenumToString(BigGLEnum::PixelFormat, format),
5927 GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels);
5928
5929 if (context)
5930 {
5931 SCOPED_SHARE_CONTEXT_LOCK(context);
5932 bool isCallValid =
5933 (context->skipValidation() ||
5934 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5935 context->getMutableErrorSetForValidation(),
5936 angle::EntryPoint::GLTexImage1D) &&
5937 ValidateTexImage1D(context, angle::EntryPoint::GLTexImage1D, target, level,
5938 internalformat, width, border, format, type, pixels)));
5939 if (isCallValid)
5940 {
5941 context->texImage1D(target, level, internalformat, width, border, format, type, pixels);
5942 }
5943 ANGLE_CAPTURE_GL(TexImage1D, isCallValid, context, target, level, internalformat, width,
5944 border, format, type, pixels);
5945 }
5946 else
5947 {
5948 GenerateContextLostErrorOnCurrentGlobalContext();
5949 }
5950 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5951 }
5952
GL_Translated(GLdouble x,GLdouble y,GLdouble z)5953 void GL_APIENTRY GL_Translated(GLdouble x, GLdouble y, GLdouble z)
5954 {
5955 Context *context = GetValidGlobalContext();
5956 EVENT(context, GLTranslated, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
5957
5958 if (context)
5959 {
5960 SCOPED_SHARE_CONTEXT_LOCK(context);
5961 bool isCallValid =
5962 (context->skipValidation() ||
5963 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5964 context->getMutableErrorSetForValidation(),
5965 angle::EntryPoint::GLTranslated) &&
5966 ValidateTranslated(context, angle::EntryPoint::GLTranslated, x, y, z)));
5967 if (isCallValid)
5968 {
5969 context->translated(x, y, z);
5970 }
5971 ANGLE_CAPTURE_GL(Translated, isCallValid, context, x, y, z);
5972 }
5973 else
5974 {
5975 GenerateContextLostErrorOnCurrentGlobalContext();
5976 }
5977 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5978 }
5979
GL_Vertex2d(GLdouble x,GLdouble y)5980 void GL_APIENTRY GL_Vertex2d(GLdouble x, GLdouble y)
5981 {
5982 Context *context = GetValidGlobalContext();
5983 EVENT(context, GLVertex2d, "context = %d, x = %f, y = %f", CID(context), x, y);
5984
5985 if (context)
5986 {
5987 SCOPED_SHARE_CONTEXT_LOCK(context);
5988 bool isCallValid =
5989 (context->skipValidation() ||
5990 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5991 context->getMutableErrorSetForValidation(),
5992 angle::EntryPoint::GLVertex2d) &&
5993 ValidateVertex2d(context, angle::EntryPoint::GLVertex2d, x, y)));
5994 if (isCallValid)
5995 {
5996 context->vertex2d(x, y);
5997 }
5998 ANGLE_CAPTURE_GL(Vertex2d, isCallValid, context, x, y);
5999 }
6000 else
6001 {
6002 GenerateContextLostErrorOnCurrentGlobalContext();
6003 }
6004 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6005 }
6006
GL_Vertex2dv(const GLdouble * v)6007 void GL_APIENTRY GL_Vertex2dv(const GLdouble *v)
6008 {
6009 Context *context = GetValidGlobalContext();
6010 EVENT(context, GLVertex2dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6011
6012 if (context)
6013 {
6014 SCOPED_SHARE_CONTEXT_LOCK(context);
6015 bool isCallValid =
6016 (context->skipValidation() ||
6017 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6018 context->getMutableErrorSetForValidation(),
6019 angle::EntryPoint::GLVertex2dv) &&
6020 ValidateVertex2dv(context, angle::EntryPoint::GLVertex2dv, v)));
6021 if (isCallValid)
6022 {
6023 context->vertex2dv(v);
6024 }
6025 ANGLE_CAPTURE_GL(Vertex2dv, isCallValid, context, v);
6026 }
6027 else
6028 {
6029 GenerateContextLostErrorOnCurrentGlobalContext();
6030 }
6031 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6032 }
6033
GL_Vertex2f(GLfloat x,GLfloat y)6034 void GL_APIENTRY GL_Vertex2f(GLfloat x, GLfloat y)
6035 {
6036 Context *context = GetValidGlobalContext();
6037 EVENT(context, GLVertex2f, "context = %d, x = %f, y = %f", CID(context), x, y);
6038
6039 if (context)
6040 {
6041 SCOPED_SHARE_CONTEXT_LOCK(context);
6042 bool isCallValid =
6043 (context->skipValidation() ||
6044 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6045 context->getMutableErrorSetForValidation(),
6046 angle::EntryPoint::GLVertex2f) &&
6047 ValidateVertex2f(context, angle::EntryPoint::GLVertex2f, x, y)));
6048 if (isCallValid)
6049 {
6050 context->vertex2f(x, y);
6051 }
6052 ANGLE_CAPTURE_GL(Vertex2f, isCallValid, context, x, y);
6053 }
6054 else
6055 {
6056 GenerateContextLostErrorOnCurrentGlobalContext();
6057 }
6058 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6059 }
6060
GL_Vertex2fv(const GLfloat * v)6061 void GL_APIENTRY GL_Vertex2fv(const GLfloat *v)
6062 {
6063 Context *context = GetValidGlobalContext();
6064 EVENT(context, GLVertex2fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6065
6066 if (context)
6067 {
6068 SCOPED_SHARE_CONTEXT_LOCK(context);
6069 bool isCallValid =
6070 (context->skipValidation() ||
6071 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6072 context->getMutableErrorSetForValidation(),
6073 angle::EntryPoint::GLVertex2fv) &&
6074 ValidateVertex2fv(context, angle::EntryPoint::GLVertex2fv, v)));
6075 if (isCallValid)
6076 {
6077 context->vertex2fv(v);
6078 }
6079 ANGLE_CAPTURE_GL(Vertex2fv, isCallValid, context, v);
6080 }
6081 else
6082 {
6083 GenerateContextLostErrorOnCurrentGlobalContext();
6084 }
6085 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6086 }
6087
GL_Vertex2i(GLint x,GLint y)6088 void GL_APIENTRY GL_Vertex2i(GLint x, GLint y)
6089 {
6090 Context *context = GetValidGlobalContext();
6091 EVENT(context, GLVertex2i, "context = %d, x = %d, y = %d", CID(context), x, y);
6092
6093 if (context)
6094 {
6095 SCOPED_SHARE_CONTEXT_LOCK(context);
6096 bool isCallValid =
6097 (context->skipValidation() ||
6098 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6099 context->getMutableErrorSetForValidation(),
6100 angle::EntryPoint::GLVertex2i) &&
6101 ValidateVertex2i(context, angle::EntryPoint::GLVertex2i, x, y)));
6102 if (isCallValid)
6103 {
6104 context->vertex2i(x, y);
6105 }
6106 ANGLE_CAPTURE_GL(Vertex2i, isCallValid, context, x, y);
6107 }
6108 else
6109 {
6110 GenerateContextLostErrorOnCurrentGlobalContext();
6111 }
6112 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6113 }
6114
GL_Vertex2iv(const GLint * v)6115 void GL_APIENTRY GL_Vertex2iv(const GLint *v)
6116 {
6117 Context *context = GetValidGlobalContext();
6118 EVENT(context, GLVertex2iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6119
6120 if (context)
6121 {
6122 SCOPED_SHARE_CONTEXT_LOCK(context);
6123 bool isCallValid =
6124 (context->skipValidation() ||
6125 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6126 context->getMutableErrorSetForValidation(),
6127 angle::EntryPoint::GLVertex2iv) &&
6128 ValidateVertex2iv(context, angle::EntryPoint::GLVertex2iv, v)));
6129 if (isCallValid)
6130 {
6131 context->vertex2iv(v);
6132 }
6133 ANGLE_CAPTURE_GL(Vertex2iv, isCallValid, context, v);
6134 }
6135 else
6136 {
6137 GenerateContextLostErrorOnCurrentGlobalContext();
6138 }
6139 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6140 }
6141
GL_Vertex2s(GLshort x,GLshort y)6142 void GL_APIENTRY GL_Vertex2s(GLshort x, GLshort y)
6143 {
6144 Context *context = GetValidGlobalContext();
6145 EVENT(context, GLVertex2s, "context = %d, x = %d, y = %d", CID(context), x, y);
6146
6147 if (context)
6148 {
6149 SCOPED_SHARE_CONTEXT_LOCK(context);
6150 bool isCallValid =
6151 (context->skipValidation() ||
6152 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6153 context->getMutableErrorSetForValidation(),
6154 angle::EntryPoint::GLVertex2s) &&
6155 ValidateVertex2s(context, angle::EntryPoint::GLVertex2s, x, y)));
6156 if (isCallValid)
6157 {
6158 context->vertex2s(x, y);
6159 }
6160 ANGLE_CAPTURE_GL(Vertex2s, isCallValid, context, x, y);
6161 }
6162 else
6163 {
6164 GenerateContextLostErrorOnCurrentGlobalContext();
6165 }
6166 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6167 }
6168
GL_Vertex2sv(const GLshort * v)6169 void GL_APIENTRY GL_Vertex2sv(const GLshort *v)
6170 {
6171 Context *context = GetValidGlobalContext();
6172 EVENT(context, GLVertex2sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6173
6174 if (context)
6175 {
6176 SCOPED_SHARE_CONTEXT_LOCK(context);
6177 bool isCallValid =
6178 (context->skipValidation() ||
6179 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6180 context->getMutableErrorSetForValidation(),
6181 angle::EntryPoint::GLVertex2sv) &&
6182 ValidateVertex2sv(context, angle::EntryPoint::GLVertex2sv, v)));
6183 if (isCallValid)
6184 {
6185 context->vertex2sv(v);
6186 }
6187 ANGLE_CAPTURE_GL(Vertex2sv, isCallValid, context, v);
6188 }
6189 else
6190 {
6191 GenerateContextLostErrorOnCurrentGlobalContext();
6192 }
6193 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6194 }
6195
GL_Vertex3d(GLdouble x,GLdouble y,GLdouble z)6196 void GL_APIENTRY GL_Vertex3d(GLdouble x, GLdouble y, GLdouble z)
6197 {
6198 Context *context = GetValidGlobalContext();
6199 EVENT(context, GLVertex3d, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
6200
6201 if (context)
6202 {
6203 SCOPED_SHARE_CONTEXT_LOCK(context);
6204 bool isCallValid =
6205 (context->skipValidation() ||
6206 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6207 context->getMutableErrorSetForValidation(),
6208 angle::EntryPoint::GLVertex3d) &&
6209 ValidateVertex3d(context, angle::EntryPoint::GLVertex3d, x, y, z)));
6210 if (isCallValid)
6211 {
6212 context->vertex3d(x, y, z);
6213 }
6214 ANGLE_CAPTURE_GL(Vertex3d, isCallValid, context, x, y, z);
6215 }
6216 else
6217 {
6218 GenerateContextLostErrorOnCurrentGlobalContext();
6219 }
6220 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6221 }
6222
GL_Vertex3dv(const GLdouble * v)6223 void GL_APIENTRY GL_Vertex3dv(const GLdouble *v)
6224 {
6225 Context *context = GetValidGlobalContext();
6226 EVENT(context, GLVertex3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6227
6228 if (context)
6229 {
6230 SCOPED_SHARE_CONTEXT_LOCK(context);
6231 bool isCallValid =
6232 (context->skipValidation() ||
6233 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6234 context->getMutableErrorSetForValidation(),
6235 angle::EntryPoint::GLVertex3dv) &&
6236 ValidateVertex3dv(context, angle::EntryPoint::GLVertex3dv, v)));
6237 if (isCallValid)
6238 {
6239 context->vertex3dv(v);
6240 }
6241 ANGLE_CAPTURE_GL(Vertex3dv, isCallValid, context, v);
6242 }
6243 else
6244 {
6245 GenerateContextLostErrorOnCurrentGlobalContext();
6246 }
6247 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6248 }
6249
GL_Vertex3f(GLfloat x,GLfloat y,GLfloat z)6250 void GL_APIENTRY GL_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
6251 {
6252 Context *context = GetValidGlobalContext();
6253 EVENT(context, GLVertex3f, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
6254
6255 if (context)
6256 {
6257 SCOPED_SHARE_CONTEXT_LOCK(context);
6258 bool isCallValid =
6259 (context->skipValidation() ||
6260 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6261 context->getMutableErrorSetForValidation(),
6262 angle::EntryPoint::GLVertex3f) &&
6263 ValidateVertex3f(context, angle::EntryPoint::GLVertex3f, x, y, z)));
6264 if (isCallValid)
6265 {
6266 context->vertex3f(x, y, z);
6267 }
6268 ANGLE_CAPTURE_GL(Vertex3f, isCallValid, context, x, y, z);
6269 }
6270 else
6271 {
6272 GenerateContextLostErrorOnCurrentGlobalContext();
6273 }
6274 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6275 }
6276
GL_Vertex3fv(const GLfloat * v)6277 void GL_APIENTRY GL_Vertex3fv(const GLfloat *v)
6278 {
6279 Context *context = GetValidGlobalContext();
6280 EVENT(context, GLVertex3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6281
6282 if (context)
6283 {
6284 SCOPED_SHARE_CONTEXT_LOCK(context);
6285 bool isCallValid =
6286 (context->skipValidation() ||
6287 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6288 context->getMutableErrorSetForValidation(),
6289 angle::EntryPoint::GLVertex3fv) &&
6290 ValidateVertex3fv(context, angle::EntryPoint::GLVertex3fv, v)));
6291 if (isCallValid)
6292 {
6293 context->vertex3fv(v);
6294 }
6295 ANGLE_CAPTURE_GL(Vertex3fv, isCallValid, context, v);
6296 }
6297 else
6298 {
6299 GenerateContextLostErrorOnCurrentGlobalContext();
6300 }
6301 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6302 }
6303
GL_Vertex3i(GLint x,GLint y,GLint z)6304 void GL_APIENTRY GL_Vertex3i(GLint x, GLint y, GLint z)
6305 {
6306 Context *context = GetValidGlobalContext();
6307 EVENT(context, GLVertex3i, "context = %d, x = %d, y = %d, z = %d", CID(context), x, y, z);
6308
6309 if (context)
6310 {
6311 SCOPED_SHARE_CONTEXT_LOCK(context);
6312 bool isCallValid =
6313 (context->skipValidation() ||
6314 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6315 context->getMutableErrorSetForValidation(),
6316 angle::EntryPoint::GLVertex3i) &&
6317 ValidateVertex3i(context, angle::EntryPoint::GLVertex3i, x, y, z)));
6318 if (isCallValid)
6319 {
6320 context->vertex3i(x, y, z);
6321 }
6322 ANGLE_CAPTURE_GL(Vertex3i, isCallValid, context, x, y, z);
6323 }
6324 else
6325 {
6326 GenerateContextLostErrorOnCurrentGlobalContext();
6327 }
6328 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6329 }
6330
GL_Vertex3iv(const GLint * v)6331 void GL_APIENTRY GL_Vertex3iv(const GLint *v)
6332 {
6333 Context *context = GetValidGlobalContext();
6334 EVENT(context, GLVertex3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6335
6336 if (context)
6337 {
6338 SCOPED_SHARE_CONTEXT_LOCK(context);
6339 bool isCallValid =
6340 (context->skipValidation() ||
6341 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6342 context->getMutableErrorSetForValidation(),
6343 angle::EntryPoint::GLVertex3iv) &&
6344 ValidateVertex3iv(context, angle::EntryPoint::GLVertex3iv, v)));
6345 if (isCallValid)
6346 {
6347 context->vertex3iv(v);
6348 }
6349 ANGLE_CAPTURE_GL(Vertex3iv, isCallValid, context, v);
6350 }
6351 else
6352 {
6353 GenerateContextLostErrorOnCurrentGlobalContext();
6354 }
6355 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6356 }
6357
GL_Vertex3s(GLshort x,GLshort y,GLshort z)6358 void GL_APIENTRY GL_Vertex3s(GLshort x, GLshort y, GLshort z)
6359 {
6360 Context *context = GetValidGlobalContext();
6361 EVENT(context, GLVertex3s, "context = %d, x = %d, y = %d, z = %d", CID(context), x, y, z);
6362
6363 if (context)
6364 {
6365 SCOPED_SHARE_CONTEXT_LOCK(context);
6366 bool isCallValid =
6367 (context->skipValidation() ||
6368 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6369 context->getMutableErrorSetForValidation(),
6370 angle::EntryPoint::GLVertex3s) &&
6371 ValidateVertex3s(context, angle::EntryPoint::GLVertex3s, x, y, z)));
6372 if (isCallValid)
6373 {
6374 context->vertex3s(x, y, z);
6375 }
6376 ANGLE_CAPTURE_GL(Vertex3s, isCallValid, context, x, y, z);
6377 }
6378 else
6379 {
6380 GenerateContextLostErrorOnCurrentGlobalContext();
6381 }
6382 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6383 }
6384
GL_Vertex3sv(const GLshort * v)6385 void GL_APIENTRY GL_Vertex3sv(const GLshort *v)
6386 {
6387 Context *context = GetValidGlobalContext();
6388 EVENT(context, GLVertex3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6389
6390 if (context)
6391 {
6392 SCOPED_SHARE_CONTEXT_LOCK(context);
6393 bool isCallValid =
6394 (context->skipValidation() ||
6395 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6396 context->getMutableErrorSetForValidation(),
6397 angle::EntryPoint::GLVertex3sv) &&
6398 ValidateVertex3sv(context, angle::EntryPoint::GLVertex3sv, v)));
6399 if (isCallValid)
6400 {
6401 context->vertex3sv(v);
6402 }
6403 ANGLE_CAPTURE_GL(Vertex3sv, isCallValid, context, v);
6404 }
6405 else
6406 {
6407 GenerateContextLostErrorOnCurrentGlobalContext();
6408 }
6409 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6410 }
6411
GL_Vertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)6412 void GL_APIENTRY GL_Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6413 {
6414 Context *context = GetValidGlobalContext();
6415 EVENT(context, GLVertex4d, "context = %d, x = %f, y = %f, z = %f, w = %f", CID(context), x, y,
6416 z, w);
6417
6418 if (context)
6419 {
6420 SCOPED_SHARE_CONTEXT_LOCK(context);
6421 bool isCallValid =
6422 (context->skipValidation() ||
6423 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6424 context->getMutableErrorSetForValidation(),
6425 angle::EntryPoint::GLVertex4d) &&
6426 ValidateVertex4d(context, angle::EntryPoint::GLVertex4d, x, y, z, w)));
6427 if (isCallValid)
6428 {
6429 context->vertex4d(x, y, z, w);
6430 }
6431 ANGLE_CAPTURE_GL(Vertex4d, isCallValid, context, x, y, z, w);
6432 }
6433 else
6434 {
6435 GenerateContextLostErrorOnCurrentGlobalContext();
6436 }
6437 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6438 }
6439
GL_Vertex4dv(const GLdouble * v)6440 void GL_APIENTRY GL_Vertex4dv(const GLdouble *v)
6441 {
6442 Context *context = GetValidGlobalContext();
6443 EVENT(context, GLVertex4dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6444
6445 if (context)
6446 {
6447 SCOPED_SHARE_CONTEXT_LOCK(context);
6448 bool isCallValid =
6449 (context->skipValidation() ||
6450 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6451 context->getMutableErrorSetForValidation(),
6452 angle::EntryPoint::GLVertex4dv) &&
6453 ValidateVertex4dv(context, angle::EntryPoint::GLVertex4dv, v)));
6454 if (isCallValid)
6455 {
6456 context->vertex4dv(v);
6457 }
6458 ANGLE_CAPTURE_GL(Vertex4dv, isCallValid, context, v);
6459 }
6460 else
6461 {
6462 GenerateContextLostErrorOnCurrentGlobalContext();
6463 }
6464 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6465 }
6466
GL_Vertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)6467 void GL_APIENTRY GL_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6468 {
6469 Context *context = GetValidGlobalContext();
6470 EVENT(context, GLVertex4f, "context = %d, x = %f, y = %f, z = %f, w = %f", CID(context), x, y,
6471 z, w);
6472
6473 if (context)
6474 {
6475 SCOPED_SHARE_CONTEXT_LOCK(context);
6476 bool isCallValid =
6477 (context->skipValidation() ||
6478 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6479 context->getMutableErrorSetForValidation(),
6480 angle::EntryPoint::GLVertex4f) &&
6481 ValidateVertex4f(context, angle::EntryPoint::GLVertex4f, x, y, z, w)));
6482 if (isCallValid)
6483 {
6484 context->vertex4f(x, y, z, w);
6485 }
6486 ANGLE_CAPTURE_GL(Vertex4f, isCallValid, context, x, y, z, w);
6487 }
6488 else
6489 {
6490 GenerateContextLostErrorOnCurrentGlobalContext();
6491 }
6492 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6493 }
6494
GL_Vertex4fv(const GLfloat * v)6495 void GL_APIENTRY GL_Vertex4fv(const GLfloat *v)
6496 {
6497 Context *context = GetValidGlobalContext();
6498 EVENT(context, GLVertex4fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6499
6500 if (context)
6501 {
6502 SCOPED_SHARE_CONTEXT_LOCK(context);
6503 bool isCallValid =
6504 (context->skipValidation() ||
6505 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6506 context->getMutableErrorSetForValidation(),
6507 angle::EntryPoint::GLVertex4fv) &&
6508 ValidateVertex4fv(context, angle::EntryPoint::GLVertex4fv, v)));
6509 if (isCallValid)
6510 {
6511 context->vertex4fv(v);
6512 }
6513 ANGLE_CAPTURE_GL(Vertex4fv, isCallValid, context, v);
6514 }
6515 else
6516 {
6517 GenerateContextLostErrorOnCurrentGlobalContext();
6518 }
6519 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6520 }
6521
GL_Vertex4i(GLint x,GLint y,GLint z,GLint w)6522 void GL_APIENTRY GL_Vertex4i(GLint x, GLint y, GLint z, GLint w)
6523 {
6524 Context *context = GetValidGlobalContext();
6525 EVENT(context, GLVertex4i, "context = %d, x = %d, y = %d, z = %d, w = %d", CID(context), x, y,
6526 z, w);
6527
6528 if (context)
6529 {
6530 SCOPED_SHARE_CONTEXT_LOCK(context);
6531 bool isCallValid =
6532 (context->skipValidation() ||
6533 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6534 context->getMutableErrorSetForValidation(),
6535 angle::EntryPoint::GLVertex4i) &&
6536 ValidateVertex4i(context, angle::EntryPoint::GLVertex4i, x, y, z, w)));
6537 if (isCallValid)
6538 {
6539 context->vertex4i(x, y, z, w);
6540 }
6541 ANGLE_CAPTURE_GL(Vertex4i, isCallValid, context, x, y, z, w);
6542 }
6543 else
6544 {
6545 GenerateContextLostErrorOnCurrentGlobalContext();
6546 }
6547 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6548 }
6549
GL_Vertex4iv(const GLint * v)6550 void GL_APIENTRY GL_Vertex4iv(const GLint *v)
6551 {
6552 Context *context = GetValidGlobalContext();
6553 EVENT(context, GLVertex4iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6554
6555 if (context)
6556 {
6557 SCOPED_SHARE_CONTEXT_LOCK(context);
6558 bool isCallValid =
6559 (context->skipValidation() ||
6560 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6561 context->getMutableErrorSetForValidation(),
6562 angle::EntryPoint::GLVertex4iv) &&
6563 ValidateVertex4iv(context, angle::EntryPoint::GLVertex4iv, v)));
6564 if (isCallValid)
6565 {
6566 context->vertex4iv(v);
6567 }
6568 ANGLE_CAPTURE_GL(Vertex4iv, isCallValid, context, v);
6569 }
6570 else
6571 {
6572 GenerateContextLostErrorOnCurrentGlobalContext();
6573 }
6574 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6575 }
6576
GL_Vertex4s(GLshort x,GLshort y,GLshort z,GLshort w)6577 void GL_APIENTRY GL_Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
6578 {
6579 Context *context = GetValidGlobalContext();
6580 EVENT(context, GLVertex4s, "context = %d, x = %d, y = %d, z = %d, w = %d", CID(context), x, y,
6581 z, w);
6582
6583 if (context)
6584 {
6585 SCOPED_SHARE_CONTEXT_LOCK(context);
6586 bool isCallValid =
6587 (context->skipValidation() ||
6588 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6589 context->getMutableErrorSetForValidation(),
6590 angle::EntryPoint::GLVertex4s) &&
6591 ValidateVertex4s(context, angle::EntryPoint::GLVertex4s, x, y, z, w)));
6592 if (isCallValid)
6593 {
6594 context->vertex4s(x, y, z, w);
6595 }
6596 ANGLE_CAPTURE_GL(Vertex4s, isCallValid, context, x, y, z, w);
6597 }
6598 else
6599 {
6600 GenerateContextLostErrorOnCurrentGlobalContext();
6601 }
6602 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6603 }
6604
GL_Vertex4sv(const GLshort * v)6605 void GL_APIENTRY GL_Vertex4sv(const GLshort *v)
6606 {
6607 Context *context = GetValidGlobalContext();
6608 EVENT(context, GLVertex4sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context), (uintptr_t)v);
6609
6610 if (context)
6611 {
6612 SCOPED_SHARE_CONTEXT_LOCK(context);
6613 bool isCallValid =
6614 (context->skipValidation() ||
6615 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6616 context->getMutableErrorSetForValidation(),
6617 angle::EntryPoint::GLVertex4sv) &&
6618 ValidateVertex4sv(context, angle::EntryPoint::GLVertex4sv, v)));
6619 if (isCallValid)
6620 {
6621 context->vertex4sv(v);
6622 }
6623 ANGLE_CAPTURE_GL(Vertex4sv, isCallValid, context, v);
6624 }
6625 else
6626 {
6627 GenerateContextLostErrorOnCurrentGlobalContext();
6628 }
6629 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6630 }
6631
6632 // GL 1.1
GL_AreTexturesResident(GLsizei n,const GLuint * textures,GLboolean * residences)6633 GLboolean GL_APIENTRY GL_AreTexturesResident(GLsizei n,
6634 const GLuint *textures,
6635 GLboolean *residences)
6636 {
6637 Context *context = GetValidGlobalContext();
6638 EVENT(context, GLAreTexturesResident,
6639 "context = %d, n = %d, textures = 0x%016" PRIxPTR ", residences = 0x%016" PRIxPTR "",
6640 CID(context), n, (uintptr_t)textures, (uintptr_t)residences);
6641
6642 GLboolean returnValue;
6643 if (context)
6644 {
6645 SCOPED_SHARE_CONTEXT_LOCK(context);
6646 bool isCallValid =
6647 (context->skipValidation() ||
6648 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6649 context->getMutableErrorSetForValidation(),
6650 angle::EntryPoint::GLAreTexturesResident) &&
6651 ValidateAreTexturesResident(context, angle::EntryPoint::GLAreTexturesResident, n,
6652 textures, residences)));
6653 if (isCallValid)
6654 {
6655 returnValue = context->areTexturesResident(n, textures, residences);
6656 }
6657 else
6658 {
6659 returnValue =
6660 GetDefaultReturnValue<angle::EntryPoint::GLAreTexturesResident, GLboolean>();
6661 }
6662 ANGLE_CAPTURE_GL(AreTexturesResident, isCallValid, context, n, textures, residences,
6663 returnValue);
6664 }
6665 else
6666 {
6667 GenerateContextLostErrorOnCurrentGlobalContext();
6668 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLAreTexturesResident, GLboolean>();
6669 }
6670 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6671 return returnValue;
6672 }
6673
GL_ArrayElement(GLint i)6674 void GL_APIENTRY GL_ArrayElement(GLint i)
6675 {
6676 Context *context = GetValidGlobalContext();
6677 EVENT(context, GLArrayElement, "context = %d, i = %d", CID(context), i);
6678
6679 if (context)
6680 {
6681 SCOPED_SHARE_CONTEXT_LOCK(context);
6682 bool isCallValid =
6683 (context->skipValidation() ||
6684 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6685 context->getMutableErrorSetForValidation(),
6686 angle::EntryPoint::GLArrayElement) &&
6687 ValidateArrayElement(context, angle::EntryPoint::GLArrayElement, i)));
6688 if (isCallValid)
6689 {
6690 context->arrayElement(i);
6691 }
6692 ANGLE_CAPTURE_GL(ArrayElement, isCallValid, context, i);
6693 }
6694 else
6695 {
6696 GenerateContextLostErrorOnCurrentGlobalContext();
6697 }
6698 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6699 }
6700
GL_CopyTexImage1D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border)6701 void GL_APIENTRY GL_CopyTexImage1D(GLenum target,
6702 GLint level,
6703 GLenum internalformat,
6704 GLint x,
6705 GLint y,
6706 GLsizei width,
6707 GLint border)
6708 {
6709 Context *context = GetValidGlobalContext();
6710 EVENT(context, GLCopyTexImage1D,
6711 "context = %d, target = %s, level = %d, internalformat = %s, x = %d, y = %d, width = %d, "
6712 "border = %d",
6713 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level,
6714 GLenumToString(BigGLEnum::InternalFormat, internalformat), x, y, width, border);
6715
6716 if (context)
6717 {
6718 SCOPED_SHARE_CONTEXT_LOCK(context);
6719 bool isCallValid =
6720 (context->skipValidation() ||
6721 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6722 context->getMutableErrorSetForValidation(),
6723 angle::EntryPoint::GLCopyTexImage1D) &&
6724 ValidateCopyTexImage1D(context, angle::EntryPoint::GLCopyTexImage1D, target, level,
6725 internalformat, x, y, width, border)));
6726 if (isCallValid)
6727 {
6728 context->copyTexImage1D(target, level, internalformat, x, y, width, border);
6729 }
6730 ANGLE_CAPTURE_GL(CopyTexImage1D, isCallValid, context, target, level, internalformat, x, y,
6731 width, border);
6732 }
6733 else
6734 {
6735 GenerateContextLostErrorOnCurrentGlobalContext();
6736 }
6737 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6738 }
6739
6740 void GL_APIENTRY
GL_CopyTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)6741 GL_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
6742 {
6743 Context *context = GetValidGlobalContext();
6744 EVENT(context, GLCopyTexSubImage1D,
6745 "context = %d, target = %s, level = %d, xoffset = %d, x = %d, y = %d, width = %d",
6746 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, xoffset, x, y,
6747 width);
6748
6749 if (context)
6750 {
6751 SCOPED_SHARE_CONTEXT_LOCK(context);
6752 bool isCallValid =
6753 (context->skipValidation() ||
6754 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6755 context->getMutableErrorSetForValidation(),
6756 angle::EntryPoint::GLCopyTexSubImage1D) &&
6757 ValidateCopyTexSubImage1D(context, angle::EntryPoint::GLCopyTexSubImage1D, target,
6758 level, xoffset, x, y, width)));
6759 if (isCallValid)
6760 {
6761 context->copyTexSubImage1D(target, level, xoffset, x, y, width);
6762 }
6763 ANGLE_CAPTURE_GL(CopyTexSubImage1D, isCallValid, context, target, level, xoffset, x, y,
6764 width);
6765 }
6766 else
6767 {
6768 GenerateContextLostErrorOnCurrentGlobalContext();
6769 }
6770 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6771 }
6772
GL_EdgeFlagPointer(GLsizei stride,const void * pointer)6773 void GL_APIENTRY GL_EdgeFlagPointer(GLsizei stride, const void *pointer)
6774 {
6775 Context *context = GetValidGlobalContext();
6776 EVENT(context, GLEdgeFlagPointer, "context = %d, stride = %d, pointer = 0x%016" PRIxPTR "",
6777 CID(context), stride, (uintptr_t)pointer);
6778
6779 if (context)
6780 {
6781 SCOPED_SHARE_CONTEXT_LOCK(context);
6782 bool isCallValid =
6783 (context->skipValidation() ||
6784 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6785 context->getMutableErrorSetForValidation(),
6786 angle::EntryPoint::GLEdgeFlagPointer) &&
6787 ValidateEdgeFlagPointer(context, angle::EntryPoint::GLEdgeFlagPointer, stride,
6788 pointer)));
6789 if (isCallValid)
6790 {
6791 context->edgeFlagPointer(stride, pointer);
6792 }
6793 ANGLE_CAPTURE_GL(EdgeFlagPointer, isCallValid, context, stride, pointer);
6794 }
6795 else
6796 {
6797 GenerateContextLostErrorOnCurrentGlobalContext();
6798 }
6799 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6800 }
6801
GL_IndexPointer(GLenum type,GLsizei stride,const void * pointer)6802 void GL_APIENTRY GL_IndexPointer(GLenum type, GLsizei stride, const void *pointer)
6803 {
6804 Context *context = GetValidGlobalContext();
6805 EVENT(context, GLIndexPointer,
6806 "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
6807 GLenumToString(BigGLEnum::IndexPointerType, type), stride, (uintptr_t)pointer);
6808
6809 if (context)
6810 {
6811 SCOPED_SHARE_CONTEXT_LOCK(context);
6812 bool isCallValid =
6813 (context->skipValidation() ||
6814 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6815 context->getMutableErrorSetForValidation(),
6816 angle::EntryPoint::GLIndexPointer) &&
6817 ValidateIndexPointer(context, angle::EntryPoint::GLIndexPointer, type, stride,
6818 pointer)));
6819 if (isCallValid)
6820 {
6821 context->indexPointer(type, stride, pointer);
6822 }
6823 ANGLE_CAPTURE_GL(IndexPointer, isCallValid, context, type, stride, pointer);
6824 }
6825 else
6826 {
6827 GenerateContextLostErrorOnCurrentGlobalContext();
6828 }
6829 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6830 }
6831
GL_Indexub(GLubyte c)6832 void GL_APIENTRY GL_Indexub(GLubyte c)
6833 {
6834 Context *context = GetValidGlobalContext();
6835 EVENT(context, GLIndexub, "context = %d, c = %d", CID(context), c);
6836
6837 if (context)
6838 {
6839 SCOPED_SHARE_CONTEXT_LOCK(context);
6840 bool isCallValid =
6841 (context->skipValidation() ||
6842 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6843 context->getMutableErrorSetForValidation(),
6844 angle::EntryPoint::GLIndexub) &&
6845 ValidateIndexub(context, angle::EntryPoint::GLIndexub, c)));
6846 if (isCallValid)
6847 {
6848 context->indexub(c);
6849 }
6850 ANGLE_CAPTURE_GL(Indexub, isCallValid, context, c);
6851 }
6852 else
6853 {
6854 GenerateContextLostErrorOnCurrentGlobalContext();
6855 }
6856 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6857 }
6858
GL_Indexubv(const GLubyte * c)6859 void GL_APIENTRY GL_Indexubv(const GLubyte *c)
6860 {
6861 Context *context = GetValidGlobalContext();
6862 EVENT(context, GLIndexubv, "context = %d, c = 0x%016" PRIxPTR "", CID(context), (uintptr_t)c);
6863
6864 if (context)
6865 {
6866 SCOPED_SHARE_CONTEXT_LOCK(context);
6867 bool isCallValid =
6868 (context->skipValidation() ||
6869 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6870 context->getMutableErrorSetForValidation(),
6871 angle::EntryPoint::GLIndexubv) &&
6872 ValidateIndexubv(context, angle::EntryPoint::GLIndexubv, c)));
6873 if (isCallValid)
6874 {
6875 context->indexubv(c);
6876 }
6877 ANGLE_CAPTURE_GL(Indexubv, isCallValid, context, c);
6878 }
6879 else
6880 {
6881 GenerateContextLostErrorOnCurrentGlobalContext();
6882 }
6883 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6884 }
6885
GL_InterleavedArrays(GLenum format,GLsizei stride,const void * pointer)6886 void GL_APIENTRY GL_InterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
6887 {
6888 Context *context = GetValidGlobalContext();
6889 EVENT(context, GLInterleavedArrays,
6890 "context = %d, format = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
6891 GLenumToString(BigGLEnum::InterleavedArrayFormat, format), stride, (uintptr_t)pointer);
6892
6893 if (context)
6894 {
6895 SCOPED_SHARE_CONTEXT_LOCK(context);
6896 bool isCallValid =
6897 (context->skipValidation() ||
6898 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6899 context->getMutableErrorSetForValidation(),
6900 angle::EntryPoint::GLInterleavedArrays) &&
6901 ValidateInterleavedArrays(context, angle::EntryPoint::GLInterleavedArrays, format,
6902 stride, pointer)));
6903 if (isCallValid)
6904 {
6905 context->interleavedArrays(format, stride, pointer);
6906 }
6907 ANGLE_CAPTURE_GL(InterleavedArrays, isCallValid, context, format, stride, pointer);
6908 }
6909 else
6910 {
6911 GenerateContextLostErrorOnCurrentGlobalContext();
6912 }
6913 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6914 }
6915
GL_PopClientAttrib()6916 void GL_APIENTRY GL_PopClientAttrib()
6917 {
6918 Context *context = GetValidGlobalContext();
6919 EVENT(context, GLPopClientAttrib, "context = %d", CID(context));
6920
6921 if (context)
6922 {
6923 SCOPED_SHARE_CONTEXT_LOCK(context);
6924 bool isCallValid =
6925 (context->skipValidation() ||
6926 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6927 context->getMutableErrorSetForValidation(),
6928 angle::EntryPoint::GLPopClientAttrib) &&
6929 ValidatePopClientAttrib(context, angle::EntryPoint::GLPopClientAttrib)));
6930 if (isCallValid)
6931 {
6932 context->popClientAttrib();
6933 }
6934 ANGLE_CAPTURE_GL(PopClientAttrib, isCallValid, context);
6935 }
6936 else
6937 {
6938 GenerateContextLostErrorOnCurrentGlobalContext();
6939 }
6940 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6941 }
6942
GL_PrioritizeTextures(GLsizei n,const GLuint * textures,const GLfloat * priorities)6943 void GL_APIENTRY GL_PrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
6944 {
6945 Context *context = GetValidGlobalContext();
6946 EVENT(context, GLPrioritizeTextures,
6947 "context = %d, n = %d, textures = 0x%016" PRIxPTR ", priorities = 0x%016" PRIxPTR "",
6948 CID(context), n, (uintptr_t)textures, (uintptr_t)priorities);
6949
6950 if (context)
6951 {
6952 SCOPED_SHARE_CONTEXT_LOCK(context);
6953 bool isCallValid =
6954 (context->skipValidation() ||
6955 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6956 context->getMutableErrorSetForValidation(),
6957 angle::EntryPoint::GLPrioritizeTextures) &&
6958 ValidatePrioritizeTextures(context, angle::EntryPoint::GLPrioritizeTextures, n,
6959 textures, priorities)));
6960 if (isCallValid)
6961 {
6962 context->prioritizeTextures(n, textures, priorities);
6963 }
6964 ANGLE_CAPTURE_GL(PrioritizeTextures, isCallValid, context, n, textures, priorities);
6965 }
6966 else
6967 {
6968 GenerateContextLostErrorOnCurrentGlobalContext();
6969 }
6970 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6971 }
6972
GL_PushClientAttrib(GLbitfield mask)6973 void GL_APIENTRY GL_PushClientAttrib(GLbitfield mask)
6974 {
6975 Context *context = GetValidGlobalContext();
6976 EVENT(context, GLPushClientAttrib, "context = %d, mask = %s", CID(context),
6977 GLbitfieldToString(BigGLEnum::ClientAttribMask, mask).c_str());
6978
6979 if (context)
6980 {
6981 SCOPED_SHARE_CONTEXT_LOCK(context);
6982 bool isCallValid =
6983 (context->skipValidation() ||
6984 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6985 context->getMutableErrorSetForValidation(),
6986 angle::EntryPoint::GLPushClientAttrib) &&
6987 ValidatePushClientAttrib(context, angle::EntryPoint::GLPushClientAttrib, mask)));
6988 if (isCallValid)
6989 {
6990 context->pushClientAttrib(mask);
6991 }
6992 ANGLE_CAPTURE_GL(PushClientAttrib, isCallValid, context, mask);
6993 }
6994 else
6995 {
6996 GenerateContextLostErrorOnCurrentGlobalContext();
6997 }
6998 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6999 }
7000
GL_TexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void * pixels)7001 void GL_APIENTRY GL_TexSubImage1D(GLenum target,
7002 GLint level,
7003 GLint xoffset,
7004 GLsizei width,
7005 GLenum format,
7006 GLenum type,
7007 const void *pixels)
7008 {
7009 Context *context = GetValidGlobalContext();
7010 EVENT(context, GLTexSubImage1D,
7011 "context = %d, target = %s, level = %d, xoffset = %d, width = %d, format = %s, type = "
7012 "%s, pixels = 0x%016" PRIxPTR "",
7013 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, xoffset, width,
7014 GLenumToString(BigGLEnum::PixelFormat, format),
7015 GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels);
7016
7017 if (context)
7018 {
7019 SCOPED_SHARE_CONTEXT_LOCK(context);
7020 bool isCallValid =
7021 (context->skipValidation() ||
7022 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7023 context->getMutableErrorSetForValidation(),
7024 angle::EntryPoint::GLTexSubImage1D) &&
7025 ValidateTexSubImage1D(context, angle::EntryPoint::GLTexSubImage1D, target, level,
7026 xoffset, width, format, type, pixels)));
7027 if (isCallValid)
7028 {
7029 context->texSubImage1D(target, level, xoffset, width, format, type, pixels);
7030 }
7031 ANGLE_CAPTURE_GL(TexSubImage1D, isCallValid, context, target, level, xoffset, width, format,
7032 type, pixels);
7033 }
7034 else
7035 {
7036 GenerateContextLostErrorOnCurrentGlobalContext();
7037 }
7038 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7039 }
7040
7041 // GL 1.2
7042
7043 // GL 1.3
GL_CompressedTexImage1D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void * data)7044 void GL_APIENTRY GL_CompressedTexImage1D(GLenum target,
7045 GLint level,
7046 GLenum internalformat,
7047 GLsizei width,
7048 GLint border,
7049 GLsizei imageSize,
7050 const void *data)
7051 {
7052 Context *context = GetValidGlobalContext();
7053 EVENT(context, GLCompressedTexImage1D,
7054 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, border = %d, "
7055 "imageSize = %d, data = 0x%016" PRIxPTR "",
7056 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level,
7057 GLenumToString(BigGLEnum::InternalFormat, internalformat), width, border, imageSize,
7058 (uintptr_t)data);
7059
7060 if (context)
7061 {
7062 SCOPED_SHARE_CONTEXT_LOCK(context);
7063 bool isCallValid =
7064 (context->skipValidation() ||
7065 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7066 context->getMutableErrorSetForValidation(),
7067 angle::EntryPoint::GLCompressedTexImage1D) &&
7068 ValidateCompressedTexImage1D(context, angle::EntryPoint::GLCompressedTexImage1D,
7069 target, level, internalformat, width, border, imageSize,
7070 data)));
7071 if (isCallValid)
7072 {
7073 context->compressedTexImage1D(target, level, internalformat, width, border, imageSize,
7074 data);
7075 }
7076 ANGLE_CAPTURE_GL(CompressedTexImage1D, isCallValid, context, target, level, internalformat,
7077 width, border, imageSize, data);
7078 }
7079 else
7080 {
7081 GenerateContextLostErrorOnCurrentGlobalContext();
7082 }
7083 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7084 }
7085
GL_CompressedTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void * data)7086 void GL_APIENTRY GL_CompressedTexSubImage1D(GLenum target,
7087 GLint level,
7088 GLint xoffset,
7089 GLsizei width,
7090 GLenum format,
7091 GLsizei imageSize,
7092 const void *data)
7093 {
7094 Context *context = GetValidGlobalContext();
7095 EVENT(context, GLCompressedTexSubImage1D,
7096 "context = %d, target = %s, level = %d, xoffset = %d, width = %d, format = %s, imageSize "
7097 "= %d, data = 0x%016" PRIxPTR "",
7098 CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, xoffset, width,
7099 GLenumToString(BigGLEnum::InternalFormat, format), imageSize, (uintptr_t)data);
7100
7101 if (context)
7102 {
7103 SCOPED_SHARE_CONTEXT_LOCK(context);
7104 bool isCallValid =
7105 (context->skipValidation() ||
7106 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7107 context->getMutableErrorSetForValidation(),
7108 angle::EntryPoint::GLCompressedTexSubImage1D) &&
7109 ValidateCompressedTexSubImage1D(context, angle::EntryPoint::GLCompressedTexSubImage1D,
7110 target, level, xoffset, width, format, imageSize,
7111 data)));
7112 if (isCallValid)
7113 {
7114 context->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize,
7115 data);
7116 }
7117 ANGLE_CAPTURE_GL(CompressedTexSubImage1D, isCallValid, context, target, level, xoffset,
7118 width, format, imageSize, data);
7119 }
7120 else
7121 {
7122 GenerateContextLostErrorOnCurrentGlobalContext();
7123 }
7124 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7125 }
7126
GL_GetCompressedTexImage(GLenum target,GLint level,void * img)7127 void GL_APIENTRY GL_GetCompressedTexImage(GLenum target, GLint level, void *img)
7128 {
7129 Context *context = GetValidGlobalContext();
7130 EVENT(context, GLGetCompressedTexImage,
7131 "context = %d, target = %s, level = %d, img = 0x%016" PRIxPTR "", CID(context),
7132 GLenumToString(BigGLEnum::TextureTarget, target), level, (uintptr_t)img);
7133
7134 if (context)
7135 {
7136 TextureTarget targetPacked = PackParam<TextureTarget>(target);
7137 SCOPED_SHARE_CONTEXT_LOCK(context);
7138 bool isCallValid =
7139 (context->skipValidation() ||
7140 ValidateGetCompressedTexImage(context, angle::EntryPoint::GLGetCompressedTexImage,
7141 targetPacked, level, img));
7142 if (isCallValid)
7143 {
7144 context->getCompressedTexImage(targetPacked, level, img);
7145 }
7146 ANGLE_CAPTURE_GL(GetCompressedTexImage, isCallValid, context, targetPacked, level, img);
7147 }
7148 else
7149 {
7150 GenerateContextLostErrorOnCurrentGlobalContext();
7151 }
7152 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7153 }
7154
GL_LoadTransposeMatrixd(const GLdouble * m)7155 void GL_APIENTRY GL_LoadTransposeMatrixd(const GLdouble *m)
7156 {
7157 Context *context = GetValidGlobalContext();
7158 EVENT(context, GLLoadTransposeMatrixd, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
7159 (uintptr_t)m);
7160
7161 if (context)
7162 {
7163 SCOPED_SHARE_CONTEXT_LOCK(context);
7164 bool isCallValid =
7165 (context->skipValidation() ||
7166 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7167 context->getMutableErrorSetForValidation(),
7168 angle::EntryPoint::GLLoadTransposeMatrixd) &&
7169 ValidateLoadTransposeMatrixd(context, angle::EntryPoint::GLLoadTransposeMatrixd, m)));
7170 if (isCallValid)
7171 {
7172 context->loadTransposeMatrixd(m);
7173 }
7174 ANGLE_CAPTURE_GL(LoadTransposeMatrixd, isCallValid, context, m);
7175 }
7176 else
7177 {
7178 GenerateContextLostErrorOnCurrentGlobalContext();
7179 }
7180 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7181 }
7182
GL_LoadTransposeMatrixf(const GLfloat * m)7183 void GL_APIENTRY GL_LoadTransposeMatrixf(const GLfloat *m)
7184 {
7185 Context *context = GetValidGlobalContext();
7186 EVENT(context, GLLoadTransposeMatrixf, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
7187 (uintptr_t)m);
7188
7189 if (context)
7190 {
7191 SCOPED_SHARE_CONTEXT_LOCK(context);
7192 bool isCallValid =
7193 (context->skipValidation() ||
7194 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7195 context->getMutableErrorSetForValidation(),
7196 angle::EntryPoint::GLLoadTransposeMatrixf) &&
7197 ValidateLoadTransposeMatrixf(context, angle::EntryPoint::GLLoadTransposeMatrixf, m)));
7198 if (isCallValid)
7199 {
7200 context->loadTransposeMatrixf(m);
7201 }
7202 ANGLE_CAPTURE_GL(LoadTransposeMatrixf, isCallValid, context, m);
7203 }
7204 else
7205 {
7206 GenerateContextLostErrorOnCurrentGlobalContext();
7207 }
7208 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7209 }
7210
GL_MultTransposeMatrixd(const GLdouble * m)7211 void GL_APIENTRY GL_MultTransposeMatrixd(const GLdouble *m)
7212 {
7213 Context *context = GetValidGlobalContext();
7214 EVENT(context, GLMultTransposeMatrixd, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
7215 (uintptr_t)m);
7216
7217 if (context)
7218 {
7219 SCOPED_SHARE_CONTEXT_LOCK(context);
7220 bool isCallValid =
7221 (context->skipValidation() ||
7222 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7223 context->getMutableErrorSetForValidation(),
7224 angle::EntryPoint::GLMultTransposeMatrixd) &&
7225 ValidateMultTransposeMatrixd(context, angle::EntryPoint::GLMultTransposeMatrixd, m)));
7226 if (isCallValid)
7227 {
7228 context->multTransposeMatrixd(m);
7229 }
7230 ANGLE_CAPTURE_GL(MultTransposeMatrixd, isCallValid, context, m);
7231 }
7232 else
7233 {
7234 GenerateContextLostErrorOnCurrentGlobalContext();
7235 }
7236 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7237 }
7238
GL_MultTransposeMatrixf(const GLfloat * m)7239 void GL_APIENTRY GL_MultTransposeMatrixf(const GLfloat *m)
7240 {
7241 Context *context = GetValidGlobalContext();
7242 EVENT(context, GLMultTransposeMatrixf, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
7243 (uintptr_t)m);
7244
7245 if (context)
7246 {
7247 SCOPED_SHARE_CONTEXT_LOCK(context);
7248 bool isCallValid =
7249 (context->skipValidation() ||
7250 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7251 context->getMutableErrorSetForValidation(),
7252 angle::EntryPoint::GLMultTransposeMatrixf) &&
7253 ValidateMultTransposeMatrixf(context, angle::EntryPoint::GLMultTransposeMatrixf, m)));
7254 if (isCallValid)
7255 {
7256 context->multTransposeMatrixf(m);
7257 }
7258 ANGLE_CAPTURE_GL(MultTransposeMatrixf, isCallValid, context, m);
7259 }
7260 else
7261 {
7262 GenerateContextLostErrorOnCurrentGlobalContext();
7263 }
7264 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7265 }
7266
GL_MultiTexCoord1d(GLenum target,GLdouble s)7267 void GL_APIENTRY GL_MultiTexCoord1d(GLenum target, GLdouble s)
7268 {
7269 Context *context = GetValidGlobalContext();
7270 EVENT(context, GLMultiTexCoord1d, "context = %d, target = %s, s = %f", CID(context),
7271 GLenumToString(BigGLEnum::TextureUnit, target), s);
7272
7273 if (context)
7274 {
7275 SCOPED_SHARE_CONTEXT_LOCK(context);
7276 bool isCallValid =
7277 (context->skipValidation() ||
7278 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7279 context->getMutableErrorSetForValidation(),
7280 angle::EntryPoint::GLMultiTexCoord1d) &&
7281 ValidateMultiTexCoord1d(context, angle::EntryPoint::GLMultiTexCoord1d, target, s)));
7282 if (isCallValid)
7283 {
7284 context->multiTexCoord1d(target, s);
7285 }
7286 ANGLE_CAPTURE_GL(MultiTexCoord1d, isCallValid, context, target, s);
7287 }
7288 else
7289 {
7290 GenerateContextLostErrorOnCurrentGlobalContext();
7291 }
7292 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7293 }
7294
GL_MultiTexCoord1dv(GLenum target,const GLdouble * v)7295 void GL_APIENTRY GL_MultiTexCoord1dv(GLenum target, const GLdouble *v)
7296 {
7297 Context *context = GetValidGlobalContext();
7298 EVENT(context, GLMultiTexCoord1dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7299 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7300
7301 if (context)
7302 {
7303 SCOPED_SHARE_CONTEXT_LOCK(context);
7304 bool isCallValid =
7305 (context->skipValidation() ||
7306 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7307 context->getMutableErrorSetForValidation(),
7308 angle::EntryPoint::GLMultiTexCoord1dv) &&
7309 ValidateMultiTexCoord1dv(context, angle::EntryPoint::GLMultiTexCoord1dv, target, v)));
7310 if (isCallValid)
7311 {
7312 context->multiTexCoord1dv(target, v);
7313 }
7314 ANGLE_CAPTURE_GL(MultiTexCoord1dv, isCallValid, context, target, v);
7315 }
7316 else
7317 {
7318 GenerateContextLostErrorOnCurrentGlobalContext();
7319 }
7320 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7321 }
7322
GL_MultiTexCoord1f(GLenum target,GLfloat s)7323 void GL_APIENTRY GL_MultiTexCoord1f(GLenum target, GLfloat s)
7324 {
7325 Context *context = GetValidGlobalContext();
7326 EVENT(context, GLMultiTexCoord1f, "context = %d, target = %s, s = %f", CID(context),
7327 GLenumToString(BigGLEnum::TextureUnit, target), s);
7328
7329 if (context)
7330 {
7331 SCOPED_SHARE_CONTEXT_LOCK(context);
7332 bool isCallValid =
7333 (context->skipValidation() ||
7334 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7335 context->getMutableErrorSetForValidation(),
7336 angle::EntryPoint::GLMultiTexCoord1f) &&
7337 ValidateMultiTexCoord1f(context, angle::EntryPoint::GLMultiTexCoord1f, target, s)));
7338 if (isCallValid)
7339 {
7340 context->multiTexCoord1f(target, s);
7341 }
7342 ANGLE_CAPTURE_GL(MultiTexCoord1f, isCallValid, context, target, s);
7343 }
7344 else
7345 {
7346 GenerateContextLostErrorOnCurrentGlobalContext();
7347 }
7348 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7349 }
7350
GL_MultiTexCoord1fv(GLenum target,const GLfloat * v)7351 void GL_APIENTRY GL_MultiTexCoord1fv(GLenum target, const GLfloat *v)
7352 {
7353 Context *context = GetValidGlobalContext();
7354 EVENT(context, GLMultiTexCoord1fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7355 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7356
7357 if (context)
7358 {
7359 SCOPED_SHARE_CONTEXT_LOCK(context);
7360 bool isCallValid =
7361 (context->skipValidation() ||
7362 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7363 context->getMutableErrorSetForValidation(),
7364 angle::EntryPoint::GLMultiTexCoord1fv) &&
7365 ValidateMultiTexCoord1fv(context, angle::EntryPoint::GLMultiTexCoord1fv, target, v)));
7366 if (isCallValid)
7367 {
7368 context->multiTexCoord1fv(target, v);
7369 }
7370 ANGLE_CAPTURE_GL(MultiTexCoord1fv, isCallValid, context, target, v);
7371 }
7372 else
7373 {
7374 GenerateContextLostErrorOnCurrentGlobalContext();
7375 }
7376 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7377 }
7378
GL_MultiTexCoord1i(GLenum target,GLint s)7379 void GL_APIENTRY GL_MultiTexCoord1i(GLenum target, GLint s)
7380 {
7381 Context *context = GetValidGlobalContext();
7382 EVENT(context, GLMultiTexCoord1i, "context = %d, target = %s, s = %d", CID(context),
7383 GLenumToString(BigGLEnum::TextureUnit, target), s);
7384
7385 if (context)
7386 {
7387 SCOPED_SHARE_CONTEXT_LOCK(context);
7388 bool isCallValid =
7389 (context->skipValidation() ||
7390 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7391 context->getMutableErrorSetForValidation(),
7392 angle::EntryPoint::GLMultiTexCoord1i) &&
7393 ValidateMultiTexCoord1i(context, angle::EntryPoint::GLMultiTexCoord1i, target, s)));
7394 if (isCallValid)
7395 {
7396 context->multiTexCoord1i(target, s);
7397 }
7398 ANGLE_CAPTURE_GL(MultiTexCoord1i, isCallValid, context, target, s);
7399 }
7400 else
7401 {
7402 GenerateContextLostErrorOnCurrentGlobalContext();
7403 }
7404 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7405 }
7406
GL_MultiTexCoord1iv(GLenum target,const GLint * v)7407 void GL_APIENTRY GL_MultiTexCoord1iv(GLenum target, const GLint *v)
7408 {
7409 Context *context = GetValidGlobalContext();
7410 EVENT(context, GLMultiTexCoord1iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7411 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7412
7413 if (context)
7414 {
7415 SCOPED_SHARE_CONTEXT_LOCK(context);
7416 bool isCallValid =
7417 (context->skipValidation() ||
7418 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7419 context->getMutableErrorSetForValidation(),
7420 angle::EntryPoint::GLMultiTexCoord1iv) &&
7421 ValidateMultiTexCoord1iv(context, angle::EntryPoint::GLMultiTexCoord1iv, target, v)));
7422 if (isCallValid)
7423 {
7424 context->multiTexCoord1iv(target, v);
7425 }
7426 ANGLE_CAPTURE_GL(MultiTexCoord1iv, isCallValid, context, target, v);
7427 }
7428 else
7429 {
7430 GenerateContextLostErrorOnCurrentGlobalContext();
7431 }
7432 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7433 }
7434
GL_MultiTexCoord1s(GLenum target,GLshort s)7435 void GL_APIENTRY GL_MultiTexCoord1s(GLenum target, GLshort s)
7436 {
7437 Context *context = GetValidGlobalContext();
7438 EVENT(context, GLMultiTexCoord1s, "context = %d, target = %s, s = %d", CID(context),
7439 GLenumToString(BigGLEnum::TextureUnit, target), s);
7440
7441 if (context)
7442 {
7443 SCOPED_SHARE_CONTEXT_LOCK(context);
7444 bool isCallValid =
7445 (context->skipValidation() ||
7446 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7447 context->getMutableErrorSetForValidation(),
7448 angle::EntryPoint::GLMultiTexCoord1s) &&
7449 ValidateMultiTexCoord1s(context, angle::EntryPoint::GLMultiTexCoord1s, target, s)));
7450 if (isCallValid)
7451 {
7452 context->multiTexCoord1s(target, s);
7453 }
7454 ANGLE_CAPTURE_GL(MultiTexCoord1s, isCallValid, context, target, s);
7455 }
7456 else
7457 {
7458 GenerateContextLostErrorOnCurrentGlobalContext();
7459 }
7460 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7461 }
7462
GL_MultiTexCoord1sv(GLenum target,const GLshort * v)7463 void GL_APIENTRY GL_MultiTexCoord1sv(GLenum target, const GLshort *v)
7464 {
7465 Context *context = GetValidGlobalContext();
7466 EVENT(context, GLMultiTexCoord1sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7467 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7468
7469 if (context)
7470 {
7471 SCOPED_SHARE_CONTEXT_LOCK(context);
7472 bool isCallValid =
7473 (context->skipValidation() ||
7474 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7475 context->getMutableErrorSetForValidation(),
7476 angle::EntryPoint::GLMultiTexCoord1sv) &&
7477 ValidateMultiTexCoord1sv(context, angle::EntryPoint::GLMultiTexCoord1sv, target, v)));
7478 if (isCallValid)
7479 {
7480 context->multiTexCoord1sv(target, v);
7481 }
7482 ANGLE_CAPTURE_GL(MultiTexCoord1sv, isCallValid, context, target, v);
7483 }
7484 else
7485 {
7486 GenerateContextLostErrorOnCurrentGlobalContext();
7487 }
7488 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7489 }
7490
GL_MultiTexCoord2d(GLenum target,GLdouble s,GLdouble t)7491 void GL_APIENTRY GL_MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
7492 {
7493 Context *context = GetValidGlobalContext();
7494 EVENT(context, GLMultiTexCoord2d, "context = %d, target = %s, s = %f, t = %f", CID(context),
7495 GLenumToString(BigGLEnum::TextureUnit, target), s, t);
7496
7497 if (context)
7498 {
7499 SCOPED_SHARE_CONTEXT_LOCK(context);
7500 bool isCallValid =
7501 (context->skipValidation() ||
7502 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7503 context->getMutableErrorSetForValidation(),
7504 angle::EntryPoint::GLMultiTexCoord2d) &&
7505 ValidateMultiTexCoord2d(context, angle::EntryPoint::GLMultiTexCoord2d, target, s,
7506 t)));
7507 if (isCallValid)
7508 {
7509 context->multiTexCoord2d(target, s, t);
7510 }
7511 ANGLE_CAPTURE_GL(MultiTexCoord2d, isCallValid, context, target, s, t);
7512 }
7513 else
7514 {
7515 GenerateContextLostErrorOnCurrentGlobalContext();
7516 }
7517 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7518 }
7519
GL_MultiTexCoord2dv(GLenum target,const GLdouble * v)7520 void GL_APIENTRY GL_MultiTexCoord2dv(GLenum target, const GLdouble *v)
7521 {
7522 Context *context = GetValidGlobalContext();
7523 EVENT(context, GLMultiTexCoord2dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7524 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7525
7526 if (context)
7527 {
7528 SCOPED_SHARE_CONTEXT_LOCK(context);
7529 bool isCallValid =
7530 (context->skipValidation() ||
7531 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7532 context->getMutableErrorSetForValidation(),
7533 angle::EntryPoint::GLMultiTexCoord2dv) &&
7534 ValidateMultiTexCoord2dv(context, angle::EntryPoint::GLMultiTexCoord2dv, target, v)));
7535 if (isCallValid)
7536 {
7537 context->multiTexCoord2dv(target, v);
7538 }
7539 ANGLE_CAPTURE_GL(MultiTexCoord2dv, isCallValid, context, target, v);
7540 }
7541 else
7542 {
7543 GenerateContextLostErrorOnCurrentGlobalContext();
7544 }
7545 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7546 }
7547
GL_MultiTexCoord2f(GLenum target,GLfloat s,GLfloat t)7548 void GL_APIENTRY GL_MultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
7549 {
7550 Context *context = GetValidGlobalContext();
7551 EVENT(context, GLMultiTexCoord2f, "context = %d, target = %s, s = %f, t = %f", CID(context),
7552 GLenumToString(BigGLEnum::TextureUnit, target), s, t);
7553
7554 if (context)
7555 {
7556 SCOPED_SHARE_CONTEXT_LOCK(context);
7557 bool isCallValid =
7558 (context->skipValidation() ||
7559 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7560 context->getMutableErrorSetForValidation(),
7561 angle::EntryPoint::GLMultiTexCoord2f) &&
7562 ValidateMultiTexCoord2f(context, angle::EntryPoint::GLMultiTexCoord2f, target, s,
7563 t)));
7564 if (isCallValid)
7565 {
7566 context->multiTexCoord2f(target, s, t);
7567 }
7568 ANGLE_CAPTURE_GL(MultiTexCoord2f, isCallValid, context, target, s, t);
7569 }
7570 else
7571 {
7572 GenerateContextLostErrorOnCurrentGlobalContext();
7573 }
7574 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7575 }
7576
GL_MultiTexCoord2fv(GLenum target,const GLfloat * v)7577 void GL_APIENTRY GL_MultiTexCoord2fv(GLenum target, const GLfloat *v)
7578 {
7579 Context *context = GetValidGlobalContext();
7580 EVENT(context, GLMultiTexCoord2fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7581 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7582
7583 if (context)
7584 {
7585 SCOPED_SHARE_CONTEXT_LOCK(context);
7586 bool isCallValid =
7587 (context->skipValidation() ||
7588 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7589 context->getMutableErrorSetForValidation(),
7590 angle::EntryPoint::GLMultiTexCoord2fv) &&
7591 ValidateMultiTexCoord2fv(context, angle::EntryPoint::GLMultiTexCoord2fv, target, v)));
7592 if (isCallValid)
7593 {
7594 context->multiTexCoord2fv(target, v);
7595 }
7596 ANGLE_CAPTURE_GL(MultiTexCoord2fv, isCallValid, context, target, v);
7597 }
7598 else
7599 {
7600 GenerateContextLostErrorOnCurrentGlobalContext();
7601 }
7602 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7603 }
7604
GL_MultiTexCoord2i(GLenum target,GLint s,GLint t)7605 void GL_APIENTRY GL_MultiTexCoord2i(GLenum target, GLint s, GLint t)
7606 {
7607 Context *context = GetValidGlobalContext();
7608 EVENT(context, GLMultiTexCoord2i, "context = %d, target = %s, s = %d, t = %d", CID(context),
7609 GLenumToString(BigGLEnum::TextureUnit, target), s, t);
7610
7611 if (context)
7612 {
7613 SCOPED_SHARE_CONTEXT_LOCK(context);
7614 bool isCallValid =
7615 (context->skipValidation() ||
7616 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7617 context->getMutableErrorSetForValidation(),
7618 angle::EntryPoint::GLMultiTexCoord2i) &&
7619 ValidateMultiTexCoord2i(context, angle::EntryPoint::GLMultiTexCoord2i, target, s,
7620 t)));
7621 if (isCallValid)
7622 {
7623 context->multiTexCoord2i(target, s, t);
7624 }
7625 ANGLE_CAPTURE_GL(MultiTexCoord2i, isCallValid, context, target, s, t);
7626 }
7627 else
7628 {
7629 GenerateContextLostErrorOnCurrentGlobalContext();
7630 }
7631 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7632 }
7633
GL_MultiTexCoord2iv(GLenum target,const GLint * v)7634 void GL_APIENTRY GL_MultiTexCoord2iv(GLenum target, const GLint *v)
7635 {
7636 Context *context = GetValidGlobalContext();
7637 EVENT(context, GLMultiTexCoord2iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7638 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7639
7640 if (context)
7641 {
7642 SCOPED_SHARE_CONTEXT_LOCK(context);
7643 bool isCallValid =
7644 (context->skipValidation() ||
7645 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7646 context->getMutableErrorSetForValidation(),
7647 angle::EntryPoint::GLMultiTexCoord2iv) &&
7648 ValidateMultiTexCoord2iv(context, angle::EntryPoint::GLMultiTexCoord2iv, target, v)));
7649 if (isCallValid)
7650 {
7651 context->multiTexCoord2iv(target, v);
7652 }
7653 ANGLE_CAPTURE_GL(MultiTexCoord2iv, isCallValid, context, target, v);
7654 }
7655 else
7656 {
7657 GenerateContextLostErrorOnCurrentGlobalContext();
7658 }
7659 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7660 }
7661
GL_MultiTexCoord2s(GLenum target,GLshort s,GLshort t)7662 void GL_APIENTRY GL_MultiTexCoord2s(GLenum target, GLshort s, GLshort t)
7663 {
7664 Context *context = GetValidGlobalContext();
7665 EVENT(context, GLMultiTexCoord2s, "context = %d, target = %s, s = %d, t = %d", CID(context),
7666 GLenumToString(BigGLEnum::TextureUnit, target), s, t);
7667
7668 if (context)
7669 {
7670 SCOPED_SHARE_CONTEXT_LOCK(context);
7671 bool isCallValid =
7672 (context->skipValidation() ||
7673 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7674 context->getMutableErrorSetForValidation(),
7675 angle::EntryPoint::GLMultiTexCoord2s) &&
7676 ValidateMultiTexCoord2s(context, angle::EntryPoint::GLMultiTexCoord2s, target, s,
7677 t)));
7678 if (isCallValid)
7679 {
7680 context->multiTexCoord2s(target, s, t);
7681 }
7682 ANGLE_CAPTURE_GL(MultiTexCoord2s, isCallValid, context, target, s, t);
7683 }
7684 else
7685 {
7686 GenerateContextLostErrorOnCurrentGlobalContext();
7687 }
7688 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7689 }
7690
GL_MultiTexCoord2sv(GLenum target,const GLshort * v)7691 void GL_APIENTRY GL_MultiTexCoord2sv(GLenum target, const GLshort *v)
7692 {
7693 Context *context = GetValidGlobalContext();
7694 EVENT(context, GLMultiTexCoord2sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7695 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7696
7697 if (context)
7698 {
7699 SCOPED_SHARE_CONTEXT_LOCK(context);
7700 bool isCallValid =
7701 (context->skipValidation() ||
7702 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7703 context->getMutableErrorSetForValidation(),
7704 angle::EntryPoint::GLMultiTexCoord2sv) &&
7705 ValidateMultiTexCoord2sv(context, angle::EntryPoint::GLMultiTexCoord2sv, target, v)));
7706 if (isCallValid)
7707 {
7708 context->multiTexCoord2sv(target, v);
7709 }
7710 ANGLE_CAPTURE_GL(MultiTexCoord2sv, isCallValid, context, target, v);
7711 }
7712 else
7713 {
7714 GenerateContextLostErrorOnCurrentGlobalContext();
7715 }
7716 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7717 }
7718
GL_MultiTexCoord3d(GLenum target,GLdouble s,GLdouble t,GLdouble r)7719 void GL_APIENTRY GL_MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
7720 {
7721 Context *context = GetValidGlobalContext();
7722 EVENT(context, GLMultiTexCoord3d, "context = %d, target = %s, s = %f, t = %f, r = %f",
7723 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r);
7724
7725 if (context)
7726 {
7727 SCOPED_SHARE_CONTEXT_LOCK(context);
7728 bool isCallValid =
7729 (context->skipValidation() ||
7730 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7731 context->getMutableErrorSetForValidation(),
7732 angle::EntryPoint::GLMultiTexCoord3d) &&
7733 ValidateMultiTexCoord3d(context, angle::EntryPoint::GLMultiTexCoord3d, target, s, t,
7734 r)));
7735 if (isCallValid)
7736 {
7737 context->multiTexCoord3d(target, s, t, r);
7738 }
7739 ANGLE_CAPTURE_GL(MultiTexCoord3d, isCallValid, context, target, s, t, r);
7740 }
7741 else
7742 {
7743 GenerateContextLostErrorOnCurrentGlobalContext();
7744 }
7745 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7746 }
7747
GL_MultiTexCoord3dv(GLenum target,const GLdouble * v)7748 void GL_APIENTRY GL_MultiTexCoord3dv(GLenum target, const GLdouble *v)
7749 {
7750 Context *context = GetValidGlobalContext();
7751 EVENT(context, GLMultiTexCoord3dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7752 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7753
7754 if (context)
7755 {
7756 SCOPED_SHARE_CONTEXT_LOCK(context);
7757 bool isCallValid =
7758 (context->skipValidation() ||
7759 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7760 context->getMutableErrorSetForValidation(),
7761 angle::EntryPoint::GLMultiTexCoord3dv) &&
7762 ValidateMultiTexCoord3dv(context, angle::EntryPoint::GLMultiTexCoord3dv, target, v)));
7763 if (isCallValid)
7764 {
7765 context->multiTexCoord3dv(target, v);
7766 }
7767 ANGLE_CAPTURE_GL(MultiTexCoord3dv, isCallValid, context, target, v);
7768 }
7769 else
7770 {
7771 GenerateContextLostErrorOnCurrentGlobalContext();
7772 }
7773 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7774 }
7775
GL_MultiTexCoord3f(GLenum target,GLfloat s,GLfloat t,GLfloat r)7776 void GL_APIENTRY GL_MultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
7777 {
7778 Context *context = GetValidGlobalContext();
7779 EVENT(context, GLMultiTexCoord3f, "context = %d, target = %s, s = %f, t = %f, r = %f",
7780 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r);
7781
7782 if (context)
7783 {
7784 SCOPED_SHARE_CONTEXT_LOCK(context);
7785 bool isCallValid =
7786 (context->skipValidation() ||
7787 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7788 context->getMutableErrorSetForValidation(),
7789 angle::EntryPoint::GLMultiTexCoord3f) &&
7790 ValidateMultiTexCoord3f(context, angle::EntryPoint::GLMultiTexCoord3f, target, s, t,
7791 r)));
7792 if (isCallValid)
7793 {
7794 context->multiTexCoord3f(target, s, t, r);
7795 }
7796 ANGLE_CAPTURE_GL(MultiTexCoord3f, isCallValid, context, target, s, t, r);
7797 }
7798 else
7799 {
7800 GenerateContextLostErrorOnCurrentGlobalContext();
7801 }
7802 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7803 }
7804
GL_MultiTexCoord3fv(GLenum target,const GLfloat * v)7805 void GL_APIENTRY GL_MultiTexCoord3fv(GLenum target, const GLfloat *v)
7806 {
7807 Context *context = GetValidGlobalContext();
7808 EVENT(context, GLMultiTexCoord3fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7809 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7810
7811 if (context)
7812 {
7813 SCOPED_SHARE_CONTEXT_LOCK(context);
7814 bool isCallValid =
7815 (context->skipValidation() ||
7816 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7817 context->getMutableErrorSetForValidation(),
7818 angle::EntryPoint::GLMultiTexCoord3fv) &&
7819 ValidateMultiTexCoord3fv(context, angle::EntryPoint::GLMultiTexCoord3fv, target, v)));
7820 if (isCallValid)
7821 {
7822 context->multiTexCoord3fv(target, v);
7823 }
7824 ANGLE_CAPTURE_GL(MultiTexCoord3fv, isCallValid, context, target, v);
7825 }
7826 else
7827 {
7828 GenerateContextLostErrorOnCurrentGlobalContext();
7829 }
7830 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7831 }
7832
GL_MultiTexCoord3i(GLenum target,GLint s,GLint t,GLint r)7833 void GL_APIENTRY GL_MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
7834 {
7835 Context *context = GetValidGlobalContext();
7836 EVENT(context, GLMultiTexCoord3i, "context = %d, target = %s, s = %d, t = %d, r = %d",
7837 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r);
7838
7839 if (context)
7840 {
7841 SCOPED_SHARE_CONTEXT_LOCK(context);
7842 bool isCallValid =
7843 (context->skipValidation() ||
7844 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7845 context->getMutableErrorSetForValidation(),
7846 angle::EntryPoint::GLMultiTexCoord3i) &&
7847 ValidateMultiTexCoord3i(context, angle::EntryPoint::GLMultiTexCoord3i, target, s, t,
7848 r)));
7849 if (isCallValid)
7850 {
7851 context->multiTexCoord3i(target, s, t, r);
7852 }
7853 ANGLE_CAPTURE_GL(MultiTexCoord3i, isCallValid, context, target, s, t, r);
7854 }
7855 else
7856 {
7857 GenerateContextLostErrorOnCurrentGlobalContext();
7858 }
7859 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7860 }
7861
GL_MultiTexCoord3iv(GLenum target,const GLint * v)7862 void GL_APIENTRY GL_MultiTexCoord3iv(GLenum target, const GLint *v)
7863 {
7864 Context *context = GetValidGlobalContext();
7865 EVENT(context, GLMultiTexCoord3iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7866 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7867
7868 if (context)
7869 {
7870 SCOPED_SHARE_CONTEXT_LOCK(context);
7871 bool isCallValid =
7872 (context->skipValidation() ||
7873 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7874 context->getMutableErrorSetForValidation(),
7875 angle::EntryPoint::GLMultiTexCoord3iv) &&
7876 ValidateMultiTexCoord3iv(context, angle::EntryPoint::GLMultiTexCoord3iv, target, v)));
7877 if (isCallValid)
7878 {
7879 context->multiTexCoord3iv(target, v);
7880 }
7881 ANGLE_CAPTURE_GL(MultiTexCoord3iv, isCallValid, context, target, v);
7882 }
7883 else
7884 {
7885 GenerateContextLostErrorOnCurrentGlobalContext();
7886 }
7887 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7888 }
7889
GL_MultiTexCoord3s(GLenum target,GLshort s,GLshort t,GLshort r)7890 void GL_APIENTRY GL_MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
7891 {
7892 Context *context = GetValidGlobalContext();
7893 EVENT(context, GLMultiTexCoord3s, "context = %d, target = %s, s = %d, t = %d, r = %d",
7894 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r);
7895
7896 if (context)
7897 {
7898 SCOPED_SHARE_CONTEXT_LOCK(context);
7899 bool isCallValid =
7900 (context->skipValidation() ||
7901 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7902 context->getMutableErrorSetForValidation(),
7903 angle::EntryPoint::GLMultiTexCoord3s) &&
7904 ValidateMultiTexCoord3s(context, angle::EntryPoint::GLMultiTexCoord3s, target, s, t,
7905 r)));
7906 if (isCallValid)
7907 {
7908 context->multiTexCoord3s(target, s, t, r);
7909 }
7910 ANGLE_CAPTURE_GL(MultiTexCoord3s, isCallValid, context, target, s, t, r);
7911 }
7912 else
7913 {
7914 GenerateContextLostErrorOnCurrentGlobalContext();
7915 }
7916 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7917 }
7918
GL_MultiTexCoord3sv(GLenum target,const GLshort * v)7919 void GL_APIENTRY GL_MultiTexCoord3sv(GLenum target, const GLshort *v)
7920 {
7921 Context *context = GetValidGlobalContext();
7922 EVENT(context, GLMultiTexCoord3sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7923 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7924
7925 if (context)
7926 {
7927 SCOPED_SHARE_CONTEXT_LOCK(context);
7928 bool isCallValid =
7929 (context->skipValidation() ||
7930 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7931 context->getMutableErrorSetForValidation(),
7932 angle::EntryPoint::GLMultiTexCoord3sv) &&
7933 ValidateMultiTexCoord3sv(context, angle::EntryPoint::GLMultiTexCoord3sv, target, v)));
7934 if (isCallValid)
7935 {
7936 context->multiTexCoord3sv(target, v);
7937 }
7938 ANGLE_CAPTURE_GL(MultiTexCoord3sv, isCallValid, context, target, v);
7939 }
7940 else
7941 {
7942 GenerateContextLostErrorOnCurrentGlobalContext();
7943 }
7944 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7945 }
7946
GL_MultiTexCoord4d(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q)7947 void GL_APIENTRY GL_MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
7948 {
7949 Context *context = GetValidGlobalContext();
7950 EVENT(context, GLMultiTexCoord4d, "context = %d, target = %s, s = %f, t = %f, r = %f, q = %f",
7951 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r, q);
7952
7953 if (context)
7954 {
7955 SCOPED_SHARE_CONTEXT_LOCK(context);
7956 bool isCallValid =
7957 (context->skipValidation() ||
7958 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7959 context->getMutableErrorSetForValidation(),
7960 angle::EntryPoint::GLMultiTexCoord4d) &&
7961 ValidateMultiTexCoord4d(context, angle::EntryPoint::GLMultiTexCoord4d, target, s, t,
7962 r, q)));
7963 if (isCallValid)
7964 {
7965 context->multiTexCoord4d(target, s, t, r, q);
7966 }
7967 ANGLE_CAPTURE_GL(MultiTexCoord4d, isCallValid, context, target, s, t, r, q);
7968 }
7969 else
7970 {
7971 GenerateContextLostErrorOnCurrentGlobalContext();
7972 }
7973 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7974 }
7975
GL_MultiTexCoord4dv(GLenum target,const GLdouble * v)7976 void GL_APIENTRY GL_MultiTexCoord4dv(GLenum target, const GLdouble *v)
7977 {
7978 Context *context = GetValidGlobalContext();
7979 EVENT(context, GLMultiTexCoord4dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
7980 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
7981
7982 if (context)
7983 {
7984 SCOPED_SHARE_CONTEXT_LOCK(context);
7985 bool isCallValid =
7986 (context->skipValidation() ||
7987 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7988 context->getMutableErrorSetForValidation(),
7989 angle::EntryPoint::GLMultiTexCoord4dv) &&
7990 ValidateMultiTexCoord4dv(context, angle::EntryPoint::GLMultiTexCoord4dv, target, v)));
7991 if (isCallValid)
7992 {
7993 context->multiTexCoord4dv(target, v);
7994 }
7995 ANGLE_CAPTURE_GL(MultiTexCoord4dv, isCallValid, context, target, v);
7996 }
7997 else
7998 {
7999 GenerateContextLostErrorOnCurrentGlobalContext();
8000 }
8001 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8002 }
8003
GL_MultiTexCoord4fv(GLenum target,const GLfloat * v)8004 void GL_APIENTRY GL_MultiTexCoord4fv(GLenum target, const GLfloat *v)
8005 {
8006 Context *context = GetValidGlobalContext();
8007 EVENT(context, GLMultiTexCoord4fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
8008 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
8009
8010 if (context)
8011 {
8012 SCOPED_SHARE_CONTEXT_LOCK(context);
8013 bool isCallValid =
8014 (context->skipValidation() ||
8015 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8016 context->getMutableErrorSetForValidation(),
8017 angle::EntryPoint::GLMultiTexCoord4fv) &&
8018 ValidateMultiTexCoord4fv(context, angle::EntryPoint::GLMultiTexCoord4fv, target, v)));
8019 if (isCallValid)
8020 {
8021 context->multiTexCoord4fv(target, v);
8022 }
8023 ANGLE_CAPTURE_GL(MultiTexCoord4fv, isCallValid, context, target, v);
8024 }
8025 else
8026 {
8027 GenerateContextLostErrorOnCurrentGlobalContext();
8028 }
8029 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8030 }
8031
GL_MultiTexCoord4i(GLenum target,GLint s,GLint t,GLint r,GLint q)8032 void GL_APIENTRY GL_MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
8033 {
8034 Context *context = GetValidGlobalContext();
8035 EVENT(context, GLMultiTexCoord4i, "context = %d, target = %s, s = %d, t = %d, r = %d, q = %d",
8036 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r, q);
8037
8038 if (context)
8039 {
8040 SCOPED_SHARE_CONTEXT_LOCK(context);
8041 bool isCallValid =
8042 (context->skipValidation() ||
8043 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8044 context->getMutableErrorSetForValidation(),
8045 angle::EntryPoint::GLMultiTexCoord4i) &&
8046 ValidateMultiTexCoord4i(context, angle::EntryPoint::GLMultiTexCoord4i, target, s, t,
8047 r, q)));
8048 if (isCallValid)
8049 {
8050 context->multiTexCoord4i(target, s, t, r, q);
8051 }
8052 ANGLE_CAPTURE_GL(MultiTexCoord4i, isCallValid, context, target, s, t, r, q);
8053 }
8054 else
8055 {
8056 GenerateContextLostErrorOnCurrentGlobalContext();
8057 }
8058 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8059 }
8060
GL_MultiTexCoord4iv(GLenum target,const GLint * v)8061 void GL_APIENTRY GL_MultiTexCoord4iv(GLenum target, const GLint *v)
8062 {
8063 Context *context = GetValidGlobalContext();
8064 EVENT(context, GLMultiTexCoord4iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
8065 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
8066
8067 if (context)
8068 {
8069 SCOPED_SHARE_CONTEXT_LOCK(context);
8070 bool isCallValid =
8071 (context->skipValidation() ||
8072 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8073 context->getMutableErrorSetForValidation(),
8074 angle::EntryPoint::GLMultiTexCoord4iv) &&
8075 ValidateMultiTexCoord4iv(context, angle::EntryPoint::GLMultiTexCoord4iv, target, v)));
8076 if (isCallValid)
8077 {
8078 context->multiTexCoord4iv(target, v);
8079 }
8080 ANGLE_CAPTURE_GL(MultiTexCoord4iv, isCallValid, context, target, v);
8081 }
8082 else
8083 {
8084 GenerateContextLostErrorOnCurrentGlobalContext();
8085 }
8086 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8087 }
8088
GL_MultiTexCoord4s(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q)8089 void GL_APIENTRY GL_MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
8090 {
8091 Context *context = GetValidGlobalContext();
8092 EVENT(context, GLMultiTexCoord4s, "context = %d, target = %s, s = %d, t = %d, r = %d, q = %d",
8093 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r, q);
8094
8095 if (context)
8096 {
8097 SCOPED_SHARE_CONTEXT_LOCK(context);
8098 bool isCallValid =
8099 (context->skipValidation() ||
8100 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8101 context->getMutableErrorSetForValidation(),
8102 angle::EntryPoint::GLMultiTexCoord4s) &&
8103 ValidateMultiTexCoord4s(context, angle::EntryPoint::GLMultiTexCoord4s, target, s, t,
8104 r, q)));
8105 if (isCallValid)
8106 {
8107 context->multiTexCoord4s(target, s, t, r, q);
8108 }
8109 ANGLE_CAPTURE_GL(MultiTexCoord4s, isCallValid, context, target, s, t, r, q);
8110 }
8111 else
8112 {
8113 GenerateContextLostErrorOnCurrentGlobalContext();
8114 }
8115 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8116 }
8117
GL_MultiTexCoord4sv(GLenum target,const GLshort * v)8118 void GL_APIENTRY GL_MultiTexCoord4sv(GLenum target, const GLshort *v)
8119 {
8120 Context *context = GetValidGlobalContext();
8121 EVENT(context, GLMultiTexCoord4sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "",
8122 CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v);
8123
8124 if (context)
8125 {
8126 SCOPED_SHARE_CONTEXT_LOCK(context);
8127 bool isCallValid =
8128 (context->skipValidation() ||
8129 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8130 context->getMutableErrorSetForValidation(),
8131 angle::EntryPoint::GLMultiTexCoord4sv) &&
8132 ValidateMultiTexCoord4sv(context, angle::EntryPoint::GLMultiTexCoord4sv, target, v)));
8133 if (isCallValid)
8134 {
8135 context->multiTexCoord4sv(target, v);
8136 }
8137 ANGLE_CAPTURE_GL(MultiTexCoord4sv, isCallValid, context, target, v);
8138 }
8139 else
8140 {
8141 GenerateContextLostErrorOnCurrentGlobalContext();
8142 }
8143 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8144 }
8145
8146 // GL 1.4
GL_FogCoordPointer(GLenum type,GLsizei stride,const void * pointer)8147 void GL_APIENTRY GL_FogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
8148 {
8149 Context *context = GetValidGlobalContext();
8150 EVENT(context, GLFogCoordPointer,
8151 "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
8152 GLenumToString(BigGLEnum::FogPointerTypeEXT, type), stride, (uintptr_t)pointer);
8153
8154 if (context)
8155 {
8156 SCOPED_SHARE_CONTEXT_LOCK(context);
8157 bool isCallValid =
8158 (context->skipValidation() ||
8159 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8160 context->getMutableErrorSetForValidation(),
8161 angle::EntryPoint::GLFogCoordPointer) &&
8162 ValidateFogCoordPointer(context, angle::EntryPoint::GLFogCoordPointer, type, stride,
8163 pointer)));
8164 if (isCallValid)
8165 {
8166 context->fogCoordPointer(type, stride, pointer);
8167 }
8168 ANGLE_CAPTURE_GL(FogCoordPointer, isCallValid, context, type, stride, pointer);
8169 }
8170 else
8171 {
8172 GenerateContextLostErrorOnCurrentGlobalContext();
8173 }
8174 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8175 }
8176
GL_FogCoordd(GLdouble coord)8177 void GL_APIENTRY GL_FogCoordd(GLdouble coord)
8178 {
8179 Context *context = GetValidGlobalContext();
8180 EVENT(context, GLFogCoordd, "context = %d, coord = %f", CID(context), coord);
8181
8182 if (context)
8183 {
8184 SCOPED_SHARE_CONTEXT_LOCK(context);
8185 bool isCallValid =
8186 (context->skipValidation() ||
8187 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8188 context->getMutableErrorSetForValidation(),
8189 angle::EntryPoint::GLFogCoordd) &&
8190 ValidateFogCoordd(context, angle::EntryPoint::GLFogCoordd, coord)));
8191 if (isCallValid)
8192 {
8193 context->fogCoordd(coord);
8194 }
8195 ANGLE_CAPTURE_GL(FogCoordd, isCallValid, context, coord);
8196 }
8197 else
8198 {
8199 GenerateContextLostErrorOnCurrentGlobalContext();
8200 }
8201 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8202 }
8203
GL_FogCoorddv(const GLdouble * coord)8204 void GL_APIENTRY GL_FogCoorddv(const GLdouble *coord)
8205 {
8206 Context *context = GetValidGlobalContext();
8207 EVENT(context, GLFogCoorddv, "context = %d, coord = 0x%016" PRIxPTR "", CID(context),
8208 (uintptr_t)coord);
8209
8210 if (context)
8211 {
8212 SCOPED_SHARE_CONTEXT_LOCK(context);
8213 bool isCallValid =
8214 (context->skipValidation() ||
8215 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8216 context->getMutableErrorSetForValidation(),
8217 angle::EntryPoint::GLFogCoorddv) &&
8218 ValidateFogCoorddv(context, angle::EntryPoint::GLFogCoorddv, coord)));
8219 if (isCallValid)
8220 {
8221 context->fogCoorddv(coord);
8222 }
8223 ANGLE_CAPTURE_GL(FogCoorddv, isCallValid, context, coord);
8224 }
8225 else
8226 {
8227 GenerateContextLostErrorOnCurrentGlobalContext();
8228 }
8229 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8230 }
8231
GL_FogCoordf(GLfloat coord)8232 void GL_APIENTRY GL_FogCoordf(GLfloat coord)
8233 {
8234 Context *context = GetValidGlobalContext();
8235 EVENT(context, GLFogCoordf, "context = %d, coord = %f", CID(context), coord);
8236
8237 if (context)
8238 {
8239 SCOPED_SHARE_CONTEXT_LOCK(context);
8240 bool isCallValid =
8241 (context->skipValidation() ||
8242 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8243 context->getMutableErrorSetForValidation(),
8244 angle::EntryPoint::GLFogCoordf) &&
8245 ValidateFogCoordf(context, angle::EntryPoint::GLFogCoordf, coord)));
8246 if (isCallValid)
8247 {
8248 context->fogCoordf(coord);
8249 }
8250 ANGLE_CAPTURE_GL(FogCoordf, isCallValid, context, coord);
8251 }
8252 else
8253 {
8254 GenerateContextLostErrorOnCurrentGlobalContext();
8255 }
8256 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8257 }
8258
GL_FogCoordfv(const GLfloat * coord)8259 void GL_APIENTRY GL_FogCoordfv(const GLfloat *coord)
8260 {
8261 Context *context = GetValidGlobalContext();
8262 EVENT(context, GLFogCoordfv, "context = %d, coord = 0x%016" PRIxPTR "", CID(context),
8263 (uintptr_t)coord);
8264
8265 if (context)
8266 {
8267 SCOPED_SHARE_CONTEXT_LOCK(context);
8268 bool isCallValid =
8269 (context->skipValidation() ||
8270 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8271 context->getMutableErrorSetForValidation(),
8272 angle::EntryPoint::GLFogCoordfv) &&
8273 ValidateFogCoordfv(context, angle::EntryPoint::GLFogCoordfv, coord)));
8274 if (isCallValid)
8275 {
8276 context->fogCoordfv(coord);
8277 }
8278 ANGLE_CAPTURE_GL(FogCoordfv, isCallValid, context, coord);
8279 }
8280 else
8281 {
8282 GenerateContextLostErrorOnCurrentGlobalContext();
8283 }
8284 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8285 }
8286
GL_MultiDrawArrays(GLenum mode,const GLint * first,const GLsizei * count,GLsizei drawcount)8287 void GL_APIENTRY GL_MultiDrawArrays(GLenum mode,
8288 const GLint *first,
8289 const GLsizei *count,
8290 GLsizei drawcount)
8291 {
8292 Context *context = GetValidGlobalContext();
8293 EVENT(context, GLMultiDrawArrays,
8294 "context = %d, mode = %s, first = 0x%016" PRIxPTR ", count = 0x%016" PRIxPTR
8295 ", drawcount = %d",
8296 CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)first,
8297 (uintptr_t)count, drawcount);
8298
8299 if (context)
8300 {
8301 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
8302 SCOPED_SHARE_CONTEXT_LOCK(context);
8303 bool isCallValid =
8304 (context->skipValidation() ||
8305 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8306 context->getMutableErrorSetForValidation(),
8307 angle::EntryPoint::GLMultiDrawArrays) &&
8308 ValidateMultiDrawArrays(context, angle::EntryPoint::GLMultiDrawArrays, modePacked,
8309 first, count, drawcount)));
8310 if (isCallValid)
8311 {
8312 context->multiDrawArrays(modePacked, first, count, drawcount);
8313 }
8314 ANGLE_CAPTURE_GL(MultiDrawArrays, isCallValid, context, modePacked, first, count,
8315 drawcount);
8316 }
8317 else
8318 {
8319 GenerateContextLostErrorOnCurrentGlobalContext();
8320 }
8321 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8322 }
8323
GL_MultiDrawElements(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei drawcount)8324 void GL_APIENTRY GL_MultiDrawElements(GLenum mode,
8325 const GLsizei *count,
8326 GLenum type,
8327 const void *const *indices,
8328 GLsizei drawcount)
8329 {
8330 Context *context = GetValidGlobalContext();
8331 EVENT(context, GLMultiDrawElements,
8332 "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
8333 ", drawcount = %d",
8334 CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)count,
8335 GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indices, drawcount);
8336
8337 if (context)
8338 {
8339 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
8340 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
8341 SCOPED_SHARE_CONTEXT_LOCK(context);
8342 bool isCallValid =
8343 (context->skipValidation() ||
8344 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8345 context->getMutableErrorSetForValidation(),
8346 angle::EntryPoint::GLMultiDrawElements) &&
8347 ValidateMultiDrawElements(context, angle::EntryPoint::GLMultiDrawElements, modePacked,
8348 count, typePacked, indices, drawcount)));
8349 if (isCallValid)
8350 {
8351 context->multiDrawElements(modePacked, count, typePacked, indices, drawcount);
8352 }
8353 ANGLE_CAPTURE_GL(MultiDrawElements, isCallValid, context, modePacked, count, typePacked,
8354 indices, drawcount);
8355 }
8356 else
8357 {
8358 GenerateContextLostErrorOnCurrentGlobalContext();
8359 }
8360 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8361 }
8362
GL_PointParameteri(GLenum pname,GLint param)8363 void GL_APIENTRY GL_PointParameteri(GLenum pname, GLint param)
8364 {
8365 Context *context = GetValidGlobalContext();
8366 EVENT(context, GLPointParameteri, "context = %d, pname = %s, param = %d", CID(context),
8367 GLenumToString(BigGLEnum::AllEnums, pname), param);
8368
8369 if (context)
8370 {
8371 SCOPED_SHARE_CONTEXT_LOCK(context);
8372 bool isCallValid =
8373 (context->skipValidation() ||
8374 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8375 context->getMutableErrorSetForValidation(),
8376 angle::EntryPoint::GLPointParameteri) &&
8377 ValidatePointParameteri(context, angle::EntryPoint::GLPointParameteri, pname,
8378 param)));
8379 if (isCallValid)
8380 {
8381 context->pointParameteri(pname, param);
8382 }
8383 ANGLE_CAPTURE_GL(PointParameteri, isCallValid, context, pname, param);
8384 }
8385 else
8386 {
8387 GenerateContextLostErrorOnCurrentGlobalContext();
8388 }
8389 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8390 }
8391
GL_PointParameteriv(GLenum pname,const GLint * params)8392 void GL_APIENTRY GL_PointParameteriv(GLenum pname, const GLint *params)
8393 {
8394 Context *context = GetValidGlobalContext();
8395 EVENT(context, GLPointParameteriv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
8396 CID(context), GLenumToString(BigGLEnum::AllEnums, pname), (uintptr_t)params);
8397
8398 if (context)
8399 {
8400 SCOPED_SHARE_CONTEXT_LOCK(context);
8401 bool isCallValid =
8402 (context->skipValidation() ||
8403 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8404 context->getMutableErrorSetForValidation(),
8405 angle::EntryPoint::GLPointParameteriv) &&
8406 ValidatePointParameteriv(context, angle::EntryPoint::GLPointParameteriv, pname,
8407 params)));
8408 if (isCallValid)
8409 {
8410 context->pointParameteriv(pname, params);
8411 }
8412 ANGLE_CAPTURE_GL(PointParameteriv, isCallValid, context, pname, params);
8413 }
8414 else
8415 {
8416 GenerateContextLostErrorOnCurrentGlobalContext();
8417 }
8418 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8419 }
8420
GL_SecondaryColor3b(GLbyte red,GLbyte green,GLbyte blue)8421 void GL_APIENTRY GL_SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
8422 {
8423 Context *context = GetValidGlobalContext();
8424 EVENT(context, GLSecondaryColor3b, "context = %d, red = %d, green = %d, blue = %d",
8425 CID(context), red, green, blue);
8426
8427 if (context)
8428 {
8429 SCOPED_SHARE_CONTEXT_LOCK(context);
8430 bool isCallValid =
8431 (context->skipValidation() ||
8432 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8433 context->getMutableErrorSetForValidation(),
8434 angle::EntryPoint::GLSecondaryColor3b) &&
8435 ValidateSecondaryColor3b(context, angle::EntryPoint::GLSecondaryColor3b, red, green,
8436 blue)));
8437 if (isCallValid)
8438 {
8439 context->secondaryColor3b(red, green, blue);
8440 }
8441 ANGLE_CAPTURE_GL(SecondaryColor3b, isCallValid, context, red, green, blue);
8442 }
8443 else
8444 {
8445 GenerateContextLostErrorOnCurrentGlobalContext();
8446 }
8447 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8448 }
8449
GL_SecondaryColor3bv(const GLbyte * v)8450 void GL_APIENTRY GL_SecondaryColor3bv(const GLbyte *v)
8451 {
8452 Context *context = GetValidGlobalContext();
8453 EVENT(context, GLSecondaryColor3bv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8454 (uintptr_t)v);
8455
8456 if (context)
8457 {
8458 SCOPED_SHARE_CONTEXT_LOCK(context);
8459 bool isCallValid =
8460 (context->skipValidation() ||
8461 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8462 context->getMutableErrorSetForValidation(),
8463 angle::EntryPoint::GLSecondaryColor3bv) &&
8464 ValidateSecondaryColor3bv(context, angle::EntryPoint::GLSecondaryColor3bv, v)));
8465 if (isCallValid)
8466 {
8467 context->secondaryColor3bv(v);
8468 }
8469 ANGLE_CAPTURE_GL(SecondaryColor3bv, isCallValid, context, v);
8470 }
8471 else
8472 {
8473 GenerateContextLostErrorOnCurrentGlobalContext();
8474 }
8475 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8476 }
8477
GL_SecondaryColor3d(GLdouble red,GLdouble green,GLdouble blue)8478 void GL_APIENTRY GL_SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
8479 {
8480 Context *context = GetValidGlobalContext();
8481 EVENT(context, GLSecondaryColor3d, "context = %d, red = %f, green = %f, blue = %f",
8482 CID(context), red, green, blue);
8483
8484 if (context)
8485 {
8486 SCOPED_SHARE_CONTEXT_LOCK(context);
8487 bool isCallValid =
8488 (context->skipValidation() ||
8489 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8490 context->getMutableErrorSetForValidation(),
8491 angle::EntryPoint::GLSecondaryColor3d) &&
8492 ValidateSecondaryColor3d(context, angle::EntryPoint::GLSecondaryColor3d, red, green,
8493 blue)));
8494 if (isCallValid)
8495 {
8496 context->secondaryColor3d(red, green, blue);
8497 }
8498 ANGLE_CAPTURE_GL(SecondaryColor3d, isCallValid, context, red, green, blue);
8499 }
8500 else
8501 {
8502 GenerateContextLostErrorOnCurrentGlobalContext();
8503 }
8504 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8505 }
8506
GL_SecondaryColor3dv(const GLdouble * v)8507 void GL_APIENTRY GL_SecondaryColor3dv(const GLdouble *v)
8508 {
8509 Context *context = GetValidGlobalContext();
8510 EVENT(context, GLSecondaryColor3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8511 (uintptr_t)v);
8512
8513 if (context)
8514 {
8515 SCOPED_SHARE_CONTEXT_LOCK(context);
8516 bool isCallValid =
8517 (context->skipValidation() ||
8518 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8519 context->getMutableErrorSetForValidation(),
8520 angle::EntryPoint::GLSecondaryColor3dv) &&
8521 ValidateSecondaryColor3dv(context, angle::EntryPoint::GLSecondaryColor3dv, v)));
8522 if (isCallValid)
8523 {
8524 context->secondaryColor3dv(v);
8525 }
8526 ANGLE_CAPTURE_GL(SecondaryColor3dv, isCallValid, context, v);
8527 }
8528 else
8529 {
8530 GenerateContextLostErrorOnCurrentGlobalContext();
8531 }
8532 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8533 }
8534
GL_SecondaryColor3f(GLfloat red,GLfloat green,GLfloat blue)8535 void GL_APIENTRY GL_SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
8536 {
8537 Context *context = GetValidGlobalContext();
8538 EVENT(context, GLSecondaryColor3f, "context = %d, red = %f, green = %f, blue = %f",
8539 CID(context), red, green, blue);
8540
8541 if (context)
8542 {
8543 SCOPED_SHARE_CONTEXT_LOCK(context);
8544 bool isCallValid =
8545 (context->skipValidation() ||
8546 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8547 context->getMutableErrorSetForValidation(),
8548 angle::EntryPoint::GLSecondaryColor3f) &&
8549 ValidateSecondaryColor3f(context, angle::EntryPoint::GLSecondaryColor3f, red, green,
8550 blue)));
8551 if (isCallValid)
8552 {
8553 context->secondaryColor3f(red, green, blue);
8554 }
8555 ANGLE_CAPTURE_GL(SecondaryColor3f, isCallValid, context, red, green, blue);
8556 }
8557 else
8558 {
8559 GenerateContextLostErrorOnCurrentGlobalContext();
8560 }
8561 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8562 }
8563
GL_SecondaryColor3fv(const GLfloat * v)8564 void GL_APIENTRY GL_SecondaryColor3fv(const GLfloat *v)
8565 {
8566 Context *context = GetValidGlobalContext();
8567 EVENT(context, GLSecondaryColor3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8568 (uintptr_t)v);
8569
8570 if (context)
8571 {
8572 SCOPED_SHARE_CONTEXT_LOCK(context);
8573 bool isCallValid =
8574 (context->skipValidation() ||
8575 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8576 context->getMutableErrorSetForValidation(),
8577 angle::EntryPoint::GLSecondaryColor3fv) &&
8578 ValidateSecondaryColor3fv(context, angle::EntryPoint::GLSecondaryColor3fv, v)));
8579 if (isCallValid)
8580 {
8581 context->secondaryColor3fv(v);
8582 }
8583 ANGLE_CAPTURE_GL(SecondaryColor3fv, isCallValid, context, v);
8584 }
8585 else
8586 {
8587 GenerateContextLostErrorOnCurrentGlobalContext();
8588 }
8589 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8590 }
8591
GL_SecondaryColor3i(GLint red,GLint green,GLint blue)8592 void GL_APIENTRY GL_SecondaryColor3i(GLint red, GLint green, GLint blue)
8593 {
8594 Context *context = GetValidGlobalContext();
8595 EVENT(context, GLSecondaryColor3i, "context = %d, red = %d, green = %d, blue = %d",
8596 CID(context), red, green, blue);
8597
8598 if (context)
8599 {
8600 SCOPED_SHARE_CONTEXT_LOCK(context);
8601 bool isCallValid =
8602 (context->skipValidation() ||
8603 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8604 context->getMutableErrorSetForValidation(),
8605 angle::EntryPoint::GLSecondaryColor3i) &&
8606 ValidateSecondaryColor3i(context, angle::EntryPoint::GLSecondaryColor3i, red, green,
8607 blue)));
8608 if (isCallValid)
8609 {
8610 context->secondaryColor3i(red, green, blue);
8611 }
8612 ANGLE_CAPTURE_GL(SecondaryColor3i, isCallValid, context, red, green, blue);
8613 }
8614 else
8615 {
8616 GenerateContextLostErrorOnCurrentGlobalContext();
8617 }
8618 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8619 }
8620
GL_SecondaryColor3iv(const GLint * v)8621 void GL_APIENTRY GL_SecondaryColor3iv(const GLint *v)
8622 {
8623 Context *context = GetValidGlobalContext();
8624 EVENT(context, GLSecondaryColor3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8625 (uintptr_t)v);
8626
8627 if (context)
8628 {
8629 SCOPED_SHARE_CONTEXT_LOCK(context);
8630 bool isCallValid =
8631 (context->skipValidation() ||
8632 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8633 context->getMutableErrorSetForValidation(),
8634 angle::EntryPoint::GLSecondaryColor3iv) &&
8635 ValidateSecondaryColor3iv(context, angle::EntryPoint::GLSecondaryColor3iv, v)));
8636 if (isCallValid)
8637 {
8638 context->secondaryColor3iv(v);
8639 }
8640 ANGLE_CAPTURE_GL(SecondaryColor3iv, isCallValid, context, v);
8641 }
8642 else
8643 {
8644 GenerateContextLostErrorOnCurrentGlobalContext();
8645 }
8646 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8647 }
8648
GL_SecondaryColor3s(GLshort red,GLshort green,GLshort blue)8649 void GL_APIENTRY GL_SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
8650 {
8651 Context *context = GetValidGlobalContext();
8652 EVENT(context, GLSecondaryColor3s, "context = %d, red = %d, green = %d, blue = %d",
8653 CID(context), red, green, blue);
8654
8655 if (context)
8656 {
8657 SCOPED_SHARE_CONTEXT_LOCK(context);
8658 bool isCallValid =
8659 (context->skipValidation() ||
8660 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8661 context->getMutableErrorSetForValidation(),
8662 angle::EntryPoint::GLSecondaryColor3s) &&
8663 ValidateSecondaryColor3s(context, angle::EntryPoint::GLSecondaryColor3s, red, green,
8664 blue)));
8665 if (isCallValid)
8666 {
8667 context->secondaryColor3s(red, green, blue);
8668 }
8669 ANGLE_CAPTURE_GL(SecondaryColor3s, isCallValid, context, red, green, blue);
8670 }
8671 else
8672 {
8673 GenerateContextLostErrorOnCurrentGlobalContext();
8674 }
8675 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8676 }
8677
GL_SecondaryColor3sv(const GLshort * v)8678 void GL_APIENTRY GL_SecondaryColor3sv(const GLshort *v)
8679 {
8680 Context *context = GetValidGlobalContext();
8681 EVENT(context, GLSecondaryColor3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8682 (uintptr_t)v);
8683
8684 if (context)
8685 {
8686 SCOPED_SHARE_CONTEXT_LOCK(context);
8687 bool isCallValid =
8688 (context->skipValidation() ||
8689 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8690 context->getMutableErrorSetForValidation(),
8691 angle::EntryPoint::GLSecondaryColor3sv) &&
8692 ValidateSecondaryColor3sv(context, angle::EntryPoint::GLSecondaryColor3sv, v)));
8693 if (isCallValid)
8694 {
8695 context->secondaryColor3sv(v);
8696 }
8697 ANGLE_CAPTURE_GL(SecondaryColor3sv, isCallValid, context, v);
8698 }
8699 else
8700 {
8701 GenerateContextLostErrorOnCurrentGlobalContext();
8702 }
8703 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8704 }
8705
GL_SecondaryColor3ub(GLubyte red,GLubyte green,GLubyte blue)8706 void GL_APIENTRY GL_SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
8707 {
8708 Context *context = GetValidGlobalContext();
8709 EVENT(context, GLSecondaryColor3ub, "context = %d, red = %d, green = %d, blue = %d",
8710 CID(context), red, green, blue);
8711
8712 if (context)
8713 {
8714 SCOPED_SHARE_CONTEXT_LOCK(context);
8715 bool isCallValid =
8716 (context->skipValidation() ||
8717 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8718 context->getMutableErrorSetForValidation(),
8719 angle::EntryPoint::GLSecondaryColor3ub) &&
8720 ValidateSecondaryColor3ub(context, angle::EntryPoint::GLSecondaryColor3ub, red, green,
8721 blue)));
8722 if (isCallValid)
8723 {
8724 context->secondaryColor3ub(red, green, blue);
8725 }
8726 ANGLE_CAPTURE_GL(SecondaryColor3ub, isCallValid, context, red, green, blue);
8727 }
8728 else
8729 {
8730 GenerateContextLostErrorOnCurrentGlobalContext();
8731 }
8732 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8733 }
8734
GL_SecondaryColor3ubv(const GLubyte * v)8735 void GL_APIENTRY GL_SecondaryColor3ubv(const GLubyte *v)
8736 {
8737 Context *context = GetValidGlobalContext();
8738 EVENT(context, GLSecondaryColor3ubv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8739 (uintptr_t)v);
8740
8741 if (context)
8742 {
8743 SCOPED_SHARE_CONTEXT_LOCK(context);
8744 bool isCallValid =
8745 (context->skipValidation() ||
8746 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8747 context->getMutableErrorSetForValidation(),
8748 angle::EntryPoint::GLSecondaryColor3ubv) &&
8749 ValidateSecondaryColor3ubv(context, angle::EntryPoint::GLSecondaryColor3ubv, v)));
8750 if (isCallValid)
8751 {
8752 context->secondaryColor3ubv(v);
8753 }
8754 ANGLE_CAPTURE_GL(SecondaryColor3ubv, isCallValid, context, v);
8755 }
8756 else
8757 {
8758 GenerateContextLostErrorOnCurrentGlobalContext();
8759 }
8760 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8761 }
8762
GL_SecondaryColor3ui(GLuint red,GLuint green,GLuint blue)8763 void GL_APIENTRY GL_SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
8764 {
8765 Context *context = GetValidGlobalContext();
8766 EVENT(context, GLSecondaryColor3ui, "context = %d, red = %u, green = %u, blue = %u",
8767 CID(context), red, green, blue);
8768
8769 if (context)
8770 {
8771 SCOPED_SHARE_CONTEXT_LOCK(context);
8772 bool isCallValid =
8773 (context->skipValidation() ||
8774 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8775 context->getMutableErrorSetForValidation(),
8776 angle::EntryPoint::GLSecondaryColor3ui) &&
8777 ValidateSecondaryColor3ui(context, angle::EntryPoint::GLSecondaryColor3ui, red, green,
8778 blue)));
8779 if (isCallValid)
8780 {
8781 context->secondaryColor3ui(red, green, blue);
8782 }
8783 ANGLE_CAPTURE_GL(SecondaryColor3ui, isCallValid, context, red, green, blue);
8784 }
8785 else
8786 {
8787 GenerateContextLostErrorOnCurrentGlobalContext();
8788 }
8789 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8790 }
8791
GL_SecondaryColor3uiv(const GLuint * v)8792 void GL_APIENTRY GL_SecondaryColor3uiv(const GLuint *v)
8793 {
8794 Context *context = GetValidGlobalContext();
8795 EVENT(context, GLSecondaryColor3uiv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8796 (uintptr_t)v);
8797
8798 if (context)
8799 {
8800 SCOPED_SHARE_CONTEXT_LOCK(context);
8801 bool isCallValid =
8802 (context->skipValidation() ||
8803 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8804 context->getMutableErrorSetForValidation(),
8805 angle::EntryPoint::GLSecondaryColor3uiv) &&
8806 ValidateSecondaryColor3uiv(context, angle::EntryPoint::GLSecondaryColor3uiv, v)));
8807 if (isCallValid)
8808 {
8809 context->secondaryColor3uiv(v);
8810 }
8811 ANGLE_CAPTURE_GL(SecondaryColor3uiv, isCallValid, context, v);
8812 }
8813 else
8814 {
8815 GenerateContextLostErrorOnCurrentGlobalContext();
8816 }
8817 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8818 }
8819
GL_SecondaryColor3us(GLushort red,GLushort green,GLushort blue)8820 void GL_APIENTRY GL_SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
8821 {
8822 Context *context = GetValidGlobalContext();
8823 EVENT(context, GLSecondaryColor3us, "context = %d, red = %u, green = %u, blue = %u",
8824 CID(context), red, green, blue);
8825
8826 if (context)
8827 {
8828 SCOPED_SHARE_CONTEXT_LOCK(context);
8829 bool isCallValid =
8830 (context->skipValidation() ||
8831 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8832 context->getMutableErrorSetForValidation(),
8833 angle::EntryPoint::GLSecondaryColor3us) &&
8834 ValidateSecondaryColor3us(context, angle::EntryPoint::GLSecondaryColor3us, red, green,
8835 blue)));
8836 if (isCallValid)
8837 {
8838 context->secondaryColor3us(red, green, blue);
8839 }
8840 ANGLE_CAPTURE_GL(SecondaryColor3us, isCallValid, context, red, green, blue);
8841 }
8842 else
8843 {
8844 GenerateContextLostErrorOnCurrentGlobalContext();
8845 }
8846 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8847 }
8848
GL_SecondaryColor3usv(const GLushort * v)8849 void GL_APIENTRY GL_SecondaryColor3usv(const GLushort *v)
8850 {
8851 Context *context = GetValidGlobalContext();
8852 EVENT(context, GLSecondaryColor3usv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8853 (uintptr_t)v);
8854
8855 if (context)
8856 {
8857 SCOPED_SHARE_CONTEXT_LOCK(context);
8858 bool isCallValid =
8859 (context->skipValidation() ||
8860 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8861 context->getMutableErrorSetForValidation(),
8862 angle::EntryPoint::GLSecondaryColor3usv) &&
8863 ValidateSecondaryColor3usv(context, angle::EntryPoint::GLSecondaryColor3usv, v)));
8864 if (isCallValid)
8865 {
8866 context->secondaryColor3usv(v);
8867 }
8868 ANGLE_CAPTURE_GL(SecondaryColor3usv, isCallValid, context, v);
8869 }
8870 else
8871 {
8872 GenerateContextLostErrorOnCurrentGlobalContext();
8873 }
8874 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8875 }
8876
GL_SecondaryColorPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)8877 void GL_APIENTRY GL_SecondaryColorPointer(GLint size,
8878 GLenum type,
8879 GLsizei stride,
8880 const void *pointer)
8881 {
8882 Context *context = GetValidGlobalContext();
8883 EVENT(context, GLSecondaryColorPointer,
8884 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
8885 CID(context), size, GLenumToString(BigGLEnum::ColorPointerType, type), stride,
8886 (uintptr_t)pointer);
8887
8888 if (context)
8889 {
8890 SCOPED_SHARE_CONTEXT_LOCK(context);
8891 bool isCallValid =
8892 (context->skipValidation() ||
8893 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8894 context->getMutableErrorSetForValidation(),
8895 angle::EntryPoint::GLSecondaryColorPointer) &&
8896 ValidateSecondaryColorPointer(context, angle::EntryPoint::GLSecondaryColorPointer,
8897 size, type, stride, pointer)));
8898 if (isCallValid)
8899 {
8900 context->secondaryColorPointer(size, type, stride, pointer);
8901 }
8902 ANGLE_CAPTURE_GL(SecondaryColorPointer, isCallValid, context, size, type, stride, pointer);
8903 }
8904 else
8905 {
8906 GenerateContextLostErrorOnCurrentGlobalContext();
8907 }
8908 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8909 }
8910
GL_WindowPos2d(GLdouble x,GLdouble y)8911 void GL_APIENTRY GL_WindowPos2d(GLdouble x, GLdouble y)
8912 {
8913 Context *context = GetValidGlobalContext();
8914 EVENT(context, GLWindowPos2d, "context = %d, x = %f, y = %f", CID(context), x, y);
8915
8916 if (context)
8917 {
8918 SCOPED_SHARE_CONTEXT_LOCK(context);
8919 bool isCallValid =
8920 (context->skipValidation() ||
8921 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8922 context->getMutableErrorSetForValidation(),
8923 angle::EntryPoint::GLWindowPos2d) &&
8924 ValidateWindowPos2d(context, angle::EntryPoint::GLWindowPos2d, x, y)));
8925 if (isCallValid)
8926 {
8927 context->windowPos2d(x, y);
8928 }
8929 ANGLE_CAPTURE_GL(WindowPos2d, isCallValid, context, x, y);
8930 }
8931 else
8932 {
8933 GenerateContextLostErrorOnCurrentGlobalContext();
8934 }
8935 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8936 }
8937
GL_WindowPos2dv(const GLdouble * v)8938 void GL_APIENTRY GL_WindowPos2dv(const GLdouble *v)
8939 {
8940 Context *context = GetValidGlobalContext();
8941 EVENT(context, GLWindowPos2dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8942 (uintptr_t)v);
8943
8944 if (context)
8945 {
8946 SCOPED_SHARE_CONTEXT_LOCK(context);
8947 bool isCallValid =
8948 (context->skipValidation() ||
8949 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8950 context->getMutableErrorSetForValidation(),
8951 angle::EntryPoint::GLWindowPos2dv) &&
8952 ValidateWindowPos2dv(context, angle::EntryPoint::GLWindowPos2dv, v)));
8953 if (isCallValid)
8954 {
8955 context->windowPos2dv(v);
8956 }
8957 ANGLE_CAPTURE_GL(WindowPos2dv, isCallValid, context, v);
8958 }
8959 else
8960 {
8961 GenerateContextLostErrorOnCurrentGlobalContext();
8962 }
8963 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8964 }
8965
GL_WindowPos2f(GLfloat x,GLfloat y)8966 void GL_APIENTRY GL_WindowPos2f(GLfloat x, GLfloat y)
8967 {
8968 Context *context = GetValidGlobalContext();
8969 EVENT(context, GLWindowPos2f, "context = %d, x = %f, y = %f", CID(context), x, y);
8970
8971 if (context)
8972 {
8973 SCOPED_SHARE_CONTEXT_LOCK(context);
8974 bool isCallValid =
8975 (context->skipValidation() ||
8976 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8977 context->getMutableErrorSetForValidation(),
8978 angle::EntryPoint::GLWindowPos2f) &&
8979 ValidateWindowPos2f(context, angle::EntryPoint::GLWindowPos2f, x, y)));
8980 if (isCallValid)
8981 {
8982 context->windowPos2f(x, y);
8983 }
8984 ANGLE_CAPTURE_GL(WindowPos2f, isCallValid, context, x, y);
8985 }
8986 else
8987 {
8988 GenerateContextLostErrorOnCurrentGlobalContext();
8989 }
8990 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8991 }
8992
GL_WindowPos2fv(const GLfloat * v)8993 void GL_APIENTRY GL_WindowPos2fv(const GLfloat *v)
8994 {
8995 Context *context = GetValidGlobalContext();
8996 EVENT(context, GLWindowPos2fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
8997 (uintptr_t)v);
8998
8999 if (context)
9000 {
9001 SCOPED_SHARE_CONTEXT_LOCK(context);
9002 bool isCallValid =
9003 (context->skipValidation() ||
9004 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9005 context->getMutableErrorSetForValidation(),
9006 angle::EntryPoint::GLWindowPos2fv) &&
9007 ValidateWindowPos2fv(context, angle::EntryPoint::GLWindowPos2fv, v)));
9008 if (isCallValid)
9009 {
9010 context->windowPos2fv(v);
9011 }
9012 ANGLE_CAPTURE_GL(WindowPos2fv, isCallValid, context, v);
9013 }
9014 else
9015 {
9016 GenerateContextLostErrorOnCurrentGlobalContext();
9017 }
9018 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9019 }
9020
GL_WindowPos2i(GLint x,GLint y)9021 void GL_APIENTRY GL_WindowPos2i(GLint x, GLint y)
9022 {
9023 Context *context = GetValidGlobalContext();
9024 EVENT(context, GLWindowPos2i, "context = %d, x = %d, y = %d", CID(context), x, y);
9025
9026 if (context)
9027 {
9028 SCOPED_SHARE_CONTEXT_LOCK(context);
9029 bool isCallValid =
9030 (context->skipValidation() ||
9031 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9032 context->getMutableErrorSetForValidation(),
9033 angle::EntryPoint::GLWindowPos2i) &&
9034 ValidateWindowPos2i(context, angle::EntryPoint::GLWindowPos2i, x, y)));
9035 if (isCallValid)
9036 {
9037 context->windowPos2i(x, y);
9038 }
9039 ANGLE_CAPTURE_GL(WindowPos2i, isCallValid, context, x, y);
9040 }
9041 else
9042 {
9043 GenerateContextLostErrorOnCurrentGlobalContext();
9044 }
9045 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9046 }
9047
GL_WindowPos2iv(const GLint * v)9048 void GL_APIENTRY GL_WindowPos2iv(const GLint *v)
9049 {
9050 Context *context = GetValidGlobalContext();
9051 EVENT(context, GLWindowPos2iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
9052 (uintptr_t)v);
9053
9054 if (context)
9055 {
9056 SCOPED_SHARE_CONTEXT_LOCK(context);
9057 bool isCallValid =
9058 (context->skipValidation() ||
9059 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9060 context->getMutableErrorSetForValidation(),
9061 angle::EntryPoint::GLWindowPos2iv) &&
9062 ValidateWindowPos2iv(context, angle::EntryPoint::GLWindowPos2iv, v)));
9063 if (isCallValid)
9064 {
9065 context->windowPos2iv(v);
9066 }
9067 ANGLE_CAPTURE_GL(WindowPos2iv, isCallValid, context, v);
9068 }
9069 else
9070 {
9071 GenerateContextLostErrorOnCurrentGlobalContext();
9072 }
9073 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9074 }
9075
GL_WindowPos2s(GLshort x,GLshort y)9076 void GL_APIENTRY GL_WindowPos2s(GLshort x, GLshort y)
9077 {
9078 Context *context = GetValidGlobalContext();
9079 EVENT(context, GLWindowPos2s, "context = %d, x = %d, y = %d", CID(context), x, y);
9080
9081 if (context)
9082 {
9083 SCOPED_SHARE_CONTEXT_LOCK(context);
9084 bool isCallValid =
9085 (context->skipValidation() ||
9086 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9087 context->getMutableErrorSetForValidation(),
9088 angle::EntryPoint::GLWindowPos2s) &&
9089 ValidateWindowPos2s(context, angle::EntryPoint::GLWindowPos2s, x, y)));
9090 if (isCallValid)
9091 {
9092 context->windowPos2s(x, y);
9093 }
9094 ANGLE_CAPTURE_GL(WindowPos2s, isCallValid, context, x, y);
9095 }
9096 else
9097 {
9098 GenerateContextLostErrorOnCurrentGlobalContext();
9099 }
9100 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9101 }
9102
GL_WindowPos2sv(const GLshort * v)9103 void GL_APIENTRY GL_WindowPos2sv(const GLshort *v)
9104 {
9105 Context *context = GetValidGlobalContext();
9106 EVENT(context, GLWindowPos2sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
9107 (uintptr_t)v);
9108
9109 if (context)
9110 {
9111 SCOPED_SHARE_CONTEXT_LOCK(context);
9112 bool isCallValid =
9113 (context->skipValidation() ||
9114 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9115 context->getMutableErrorSetForValidation(),
9116 angle::EntryPoint::GLWindowPos2sv) &&
9117 ValidateWindowPos2sv(context, angle::EntryPoint::GLWindowPos2sv, v)));
9118 if (isCallValid)
9119 {
9120 context->windowPos2sv(v);
9121 }
9122 ANGLE_CAPTURE_GL(WindowPos2sv, isCallValid, context, v);
9123 }
9124 else
9125 {
9126 GenerateContextLostErrorOnCurrentGlobalContext();
9127 }
9128 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9129 }
9130
GL_WindowPos3d(GLdouble x,GLdouble y,GLdouble z)9131 void GL_APIENTRY GL_WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
9132 {
9133 Context *context = GetValidGlobalContext();
9134 EVENT(context, GLWindowPos3d, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
9135
9136 if (context)
9137 {
9138 SCOPED_SHARE_CONTEXT_LOCK(context);
9139 bool isCallValid =
9140 (context->skipValidation() ||
9141 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9142 context->getMutableErrorSetForValidation(),
9143 angle::EntryPoint::GLWindowPos3d) &&
9144 ValidateWindowPos3d(context, angle::EntryPoint::GLWindowPos3d, x, y, z)));
9145 if (isCallValid)
9146 {
9147 context->windowPos3d(x, y, z);
9148 }
9149 ANGLE_CAPTURE_GL(WindowPos3d, isCallValid, context, x, y, z);
9150 }
9151 else
9152 {
9153 GenerateContextLostErrorOnCurrentGlobalContext();
9154 }
9155 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9156 }
9157
GL_WindowPos3dv(const GLdouble * v)9158 void GL_APIENTRY GL_WindowPos3dv(const GLdouble *v)
9159 {
9160 Context *context = GetValidGlobalContext();
9161 EVENT(context, GLWindowPos3dv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
9162 (uintptr_t)v);
9163
9164 if (context)
9165 {
9166 SCOPED_SHARE_CONTEXT_LOCK(context);
9167 bool isCallValid =
9168 (context->skipValidation() ||
9169 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9170 context->getMutableErrorSetForValidation(),
9171 angle::EntryPoint::GLWindowPos3dv) &&
9172 ValidateWindowPos3dv(context, angle::EntryPoint::GLWindowPos3dv, v)));
9173 if (isCallValid)
9174 {
9175 context->windowPos3dv(v);
9176 }
9177 ANGLE_CAPTURE_GL(WindowPos3dv, isCallValid, context, v);
9178 }
9179 else
9180 {
9181 GenerateContextLostErrorOnCurrentGlobalContext();
9182 }
9183 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9184 }
9185
GL_WindowPos3f(GLfloat x,GLfloat y,GLfloat z)9186 void GL_APIENTRY GL_WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
9187 {
9188 Context *context = GetValidGlobalContext();
9189 EVENT(context, GLWindowPos3f, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
9190
9191 if (context)
9192 {
9193 SCOPED_SHARE_CONTEXT_LOCK(context);
9194 bool isCallValid =
9195 (context->skipValidation() ||
9196 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9197 context->getMutableErrorSetForValidation(),
9198 angle::EntryPoint::GLWindowPos3f) &&
9199 ValidateWindowPos3f(context, angle::EntryPoint::GLWindowPos3f, x, y, z)));
9200 if (isCallValid)
9201 {
9202 context->windowPos3f(x, y, z);
9203 }
9204 ANGLE_CAPTURE_GL(WindowPos3f, isCallValid, context, x, y, z);
9205 }
9206 else
9207 {
9208 GenerateContextLostErrorOnCurrentGlobalContext();
9209 }
9210 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9211 }
9212
GL_WindowPos3fv(const GLfloat * v)9213 void GL_APIENTRY GL_WindowPos3fv(const GLfloat *v)
9214 {
9215 Context *context = GetValidGlobalContext();
9216 EVENT(context, GLWindowPos3fv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
9217 (uintptr_t)v);
9218
9219 if (context)
9220 {
9221 SCOPED_SHARE_CONTEXT_LOCK(context);
9222 bool isCallValid =
9223 (context->skipValidation() ||
9224 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9225 context->getMutableErrorSetForValidation(),
9226 angle::EntryPoint::GLWindowPos3fv) &&
9227 ValidateWindowPos3fv(context, angle::EntryPoint::GLWindowPos3fv, v)));
9228 if (isCallValid)
9229 {
9230 context->windowPos3fv(v);
9231 }
9232 ANGLE_CAPTURE_GL(WindowPos3fv, isCallValid, context, v);
9233 }
9234 else
9235 {
9236 GenerateContextLostErrorOnCurrentGlobalContext();
9237 }
9238 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9239 }
9240
GL_WindowPos3i(GLint x,GLint y,GLint z)9241 void GL_APIENTRY GL_WindowPos3i(GLint x, GLint y, GLint z)
9242 {
9243 Context *context = GetValidGlobalContext();
9244 EVENT(context, GLWindowPos3i, "context = %d, x = %d, y = %d, z = %d", CID(context), x, y, z);
9245
9246 if (context)
9247 {
9248 SCOPED_SHARE_CONTEXT_LOCK(context);
9249 bool isCallValid =
9250 (context->skipValidation() ||
9251 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9252 context->getMutableErrorSetForValidation(),
9253 angle::EntryPoint::GLWindowPos3i) &&
9254 ValidateWindowPos3i(context, angle::EntryPoint::GLWindowPos3i, x, y, z)));
9255 if (isCallValid)
9256 {
9257 context->windowPos3i(x, y, z);
9258 }
9259 ANGLE_CAPTURE_GL(WindowPos3i, isCallValid, context, x, y, z);
9260 }
9261 else
9262 {
9263 GenerateContextLostErrorOnCurrentGlobalContext();
9264 }
9265 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9266 }
9267
GL_WindowPos3iv(const GLint * v)9268 void GL_APIENTRY GL_WindowPos3iv(const GLint *v)
9269 {
9270 Context *context = GetValidGlobalContext();
9271 EVENT(context, GLWindowPos3iv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
9272 (uintptr_t)v);
9273
9274 if (context)
9275 {
9276 SCOPED_SHARE_CONTEXT_LOCK(context);
9277 bool isCallValid =
9278 (context->skipValidation() ||
9279 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9280 context->getMutableErrorSetForValidation(),
9281 angle::EntryPoint::GLWindowPos3iv) &&
9282 ValidateWindowPos3iv(context, angle::EntryPoint::GLWindowPos3iv, v)));
9283 if (isCallValid)
9284 {
9285 context->windowPos3iv(v);
9286 }
9287 ANGLE_CAPTURE_GL(WindowPos3iv, isCallValid, context, v);
9288 }
9289 else
9290 {
9291 GenerateContextLostErrorOnCurrentGlobalContext();
9292 }
9293 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9294 }
9295
GL_WindowPos3s(GLshort x,GLshort y,GLshort z)9296 void GL_APIENTRY GL_WindowPos3s(GLshort x, GLshort y, GLshort z)
9297 {
9298 Context *context = GetValidGlobalContext();
9299 EVENT(context, GLWindowPos3s, "context = %d, x = %d, y = %d, z = %d", CID(context), x, y, z);
9300
9301 if (context)
9302 {
9303 SCOPED_SHARE_CONTEXT_LOCK(context);
9304 bool isCallValid =
9305 (context->skipValidation() ||
9306 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9307 context->getMutableErrorSetForValidation(),
9308 angle::EntryPoint::GLWindowPos3s) &&
9309 ValidateWindowPos3s(context, angle::EntryPoint::GLWindowPos3s, x, y, z)));
9310 if (isCallValid)
9311 {
9312 context->windowPos3s(x, y, z);
9313 }
9314 ANGLE_CAPTURE_GL(WindowPos3s, isCallValid, context, x, y, z);
9315 }
9316 else
9317 {
9318 GenerateContextLostErrorOnCurrentGlobalContext();
9319 }
9320 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9321 }
9322
GL_WindowPos3sv(const GLshort * v)9323 void GL_APIENTRY GL_WindowPos3sv(const GLshort *v)
9324 {
9325 Context *context = GetValidGlobalContext();
9326 EVENT(context, GLWindowPos3sv, "context = %d, v = 0x%016" PRIxPTR "", CID(context),
9327 (uintptr_t)v);
9328
9329 if (context)
9330 {
9331 SCOPED_SHARE_CONTEXT_LOCK(context);
9332 bool isCallValid =
9333 (context->skipValidation() ||
9334 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9335 context->getMutableErrorSetForValidation(),
9336 angle::EntryPoint::GLWindowPos3sv) &&
9337 ValidateWindowPos3sv(context, angle::EntryPoint::GLWindowPos3sv, v)));
9338 if (isCallValid)
9339 {
9340 context->windowPos3sv(v);
9341 }
9342 ANGLE_CAPTURE_GL(WindowPos3sv, isCallValid, context, v);
9343 }
9344 else
9345 {
9346 GenerateContextLostErrorOnCurrentGlobalContext();
9347 }
9348 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9349 }
9350
9351 // GL 1.5
GL_GetBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,void * data)9352 void GL_APIENTRY GL_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
9353 {
9354 Context *context = GetValidGlobalContext();
9355 EVENT(context, GLGetBufferSubData,
9356 "context = %d, target = %s, offset = %llu, size = %llu, data = 0x%016" PRIxPTR "",
9357 CID(context), GLenumToString(BigGLEnum::BufferTargetARB, target),
9358 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
9359 (uintptr_t)data);
9360
9361 if (context)
9362 {
9363 SCOPED_SHARE_CONTEXT_LOCK(context);
9364 bool isCallValid = (context->skipValidation() ||
9365 ValidateGetBufferSubData(context, angle::EntryPoint::GLGetBufferSubData,
9366 target, offset, size, data));
9367 if (isCallValid)
9368 {
9369 context->getBufferSubData(target, offset, size, data);
9370 }
9371 ANGLE_CAPTURE_GL(GetBufferSubData, isCallValid, context, target, offset, size, data);
9372 }
9373 else
9374 {
9375 GenerateContextLostErrorOnCurrentGlobalContext();
9376 }
9377 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9378 }
9379
GL_GetQueryObjectiv(GLuint id,GLenum pname,GLint * params)9380 void GL_APIENTRY GL_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
9381 {
9382 Context *context = GetGlobalContext();
9383 EVENT(context, GLGetQueryObjectiv,
9384 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
9385 GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params);
9386
9387 if (context)
9388 {
9389 QueryID idPacked = PackParam<QueryID>(id);
9390 SCOPED_SHARE_CONTEXT_LOCK(context);
9391 bool isCallValid = (context->skipValidation() ||
9392 ValidateGetQueryObjectiv(context, angle::EntryPoint::GLGetQueryObjectiv,
9393 idPacked, pname, params));
9394 if (isCallValid)
9395 {
9396 context->getQueryObjectiv(idPacked, pname, params);
9397 }
9398 ANGLE_CAPTURE_GL(GetQueryObjectiv, isCallValid, context, idPacked, pname, params);
9399 }
9400 else
9401 {
9402 }
9403 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9404 }
9405
GL_MapBuffer(GLenum target,GLenum access)9406 void *GL_APIENTRY GL_MapBuffer(GLenum target, GLenum access)
9407 {
9408 Context *context = GetValidGlobalContext();
9409 EVENT(context, GLMapBuffer, "context = %d, target = %s, access = %s", CID(context),
9410 GLenumToString(BigGLEnum::BufferTargetARB, target),
9411 GLenumToString(BigGLEnum::BufferAccessARB, access));
9412
9413 void *returnValue;
9414 if (context)
9415 {
9416 BufferBinding targetPacked = PackParam<BufferBinding>(target);
9417 SCOPED_SHARE_CONTEXT_LOCK(context);
9418 bool isCallValid =
9419 (context->skipValidation() ||
9420 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9421 context->getMutableErrorSetForValidation(),
9422 angle::EntryPoint::GLMapBuffer) &&
9423 ValidateMapBuffer(context, angle::EntryPoint::GLMapBuffer, targetPacked, access)));
9424 if (isCallValid)
9425 {
9426 returnValue = context->mapBuffer(targetPacked, access);
9427 }
9428 else
9429 {
9430 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBuffer, void *>();
9431 }
9432 ANGLE_CAPTURE_GL(MapBuffer, isCallValid, context, targetPacked, access, returnValue);
9433 }
9434 else
9435 {
9436 GenerateContextLostErrorOnCurrentGlobalContext();
9437 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBuffer, void *>();
9438 }
9439 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9440 return returnValue;
9441 }
9442
9443 } // extern "C"
9444