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_gles_1_0_autogen.cpp:
9 // Defines the GLES 1.0 entry points.
10
11 #include "libGLESv2/entry_points_gles_1_0_autogen.h"
12
13 #include "common/entry_points_enum_autogen.h"
14 #include "common/gl_enum_utils.h"
15 #include "libANGLE/Context.h"
16 #include "libANGLE/Context.inl.h"
17 #include "libANGLE/capture/capture_gles_1_0_autogen.h"
18 #include "libANGLE/context_private_call_autogen.h"
19 #include "libANGLE/entry_points_utils.h"
20 #include "libANGLE/validationES1.h"
21 #include "libGLESv2/global_state.h"
22
23 using namespace gl;
24
25 extern "C" {
GL_AlphaFunc(GLenum func,GLfloat ref)26 void GL_APIENTRY GL_AlphaFunc(GLenum func, GLfloat ref)
27 {
28 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
29 Context *context = GetValidGlobalContext();
30 EVENT(context, GLAlphaFunc, "context = %d, func = %s, ref = %f", CID(context),
31 GLenumToString(GLESEnum::AlphaFunction, func), ref);
32
33 if (context)
34 {
35 AlphaTestFunc funcPacked = PackParam<AlphaTestFunc>(func);
36 bool isCallValid = (context->skipValidation() ||
37 ValidateAlphaFunc(context->getPrivateState(),
38 context->getMutableErrorSetForValidation(),
39 angle::EntryPoint::GLAlphaFunc, funcPacked, ref));
40 if (isCallValid)
41 {
42 ContextPrivateAlphaFunc(context->getMutablePrivateState(),
43 context->getMutablePrivateStateCache(), funcPacked, ref);
44 }
45 ANGLE_CAPTURE_GL(AlphaFunc, isCallValid, context, funcPacked, ref);
46 }
47 else
48 {
49 GenerateContextLostErrorOnCurrentGlobalContext();
50 }
51 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
52 }
53
GL_AlphaFuncx(GLenum func,GLfixed ref)54 void GL_APIENTRY GL_AlphaFuncx(GLenum func, GLfixed ref)
55 {
56 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
57 Context *context = GetValidGlobalContext();
58 EVENT(context, GLAlphaFuncx, "context = %d, func = %s, ref = 0x%X", CID(context),
59 GLenumToString(GLESEnum::AlphaFunction, func), ref);
60
61 if (context)
62 {
63 AlphaTestFunc funcPacked = PackParam<AlphaTestFunc>(func);
64 bool isCallValid = (context->skipValidation() ||
65 ValidateAlphaFuncx(context->getPrivateState(),
66 context->getMutableErrorSetForValidation(),
67 angle::EntryPoint::GLAlphaFuncx, funcPacked, ref));
68 if (isCallValid)
69 {
70 ContextPrivateAlphaFuncx(context->getMutablePrivateState(),
71 context->getMutablePrivateStateCache(), funcPacked, ref);
72 }
73 ANGLE_CAPTURE_GL(AlphaFuncx, isCallValid, context, funcPacked, ref);
74 }
75 else
76 {
77 GenerateContextLostErrorOnCurrentGlobalContext();
78 }
79 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
80 }
81
GL_ClearColorx(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)82 void GL_APIENTRY GL_ClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
83 {
84 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
85 Context *context = GetValidGlobalContext();
86 EVENT(context, GLClearColorx,
87 "context = %d, red = 0x%X, green = 0x%X, blue = 0x%X, alpha = 0x%X", CID(context), red,
88 green, blue, alpha);
89
90 if (context)
91 {
92 bool isCallValid =
93 (context->skipValidation() ||
94 ValidateClearColorx(context->getPrivateState(),
95 context->getMutableErrorSetForValidation(),
96 angle::EntryPoint::GLClearColorx, red, green, blue, alpha));
97 if (isCallValid)
98 {
99 ContextPrivateClearColorx(context->getMutablePrivateState(),
100 context->getMutablePrivateStateCache(), red, green, blue,
101 alpha);
102 }
103 ANGLE_CAPTURE_GL(ClearColorx, isCallValid, context, red, green, blue, alpha);
104 }
105 else
106 {
107 GenerateContextLostErrorOnCurrentGlobalContext();
108 }
109 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
110 }
111
GL_ClearDepthx(GLfixed depth)112 void GL_APIENTRY GL_ClearDepthx(GLfixed depth)
113 {
114 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
115 Context *context = GetValidGlobalContext();
116 EVENT(context, GLClearDepthx, "context = %d, depth = 0x%X", CID(context), depth);
117
118 if (context)
119 {
120 bool isCallValid = (context->skipValidation() ||
121 ValidateClearDepthx(context->getPrivateState(),
122 context->getMutableErrorSetForValidation(),
123 angle::EntryPoint::GLClearDepthx, depth));
124 if (isCallValid)
125 {
126 ContextPrivateClearDepthx(context->getMutablePrivateState(),
127 context->getMutablePrivateStateCache(), depth);
128 }
129 ANGLE_CAPTURE_GL(ClearDepthx, isCallValid, context, depth);
130 }
131 else
132 {
133 GenerateContextLostErrorOnCurrentGlobalContext();
134 }
135 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
136 }
137
GL_ClientActiveTexture(GLenum texture)138 void GL_APIENTRY GL_ClientActiveTexture(GLenum texture)
139 {
140 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
141 Context *context = GetValidGlobalContext();
142 EVENT(context, GLClientActiveTexture, "context = %d, texture = %s", CID(context),
143 GLenumToString(GLESEnum::TextureUnit, texture));
144
145 if (context)
146 {
147 SCOPED_SHARE_CONTEXT_LOCK(context);
148 bool isCallValid = (context->skipValidation() ||
149 ValidateClientActiveTexture(
150 context, angle::EntryPoint::GLClientActiveTexture, texture));
151 if (isCallValid)
152 {
153 context->clientActiveTexture(texture);
154 }
155 ANGLE_CAPTURE_GL(ClientActiveTexture, isCallValid, context, texture);
156 }
157 else
158 {
159 GenerateContextLostErrorOnCurrentGlobalContext();
160 }
161 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
162 }
163
GL_ClipPlanef(GLenum p,const GLfloat * eqn)164 void GL_APIENTRY GL_ClipPlanef(GLenum p, const GLfloat *eqn)
165 {
166 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
167 Context *context = GetValidGlobalContext();
168 EVENT(context, GLClipPlanef, "context = %d, p = %s, eqn = 0x%016" PRIxPTR "", CID(context),
169 GLenumToString(GLESEnum::ClipPlaneName, p), (uintptr_t)eqn);
170
171 if (context)
172 {
173 bool isCallValid = (context->skipValidation() ||
174 ValidateClipPlanef(context->getPrivateState(),
175 context->getMutableErrorSetForValidation(),
176 angle::EntryPoint::GLClipPlanef, p, eqn));
177 if (isCallValid)
178 {
179 ContextPrivateClipPlanef(context->getMutablePrivateState(),
180 context->getMutablePrivateStateCache(), p, eqn);
181 }
182 ANGLE_CAPTURE_GL(ClipPlanef, isCallValid, context, p, eqn);
183 }
184 else
185 {
186 GenerateContextLostErrorOnCurrentGlobalContext();
187 }
188 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
189 }
190
GL_ClipPlanex(GLenum plane,const GLfixed * equation)191 void GL_APIENTRY GL_ClipPlanex(GLenum plane, const GLfixed *equation)
192 {
193 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
194 Context *context = GetValidGlobalContext();
195 EVENT(context, GLClipPlanex, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "",
196 CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation);
197
198 if (context)
199 {
200 bool isCallValid = (context->skipValidation() ||
201 ValidateClipPlanex(context->getPrivateState(),
202 context->getMutableErrorSetForValidation(),
203 angle::EntryPoint::GLClipPlanex, plane, equation));
204 if (isCallValid)
205 {
206 ContextPrivateClipPlanex(context->getMutablePrivateState(),
207 context->getMutablePrivateStateCache(), plane, equation);
208 }
209 ANGLE_CAPTURE_GL(ClipPlanex, isCallValid, context, plane, equation);
210 }
211 else
212 {
213 GenerateContextLostErrorOnCurrentGlobalContext();
214 }
215 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
216 }
217
GL_Color4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)218 void GL_APIENTRY GL_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
219 {
220 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
221 Context *context = GetValidGlobalContext();
222 EVENT(context, GLColor4f, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
223 CID(context), red, green, blue, alpha);
224
225 if (context)
226 {
227 bool isCallValid =
228 (context->skipValidation() ||
229 ValidateColor4f(context->getPrivateState(), context->getMutableErrorSetForValidation(),
230 angle::EntryPoint::GLColor4f, red, green, blue, alpha));
231 if (isCallValid)
232 {
233 ContextPrivateColor4f(context->getMutablePrivateState(),
234 context->getMutablePrivateStateCache(), red, green, blue, alpha);
235 }
236 ANGLE_CAPTURE_GL(Color4f, isCallValid, context, red, green, blue, alpha);
237 }
238 else
239 {
240 GenerateContextLostErrorOnCurrentGlobalContext();
241 }
242 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
243 }
244
GL_Color4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)245 void GL_APIENTRY GL_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
246 {
247 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
248 Context *context = GetValidGlobalContext();
249 EVENT(context, GLColor4ub, "context = %d, red = %d, green = %d, blue = %d, alpha = %d",
250 CID(context), red, green, blue, alpha);
251
252 if (context)
253 {
254 bool isCallValid =
255 (context->skipValidation() ||
256 ValidateColor4ub(context->getPrivateState(),
257 context->getMutableErrorSetForValidation(),
258 angle::EntryPoint::GLColor4ub, red, green, blue, alpha));
259 if (isCallValid)
260 {
261 ContextPrivateColor4ub(context->getMutablePrivateState(),
262 context->getMutablePrivateStateCache(), red, green, blue, alpha);
263 }
264 ANGLE_CAPTURE_GL(Color4ub, isCallValid, context, red, green, blue, alpha);
265 }
266 else
267 {
268 GenerateContextLostErrorOnCurrentGlobalContext();
269 }
270 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
271 }
272
GL_Color4x(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)273 void GL_APIENTRY GL_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
274 {
275 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
276 Context *context = GetValidGlobalContext();
277 EVENT(context, GLColor4x, "context = %d, red = 0x%X, green = 0x%X, blue = 0x%X, alpha = 0x%X",
278 CID(context), red, green, blue, alpha);
279
280 if (context)
281 {
282 bool isCallValid =
283 (context->skipValidation() ||
284 ValidateColor4x(context->getPrivateState(), context->getMutableErrorSetForValidation(),
285 angle::EntryPoint::GLColor4x, red, green, blue, alpha));
286 if (isCallValid)
287 {
288 ContextPrivateColor4x(context->getMutablePrivateState(),
289 context->getMutablePrivateStateCache(), red, green, blue, alpha);
290 }
291 ANGLE_CAPTURE_GL(Color4x, isCallValid, context, red, green, blue, alpha);
292 }
293 else
294 {
295 GenerateContextLostErrorOnCurrentGlobalContext();
296 }
297 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
298 }
299
GL_ColorPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)300 void GL_APIENTRY GL_ColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
301 {
302 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
303 Context *context = GetValidGlobalContext();
304 EVENT(context, GLColorPointer,
305 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
306 CID(context), size, GLenumToString(GLESEnum::ColorPointerType, type), stride,
307 (uintptr_t)pointer);
308
309 if (context)
310 {
311 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
312 SCOPED_SHARE_CONTEXT_LOCK(context);
313 bool isCallValid = (context->skipValidation() ||
314 ValidateColorPointer(context, angle::EntryPoint::GLColorPointer, size,
315 typePacked, stride, pointer));
316 if (isCallValid)
317 {
318 context->colorPointer(size, typePacked, stride, pointer);
319 }
320 ANGLE_CAPTURE_GL(ColorPointer, isCallValid, context, size, typePacked, stride, pointer);
321 }
322 else
323 {
324 GenerateContextLostErrorOnCurrentGlobalContext();
325 }
326 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
327 }
328
GL_DepthRangex(GLfixed n,GLfixed f)329 void GL_APIENTRY GL_DepthRangex(GLfixed n, GLfixed f)
330 {
331 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
332 Context *context = GetValidGlobalContext();
333 EVENT(context, GLDepthRangex, "context = %d, n = 0x%X, f = 0x%X", CID(context), n, f);
334
335 if (context)
336 {
337 bool isCallValid = (context->skipValidation() ||
338 ValidateDepthRangex(context->getPrivateState(),
339 context->getMutableErrorSetForValidation(),
340 angle::EntryPoint::GLDepthRangex, n, f));
341 if (isCallValid)
342 {
343 ContextPrivateDepthRangex(context->getMutablePrivateState(),
344 context->getMutablePrivateStateCache(), n, f);
345 }
346 ANGLE_CAPTURE_GL(DepthRangex, isCallValid, context, n, f);
347 }
348 else
349 {
350 GenerateContextLostErrorOnCurrentGlobalContext();
351 }
352 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
353 }
354
GL_DisableClientState(GLenum array)355 void GL_APIENTRY GL_DisableClientState(GLenum array)
356 {
357 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
358 Context *context = GetValidGlobalContext();
359 EVENT(context, GLDisableClientState, "context = %d, array = %s", CID(context),
360 GLenumToString(GLESEnum::EnableCap, array));
361
362 if (context)
363 {
364 ClientVertexArrayType arrayPacked = PackParam<ClientVertexArrayType>(array);
365 SCOPED_SHARE_CONTEXT_LOCK(context);
366 bool isCallValid = (context->skipValidation() ||
367 ValidateDisableClientState(
368 context, angle::EntryPoint::GLDisableClientState, arrayPacked));
369 if (isCallValid)
370 {
371 context->disableClientState(arrayPacked);
372 }
373 ANGLE_CAPTURE_GL(DisableClientState, isCallValid, context, arrayPacked);
374 }
375 else
376 {
377 GenerateContextLostErrorOnCurrentGlobalContext();
378 }
379 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
380 }
381
GL_EnableClientState(GLenum array)382 void GL_APIENTRY GL_EnableClientState(GLenum array)
383 {
384 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
385 Context *context = GetValidGlobalContext();
386 EVENT(context, GLEnableClientState, "context = %d, array = %s", CID(context),
387 GLenumToString(GLESEnum::EnableCap, array));
388
389 if (context)
390 {
391 ClientVertexArrayType arrayPacked = PackParam<ClientVertexArrayType>(array);
392 SCOPED_SHARE_CONTEXT_LOCK(context);
393 bool isCallValid = (context->skipValidation() ||
394 ValidateEnableClientState(
395 context, angle::EntryPoint::GLEnableClientState, arrayPacked));
396 if (isCallValid)
397 {
398 context->enableClientState(arrayPacked);
399 }
400 ANGLE_CAPTURE_GL(EnableClientState, isCallValid, context, arrayPacked);
401 }
402 else
403 {
404 GenerateContextLostErrorOnCurrentGlobalContext();
405 }
406 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
407 }
408
GL_Fogf(GLenum pname,GLfloat param)409 void GL_APIENTRY GL_Fogf(GLenum pname, GLfloat param)
410 {
411 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
412 Context *context = GetValidGlobalContext();
413 EVENT(context, GLFogf, "context = %d, pname = %s, param = %f", CID(context),
414 GLenumToString(GLESEnum::FogParameter, pname), param);
415
416 if (context)
417 {
418 bool isCallValid =
419 (context->skipValidation() ||
420 ValidateFogf(context->getPrivateState(), context->getMutableErrorSetForValidation(),
421 angle::EntryPoint::GLFogf, pname, param));
422 if (isCallValid)
423 {
424 ContextPrivateFogf(context->getMutablePrivateState(),
425 context->getMutablePrivateStateCache(), pname, param);
426 }
427 ANGLE_CAPTURE_GL(Fogf, isCallValid, context, pname, param);
428 }
429 else
430 {
431 GenerateContextLostErrorOnCurrentGlobalContext();
432 }
433 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
434 }
435
GL_Fogfv(GLenum pname,const GLfloat * params)436 void GL_APIENTRY GL_Fogfv(GLenum pname, const GLfloat *params)
437 {
438 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
439 Context *context = GetValidGlobalContext();
440 EVENT(context, GLFogfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
441 GLenumToString(GLESEnum::FogParameter, pname), (uintptr_t)params);
442
443 if (context)
444 {
445 bool isCallValid =
446 (context->skipValidation() ||
447 ValidateFogfv(context->getPrivateState(), context->getMutableErrorSetForValidation(),
448 angle::EntryPoint::GLFogfv, pname, params));
449 if (isCallValid)
450 {
451 ContextPrivateFogfv(context->getMutablePrivateState(),
452 context->getMutablePrivateStateCache(), pname, params);
453 }
454 ANGLE_CAPTURE_GL(Fogfv, isCallValid, context, pname, params);
455 }
456 else
457 {
458 GenerateContextLostErrorOnCurrentGlobalContext();
459 }
460 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
461 }
462
GL_Fogx(GLenum pname,GLfixed param)463 void GL_APIENTRY GL_Fogx(GLenum pname, GLfixed param)
464 {
465 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
466 Context *context = GetValidGlobalContext();
467 EVENT(context, GLFogx, "context = %d, pname = %s, param = 0x%X", CID(context),
468 GLenumToString(GLESEnum::FogPName, pname), param);
469
470 if (context)
471 {
472 bool isCallValid =
473 (context->skipValidation() ||
474 ValidateFogx(context->getPrivateState(), context->getMutableErrorSetForValidation(),
475 angle::EntryPoint::GLFogx, pname, param));
476 if (isCallValid)
477 {
478 ContextPrivateFogx(context->getMutablePrivateState(),
479 context->getMutablePrivateStateCache(), pname, param);
480 }
481 ANGLE_CAPTURE_GL(Fogx, isCallValid, context, pname, param);
482 }
483 else
484 {
485 GenerateContextLostErrorOnCurrentGlobalContext();
486 }
487 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
488 }
489
GL_Fogxv(GLenum pname,const GLfixed * param)490 void GL_APIENTRY GL_Fogxv(GLenum pname, const GLfixed *param)
491 {
492 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
493 Context *context = GetValidGlobalContext();
494 EVENT(context, GLFogxv, "context = %d, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
495 GLenumToString(GLESEnum::FogPName, pname), (uintptr_t)param);
496
497 if (context)
498 {
499 bool isCallValid =
500 (context->skipValidation() ||
501 ValidateFogxv(context->getPrivateState(), context->getMutableErrorSetForValidation(),
502 angle::EntryPoint::GLFogxv, pname, param));
503 if (isCallValid)
504 {
505 ContextPrivateFogxv(context->getMutablePrivateState(),
506 context->getMutablePrivateStateCache(), pname, param);
507 }
508 ANGLE_CAPTURE_GL(Fogxv, isCallValid, context, pname, param);
509 }
510 else
511 {
512 GenerateContextLostErrorOnCurrentGlobalContext();
513 }
514 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
515 }
516
GL_Frustumf(GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f)517 void GL_APIENTRY GL_Frustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
518 {
519 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
520 Context *context = GetValidGlobalContext();
521 EVENT(context, GLFrustumf, "context = %d, l = %f, r = %f, b = %f, t = %f, n = %f, f = %f",
522 CID(context), l, r, b, t, n, f);
523
524 if (context)
525 {
526 bool isCallValid = (context->skipValidation() ||
527 ValidateFrustumf(context->getPrivateState(),
528 context->getMutableErrorSetForValidation(),
529 angle::EntryPoint::GLFrustumf, l, r, b, t, n, f));
530 if (isCallValid)
531 {
532 ContextPrivateFrustumf(context->getMutablePrivateState(),
533 context->getMutablePrivateStateCache(), l, r, b, t, n, f);
534 }
535 ANGLE_CAPTURE_GL(Frustumf, isCallValid, context, l, r, b, t, n, f);
536 }
537 else
538 {
539 GenerateContextLostErrorOnCurrentGlobalContext();
540 }
541 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
542 }
543
GL_Frustumx(GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f)544 void GL_APIENTRY GL_Frustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
545 {
546 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
547 Context *context = GetValidGlobalContext();
548 EVENT(context, GLFrustumx,
549 "context = %d, l = 0x%X, r = 0x%X, b = 0x%X, t = 0x%X, n = 0x%X, f = 0x%X", CID(context),
550 l, r, b, t, n, f);
551
552 if (context)
553 {
554 bool isCallValid = (context->skipValidation() ||
555 ValidateFrustumx(context->getPrivateState(),
556 context->getMutableErrorSetForValidation(),
557 angle::EntryPoint::GLFrustumx, l, r, b, t, n, f));
558 if (isCallValid)
559 {
560 ContextPrivateFrustumx(context->getMutablePrivateState(),
561 context->getMutablePrivateStateCache(), l, r, b, t, n, f);
562 }
563 ANGLE_CAPTURE_GL(Frustumx, isCallValid, context, l, r, b, t, n, f);
564 }
565 else
566 {
567 GenerateContextLostErrorOnCurrentGlobalContext();
568 }
569 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
570 }
571
GL_GetClipPlanef(GLenum plane,GLfloat * equation)572 void GL_APIENTRY GL_GetClipPlanef(GLenum plane, GLfloat *equation)
573 {
574 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
575 Context *context = GetValidGlobalContext();
576 EVENT(context, GLGetClipPlanef, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "",
577 CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation);
578
579 if (context)
580 {
581 bool isCallValid =
582 (context->skipValidation() ||
583 ValidateGetClipPlanef(context->getPrivateState(),
584 context->getMutableErrorSetForValidation(),
585 angle::EntryPoint::GLGetClipPlanef, plane, equation));
586 if (isCallValid)
587 {
588 ContextPrivateGetClipPlanef(context->getMutablePrivateState(),
589 context->getMutablePrivateStateCache(), plane, equation);
590 }
591 ANGLE_CAPTURE_GL(GetClipPlanef, isCallValid, context, plane, equation);
592 }
593 else
594 {
595 GenerateContextLostErrorOnCurrentGlobalContext();
596 }
597 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
598 }
599
GL_GetClipPlanex(GLenum plane,GLfixed * equation)600 void GL_APIENTRY GL_GetClipPlanex(GLenum plane, GLfixed *equation)
601 {
602 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
603 Context *context = GetValidGlobalContext();
604 EVENT(context, GLGetClipPlanex, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "",
605 CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation);
606
607 if (context)
608 {
609 bool isCallValid =
610 (context->skipValidation() ||
611 ValidateGetClipPlanex(context->getPrivateState(),
612 context->getMutableErrorSetForValidation(),
613 angle::EntryPoint::GLGetClipPlanex, plane, equation));
614 if (isCallValid)
615 {
616 ContextPrivateGetClipPlanex(context->getMutablePrivateState(),
617 context->getMutablePrivateStateCache(), plane, equation);
618 }
619 ANGLE_CAPTURE_GL(GetClipPlanex, isCallValid, context, plane, equation);
620 }
621 else
622 {
623 GenerateContextLostErrorOnCurrentGlobalContext();
624 }
625 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
626 }
627
GL_GetFixedv(GLenum pname,GLfixed * params)628 void GL_APIENTRY GL_GetFixedv(GLenum pname, GLfixed *params)
629 {
630 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
631 Context *context = GetValidGlobalContext();
632 EVENT(context, GLGetFixedv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
633 CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)params);
634
635 if (context)
636 {
637 SCOPED_SHARE_CONTEXT_LOCK(context);
638 bool isCallValid =
639 (context->skipValidation() ||
640 ValidateGetFixedv(context, angle::EntryPoint::GLGetFixedv, pname, params));
641 if (isCallValid)
642 {
643 context->getFixedv(pname, params);
644 }
645 ANGLE_CAPTURE_GL(GetFixedv, isCallValid, context, pname, params);
646 }
647 else
648 {
649 GenerateContextLostErrorOnCurrentGlobalContext();
650 }
651 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
652 }
653
GL_GetLightfv(GLenum light,GLenum pname,GLfloat * params)654 void GL_APIENTRY GL_GetLightfv(GLenum light, GLenum pname, GLfloat *params)
655 {
656 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
657 Context *context = GetValidGlobalContext();
658 EVENT(context, GLGetLightfv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "",
659 CID(context), GLenumToString(GLESEnum::LightName, light),
660 GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params);
661
662 if (context)
663 {
664 LightParameter pnamePacked = PackParam<LightParameter>(pname);
665 bool isCallValid =
666 (context->skipValidation() ||
667 ValidateGetLightfv(context->getPrivateState(),
668 context->getMutableErrorSetForValidation(),
669 angle::EntryPoint::GLGetLightfv, light, pnamePacked, params));
670 if (isCallValid)
671 {
672 ContextPrivateGetLightfv(context->getMutablePrivateState(),
673 context->getMutablePrivateStateCache(), light, pnamePacked,
674 params);
675 }
676 ANGLE_CAPTURE_GL(GetLightfv, isCallValid, context, light, pnamePacked, params);
677 }
678 else
679 {
680 GenerateContextLostErrorOnCurrentGlobalContext();
681 }
682 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
683 }
684
GL_GetLightxv(GLenum light,GLenum pname,GLfixed * params)685 void GL_APIENTRY GL_GetLightxv(GLenum light, GLenum pname, GLfixed *params)
686 {
687 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
688 Context *context = GetValidGlobalContext();
689 EVENT(context, GLGetLightxv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "",
690 CID(context), GLenumToString(GLESEnum::LightName, light),
691 GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params);
692
693 if (context)
694 {
695 LightParameter pnamePacked = PackParam<LightParameter>(pname);
696 bool isCallValid =
697 (context->skipValidation() ||
698 ValidateGetLightxv(context->getPrivateState(),
699 context->getMutableErrorSetForValidation(),
700 angle::EntryPoint::GLGetLightxv, light, pnamePacked, params));
701 if (isCallValid)
702 {
703 ContextPrivateGetLightxv(context->getMutablePrivateState(),
704 context->getMutablePrivateStateCache(), light, pnamePacked,
705 params);
706 }
707 ANGLE_CAPTURE_GL(GetLightxv, isCallValid, context, light, pnamePacked, params);
708 }
709 else
710 {
711 GenerateContextLostErrorOnCurrentGlobalContext();
712 }
713 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
714 }
715
GL_GetMaterialfv(GLenum face,GLenum pname,GLfloat * params)716 void GL_APIENTRY GL_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
717 {
718 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
719 Context *context = GetValidGlobalContext();
720 EVENT(context, GLGetMaterialfv,
721 "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
722 GLenumToString(GLESEnum::TriangleFace, face),
723 GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params);
724
725 if (context)
726 {
727 MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
728 bool isCallValid =
729 (context->skipValidation() ||
730 ValidateGetMaterialfv(context->getPrivateState(),
731 context->getMutableErrorSetForValidation(),
732 angle::EntryPoint::GLGetMaterialfv, face, pnamePacked, params));
733 if (isCallValid)
734 {
735 ContextPrivateGetMaterialfv(context->getMutablePrivateState(),
736 context->getMutablePrivateStateCache(), face, pnamePacked,
737 params);
738 }
739 ANGLE_CAPTURE_GL(GetMaterialfv, isCallValid, context, face, pnamePacked, params);
740 }
741 else
742 {
743 GenerateContextLostErrorOnCurrentGlobalContext();
744 }
745 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
746 }
747
GL_GetMaterialxv(GLenum face,GLenum pname,GLfixed * params)748 void GL_APIENTRY GL_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
749 {
750 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
751 Context *context = GetValidGlobalContext();
752 EVENT(context, GLGetMaterialxv,
753 "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
754 GLenumToString(GLESEnum::TriangleFace, face),
755 GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params);
756
757 if (context)
758 {
759 MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
760 bool isCallValid =
761 (context->skipValidation() ||
762 ValidateGetMaterialxv(context->getPrivateState(),
763 context->getMutableErrorSetForValidation(),
764 angle::EntryPoint::GLGetMaterialxv, face, pnamePacked, params));
765 if (isCallValid)
766 {
767 ContextPrivateGetMaterialxv(context->getMutablePrivateState(),
768 context->getMutablePrivateStateCache(), face, pnamePacked,
769 params);
770 }
771 ANGLE_CAPTURE_GL(GetMaterialxv, isCallValid, context, face, pnamePacked, params);
772 }
773 else
774 {
775 GenerateContextLostErrorOnCurrentGlobalContext();
776 }
777 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
778 }
779
GL_GetTexEnvfv(GLenum target,GLenum pname,GLfloat * params)780 void GL_APIENTRY GL_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
781 {
782 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
783 Context *context = GetValidGlobalContext();
784 EVENT(context, GLGetTexEnvfv,
785 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
786 GLenumToString(GLESEnum::TextureEnvTarget, target),
787 GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params);
788
789 if (context)
790 {
791 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
792 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
793 bool isCallValid =
794 (context->skipValidation() ||
795 ValidateGetTexEnvfv(
796 context->getPrivateState(), context->getMutableErrorSetForValidation(),
797 angle::EntryPoint::GLGetTexEnvfv, targetPacked, pnamePacked, params));
798 if (isCallValid)
799 {
800 ContextPrivateGetTexEnvfv(context->getMutablePrivateState(),
801 context->getMutablePrivateStateCache(), targetPacked,
802 pnamePacked, params);
803 }
804 ANGLE_CAPTURE_GL(GetTexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
805 }
806 else
807 {
808 GenerateContextLostErrorOnCurrentGlobalContext();
809 }
810 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
811 }
812
GL_GetTexEnviv(GLenum target,GLenum pname,GLint * params)813 void GL_APIENTRY GL_GetTexEnviv(GLenum target, GLenum pname, GLint *params)
814 {
815 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
816 Context *context = GetValidGlobalContext();
817 EVENT(context, GLGetTexEnviv,
818 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
819 GLenumToString(GLESEnum::TextureEnvTarget, target),
820 GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params);
821
822 if (context)
823 {
824 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
825 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
826 bool isCallValid =
827 (context->skipValidation() ||
828 ValidateGetTexEnviv(
829 context->getPrivateState(), context->getMutableErrorSetForValidation(),
830 angle::EntryPoint::GLGetTexEnviv, targetPacked, pnamePacked, params));
831 if (isCallValid)
832 {
833 ContextPrivateGetTexEnviv(context->getMutablePrivateState(),
834 context->getMutablePrivateStateCache(), targetPacked,
835 pnamePacked, params);
836 }
837 ANGLE_CAPTURE_GL(GetTexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
838 }
839 else
840 {
841 GenerateContextLostErrorOnCurrentGlobalContext();
842 }
843 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
844 }
845
GL_GetTexEnvxv(GLenum target,GLenum pname,GLfixed * params)846 void GL_APIENTRY GL_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
847 {
848 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
849 Context *context = GetValidGlobalContext();
850 EVENT(context, GLGetTexEnvxv,
851 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
852 GLenumToString(GLESEnum::TextureEnvTarget, target),
853 GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params);
854
855 if (context)
856 {
857 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
858 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
859 bool isCallValid =
860 (context->skipValidation() ||
861 ValidateGetTexEnvxv(
862 context->getPrivateState(), context->getMutableErrorSetForValidation(),
863 angle::EntryPoint::GLGetTexEnvxv, targetPacked, pnamePacked, params));
864 if (isCallValid)
865 {
866 ContextPrivateGetTexEnvxv(context->getMutablePrivateState(),
867 context->getMutablePrivateStateCache(), targetPacked,
868 pnamePacked, params);
869 }
870 ANGLE_CAPTURE_GL(GetTexEnvxv, isCallValid, context, targetPacked, pnamePacked, params);
871 }
872 else
873 {
874 GenerateContextLostErrorOnCurrentGlobalContext();
875 }
876 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
877 }
878
GL_GetTexParameterxv(GLenum target,GLenum pname,GLfixed * params)879 void GL_APIENTRY GL_GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
880 {
881 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
882 Context *context = GetValidGlobalContext();
883 EVENT(context, GLGetTexParameterxv,
884 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
885 GLenumToString(GLESEnum::TextureTarget, target),
886 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
887
888 if (context)
889 {
890 TextureType targetPacked = PackParam<TextureType>(target);
891 SCOPED_SHARE_CONTEXT_LOCK(context);
892 bool isCallValid =
893 (context->skipValidation() ||
894 ValidateGetTexParameterxv(context, angle::EntryPoint::GLGetTexParameterxv,
895 targetPacked, pname, params));
896 if (isCallValid)
897 {
898 context->getTexParameterxv(targetPacked, pname, params);
899 }
900 ANGLE_CAPTURE_GL(GetTexParameterxv, isCallValid, context, targetPacked, pname, params);
901 }
902 else
903 {
904 GenerateContextLostErrorOnCurrentGlobalContext();
905 }
906 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
907 }
908
GL_LightModelf(GLenum pname,GLfloat param)909 void GL_APIENTRY GL_LightModelf(GLenum pname, GLfloat param)
910 {
911 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
912 Context *context = GetValidGlobalContext();
913 EVENT(context, GLLightModelf, "context = %d, pname = %s, param = %f", CID(context),
914 GLenumToString(GLESEnum::LightModelParameter, pname), param);
915
916 if (context)
917 {
918 bool isCallValid = (context->skipValidation() ||
919 ValidateLightModelf(context->getPrivateState(),
920 context->getMutableErrorSetForValidation(),
921 angle::EntryPoint::GLLightModelf, pname, param));
922 if (isCallValid)
923 {
924 ContextPrivateLightModelf(context->getMutablePrivateState(),
925 context->getMutablePrivateStateCache(), pname, param);
926 }
927 ANGLE_CAPTURE_GL(LightModelf, isCallValid, context, pname, param);
928 }
929 else
930 {
931 GenerateContextLostErrorOnCurrentGlobalContext();
932 }
933 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
934 }
935
GL_LightModelfv(GLenum pname,const GLfloat * params)936 void GL_APIENTRY GL_LightModelfv(GLenum pname, const GLfloat *params)
937 {
938 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
939 Context *context = GetValidGlobalContext();
940 EVENT(context, GLLightModelfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
941 CID(context), GLenumToString(GLESEnum::LightModelParameter, pname), (uintptr_t)params);
942
943 if (context)
944 {
945 bool isCallValid = (context->skipValidation() ||
946 ValidateLightModelfv(context->getPrivateState(),
947 context->getMutableErrorSetForValidation(),
948 angle::EntryPoint::GLLightModelfv, pname, params));
949 if (isCallValid)
950 {
951 ContextPrivateLightModelfv(context->getMutablePrivateState(),
952 context->getMutablePrivateStateCache(), pname, params);
953 }
954 ANGLE_CAPTURE_GL(LightModelfv, isCallValid, context, pname, params);
955 }
956 else
957 {
958 GenerateContextLostErrorOnCurrentGlobalContext();
959 }
960 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
961 }
962
GL_LightModelx(GLenum pname,GLfixed param)963 void GL_APIENTRY GL_LightModelx(GLenum pname, GLfixed param)
964 {
965 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
966 Context *context = GetValidGlobalContext();
967 EVENT(context, GLLightModelx, "context = %d, pname = %s, param = 0x%X", CID(context),
968 GLenumToString(GLESEnum::LightModelParameter, pname), param);
969
970 if (context)
971 {
972 bool isCallValid = (context->skipValidation() ||
973 ValidateLightModelx(context->getPrivateState(),
974 context->getMutableErrorSetForValidation(),
975 angle::EntryPoint::GLLightModelx, pname, param));
976 if (isCallValid)
977 {
978 ContextPrivateLightModelx(context->getMutablePrivateState(),
979 context->getMutablePrivateStateCache(), pname, param);
980 }
981 ANGLE_CAPTURE_GL(LightModelx, isCallValid, context, pname, param);
982 }
983 else
984 {
985 GenerateContextLostErrorOnCurrentGlobalContext();
986 }
987 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
988 }
989
GL_LightModelxv(GLenum pname,const GLfixed * param)990 void GL_APIENTRY GL_LightModelxv(GLenum pname, const GLfixed *param)
991 {
992 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
993 Context *context = GetValidGlobalContext();
994 EVENT(context, GLLightModelxv, "context = %d, pname = %s, param = 0x%016" PRIxPTR "",
995 CID(context), GLenumToString(GLESEnum::LightModelParameter, pname), (uintptr_t)param);
996
997 if (context)
998 {
999 bool isCallValid = (context->skipValidation() ||
1000 ValidateLightModelxv(context->getPrivateState(),
1001 context->getMutableErrorSetForValidation(),
1002 angle::EntryPoint::GLLightModelxv, pname, param));
1003 if (isCallValid)
1004 {
1005 ContextPrivateLightModelxv(context->getMutablePrivateState(),
1006 context->getMutablePrivateStateCache(), pname, param);
1007 }
1008 ANGLE_CAPTURE_GL(LightModelxv, isCallValid, context, pname, param);
1009 }
1010 else
1011 {
1012 GenerateContextLostErrorOnCurrentGlobalContext();
1013 }
1014 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1015 }
1016
GL_Lightf(GLenum light,GLenum pname,GLfloat param)1017 void GL_APIENTRY GL_Lightf(GLenum light, GLenum pname, GLfloat param)
1018 {
1019 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1020 Context *context = GetValidGlobalContext();
1021 EVENT(context, GLLightf, "context = %d, light = %s, pname = %s, param = %f", CID(context),
1022 GLenumToString(GLESEnum::LightName, light),
1023 GLenumToString(GLESEnum::LightParameter, pname), param);
1024
1025 if (context)
1026 {
1027 LightParameter pnamePacked = PackParam<LightParameter>(pname);
1028 bool isCallValid =
1029 (context->skipValidation() ||
1030 ValidateLightf(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1031 angle::EntryPoint::GLLightf, light, pnamePacked, param));
1032 if (isCallValid)
1033 {
1034 ContextPrivateLightf(context->getMutablePrivateState(),
1035 context->getMutablePrivateStateCache(), light, pnamePacked, param);
1036 }
1037 ANGLE_CAPTURE_GL(Lightf, isCallValid, context, light, pnamePacked, param);
1038 }
1039 else
1040 {
1041 GenerateContextLostErrorOnCurrentGlobalContext();
1042 }
1043 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1044 }
1045
GL_Lightfv(GLenum light,GLenum pname,const GLfloat * params)1046 void GL_APIENTRY GL_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
1047 {
1048 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1049 Context *context = GetValidGlobalContext();
1050 EVENT(context, GLLightfv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "",
1051 CID(context), GLenumToString(GLESEnum::LightName, light),
1052 GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params);
1053
1054 if (context)
1055 {
1056 LightParameter pnamePacked = PackParam<LightParameter>(pname);
1057 bool isCallValid =
1058 (context->skipValidation() ||
1059 ValidateLightfv(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1060 angle::EntryPoint::GLLightfv, light, pnamePacked, params));
1061 if (isCallValid)
1062 {
1063 ContextPrivateLightfv(context->getMutablePrivateState(),
1064 context->getMutablePrivateStateCache(), light, pnamePacked,
1065 params);
1066 }
1067 ANGLE_CAPTURE_GL(Lightfv, isCallValid, context, light, pnamePacked, params);
1068 }
1069 else
1070 {
1071 GenerateContextLostErrorOnCurrentGlobalContext();
1072 }
1073 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1074 }
1075
GL_Lightx(GLenum light,GLenum pname,GLfixed param)1076 void GL_APIENTRY GL_Lightx(GLenum light, GLenum pname, GLfixed param)
1077 {
1078 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1079 Context *context = GetValidGlobalContext();
1080 EVENT(context, GLLightx, "context = %d, light = %s, pname = %s, param = 0x%X", CID(context),
1081 GLenumToString(GLESEnum::LightName, light),
1082 GLenumToString(GLESEnum::LightParameter, pname), param);
1083
1084 if (context)
1085 {
1086 LightParameter pnamePacked = PackParam<LightParameter>(pname);
1087 bool isCallValid =
1088 (context->skipValidation() ||
1089 ValidateLightx(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1090 angle::EntryPoint::GLLightx, light, pnamePacked, param));
1091 if (isCallValid)
1092 {
1093 ContextPrivateLightx(context->getMutablePrivateState(),
1094 context->getMutablePrivateStateCache(), light, pnamePacked, param);
1095 }
1096 ANGLE_CAPTURE_GL(Lightx, isCallValid, context, light, pnamePacked, param);
1097 }
1098 else
1099 {
1100 GenerateContextLostErrorOnCurrentGlobalContext();
1101 }
1102 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1103 }
1104
GL_Lightxv(GLenum light,GLenum pname,const GLfixed * params)1105 void GL_APIENTRY GL_Lightxv(GLenum light, GLenum pname, const GLfixed *params)
1106 {
1107 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1108 Context *context = GetValidGlobalContext();
1109 EVENT(context, GLLightxv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "",
1110 CID(context), GLenumToString(GLESEnum::LightName, light),
1111 GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params);
1112
1113 if (context)
1114 {
1115 LightParameter pnamePacked = PackParam<LightParameter>(pname);
1116 bool isCallValid =
1117 (context->skipValidation() ||
1118 ValidateLightxv(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1119 angle::EntryPoint::GLLightxv, light, pnamePacked, params));
1120 if (isCallValid)
1121 {
1122 ContextPrivateLightxv(context->getMutablePrivateState(),
1123 context->getMutablePrivateStateCache(), light, pnamePacked,
1124 params);
1125 }
1126 ANGLE_CAPTURE_GL(Lightxv, isCallValid, context, light, pnamePacked, params);
1127 }
1128 else
1129 {
1130 GenerateContextLostErrorOnCurrentGlobalContext();
1131 }
1132 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1133 }
1134
GL_LineWidthx(GLfixed width)1135 void GL_APIENTRY GL_LineWidthx(GLfixed width)
1136 {
1137 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1138 Context *context = GetValidGlobalContext();
1139 EVENT(context, GLLineWidthx, "context = %d, width = 0x%X", CID(context), width);
1140
1141 if (context)
1142 {
1143 bool isCallValid = (context->skipValidation() ||
1144 ValidateLineWidthx(context->getPrivateState(),
1145 context->getMutableErrorSetForValidation(),
1146 angle::EntryPoint::GLLineWidthx, width));
1147 if (isCallValid)
1148 {
1149 ContextPrivateLineWidthx(context->getMutablePrivateState(),
1150 context->getMutablePrivateStateCache(), width);
1151 }
1152 ANGLE_CAPTURE_GL(LineWidthx, isCallValid, context, width);
1153 }
1154 else
1155 {
1156 GenerateContextLostErrorOnCurrentGlobalContext();
1157 }
1158 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1159 }
1160
GL_LoadIdentity()1161 void GL_APIENTRY GL_LoadIdentity()
1162 {
1163 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1164 Context *context = GetValidGlobalContext();
1165 EVENT(context, GLLoadIdentity, "context = %d", CID(context));
1166
1167 if (context)
1168 {
1169 bool isCallValid = (context->skipValidation() ||
1170 ValidateLoadIdentity(context->getPrivateState(),
1171 context->getMutableErrorSetForValidation(),
1172 angle::EntryPoint::GLLoadIdentity));
1173 if (isCallValid)
1174 {
1175 ContextPrivateLoadIdentity(context->getMutablePrivateState(),
1176 context->getMutablePrivateStateCache());
1177 }
1178 ANGLE_CAPTURE_GL(LoadIdentity, isCallValid, context);
1179 }
1180 else
1181 {
1182 GenerateContextLostErrorOnCurrentGlobalContext();
1183 }
1184 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1185 }
1186
GL_LoadMatrixf(const GLfloat * m)1187 void GL_APIENTRY GL_LoadMatrixf(const GLfloat *m)
1188 {
1189 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1190 Context *context = GetValidGlobalContext();
1191 EVENT(context, GLLoadMatrixf, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
1192 (uintptr_t)m);
1193
1194 if (context)
1195 {
1196 bool isCallValid = (context->skipValidation() ||
1197 ValidateLoadMatrixf(context->getPrivateState(),
1198 context->getMutableErrorSetForValidation(),
1199 angle::EntryPoint::GLLoadMatrixf, m));
1200 if (isCallValid)
1201 {
1202 ContextPrivateLoadMatrixf(context->getMutablePrivateState(),
1203 context->getMutablePrivateStateCache(), m);
1204 }
1205 ANGLE_CAPTURE_GL(LoadMatrixf, isCallValid, context, m);
1206 }
1207 else
1208 {
1209 GenerateContextLostErrorOnCurrentGlobalContext();
1210 }
1211 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1212 }
1213
GL_LoadMatrixx(const GLfixed * m)1214 void GL_APIENTRY GL_LoadMatrixx(const GLfixed *m)
1215 {
1216 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1217 Context *context = GetValidGlobalContext();
1218 EVENT(context, GLLoadMatrixx, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
1219 (uintptr_t)m);
1220
1221 if (context)
1222 {
1223 bool isCallValid = (context->skipValidation() ||
1224 ValidateLoadMatrixx(context->getPrivateState(),
1225 context->getMutableErrorSetForValidation(),
1226 angle::EntryPoint::GLLoadMatrixx, m));
1227 if (isCallValid)
1228 {
1229 ContextPrivateLoadMatrixx(context->getMutablePrivateState(),
1230 context->getMutablePrivateStateCache(), m);
1231 }
1232 ANGLE_CAPTURE_GL(LoadMatrixx, isCallValid, context, m);
1233 }
1234 else
1235 {
1236 GenerateContextLostErrorOnCurrentGlobalContext();
1237 }
1238 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1239 }
1240
GL_LogicOp(GLenum opcode)1241 void GL_APIENTRY GL_LogicOp(GLenum opcode)
1242 {
1243 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1244 Context *context = GetValidGlobalContext();
1245 EVENT(context, GLLogicOp, "context = %d, opcode = %s", CID(context),
1246 GLenumToString(GLESEnum::LogicOp, opcode));
1247
1248 if (context)
1249 {
1250 LogicalOperation opcodePacked = PackParam<LogicalOperation>(opcode);
1251 bool isCallValid =
1252 (context->skipValidation() ||
1253 ValidateLogicOp(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1254 angle::EntryPoint::GLLogicOp, opcodePacked));
1255 if (isCallValid)
1256 {
1257 ContextPrivateLogicOp(context->getMutablePrivateState(),
1258 context->getMutablePrivateStateCache(), opcodePacked);
1259 }
1260 ANGLE_CAPTURE_GL(LogicOp, isCallValid, context, opcodePacked);
1261 }
1262 else
1263 {
1264 GenerateContextLostErrorOnCurrentGlobalContext();
1265 }
1266 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1267 }
1268
GL_Materialf(GLenum face,GLenum pname,GLfloat param)1269 void GL_APIENTRY GL_Materialf(GLenum face, GLenum pname, GLfloat param)
1270 {
1271 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1272 Context *context = GetValidGlobalContext();
1273 EVENT(context, GLMaterialf, "context = %d, face = %s, pname = %s, param = %f", CID(context),
1274 GLenumToString(GLESEnum::TriangleFace, face),
1275 GLenumToString(GLESEnum::MaterialParameter, pname), param);
1276
1277 if (context)
1278 {
1279 MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
1280 bool isCallValid =
1281 (context->skipValidation() ||
1282 ValidateMaterialf(context->getPrivateState(),
1283 context->getMutableErrorSetForValidation(),
1284 angle::EntryPoint::GLMaterialf, face, pnamePacked, param));
1285 if (isCallValid)
1286 {
1287 ContextPrivateMaterialf(context->getMutablePrivateState(),
1288 context->getMutablePrivateStateCache(), face, pnamePacked,
1289 param);
1290 }
1291 ANGLE_CAPTURE_GL(Materialf, isCallValid, context, face, pnamePacked, param);
1292 }
1293 else
1294 {
1295 GenerateContextLostErrorOnCurrentGlobalContext();
1296 }
1297 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1298 }
1299
GL_Materialfv(GLenum face,GLenum pname,const GLfloat * params)1300 void GL_APIENTRY GL_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
1301 {
1302 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1303 Context *context = GetValidGlobalContext();
1304 EVENT(context, GLMaterialfv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "",
1305 CID(context), GLenumToString(GLESEnum::TriangleFace, face),
1306 GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params);
1307
1308 if (context)
1309 {
1310 MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
1311 bool isCallValid =
1312 (context->skipValidation() ||
1313 ValidateMaterialfv(context->getPrivateState(),
1314 context->getMutableErrorSetForValidation(),
1315 angle::EntryPoint::GLMaterialfv, face, pnamePacked, params));
1316 if (isCallValid)
1317 {
1318 ContextPrivateMaterialfv(context->getMutablePrivateState(),
1319 context->getMutablePrivateStateCache(), face, pnamePacked,
1320 params);
1321 }
1322 ANGLE_CAPTURE_GL(Materialfv, isCallValid, context, face, pnamePacked, params);
1323 }
1324 else
1325 {
1326 GenerateContextLostErrorOnCurrentGlobalContext();
1327 }
1328 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1329 }
1330
GL_Materialx(GLenum face,GLenum pname,GLfixed param)1331 void GL_APIENTRY GL_Materialx(GLenum face, GLenum pname, GLfixed param)
1332 {
1333 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1334 Context *context = GetValidGlobalContext();
1335 EVENT(context, GLMaterialx, "context = %d, face = %s, pname = %s, param = 0x%X", CID(context),
1336 GLenumToString(GLESEnum::TriangleFace, face),
1337 GLenumToString(GLESEnum::MaterialParameter, pname), param);
1338
1339 if (context)
1340 {
1341 MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
1342 bool isCallValid =
1343 (context->skipValidation() ||
1344 ValidateMaterialx(context->getPrivateState(),
1345 context->getMutableErrorSetForValidation(),
1346 angle::EntryPoint::GLMaterialx, face, pnamePacked, param));
1347 if (isCallValid)
1348 {
1349 ContextPrivateMaterialx(context->getMutablePrivateState(),
1350 context->getMutablePrivateStateCache(), face, pnamePacked,
1351 param);
1352 }
1353 ANGLE_CAPTURE_GL(Materialx, isCallValid, context, face, pnamePacked, param);
1354 }
1355 else
1356 {
1357 GenerateContextLostErrorOnCurrentGlobalContext();
1358 }
1359 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1360 }
1361
GL_Materialxv(GLenum face,GLenum pname,const GLfixed * param)1362 void GL_APIENTRY GL_Materialxv(GLenum face, GLenum pname, const GLfixed *param)
1363 {
1364 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1365 Context *context = GetValidGlobalContext();
1366 EVENT(context, GLMaterialxv, "context = %d, face = %s, pname = %s, param = 0x%016" PRIxPTR "",
1367 CID(context), GLenumToString(GLESEnum::TriangleFace, face),
1368 GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)param);
1369
1370 if (context)
1371 {
1372 MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
1373 bool isCallValid =
1374 (context->skipValidation() ||
1375 ValidateMaterialxv(context->getPrivateState(),
1376 context->getMutableErrorSetForValidation(),
1377 angle::EntryPoint::GLMaterialxv, face, pnamePacked, param));
1378 if (isCallValid)
1379 {
1380 ContextPrivateMaterialxv(context->getMutablePrivateState(),
1381 context->getMutablePrivateStateCache(), face, pnamePacked,
1382 param);
1383 }
1384 ANGLE_CAPTURE_GL(Materialxv, isCallValid, context, face, pnamePacked, param);
1385 }
1386 else
1387 {
1388 GenerateContextLostErrorOnCurrentGlobalContext();
1389 }
1390 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1391 }
1392
GL_MatrixMode(GLenum mode)1393 void GL_APIENTRY GL_MatrixMode(GLenum mode)
1394 {
1395 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1396 Context *context = GetValidGlobalContext();
1397 EVENT(context, GLMatrixMode, "context = %d, mode = %s", CID(context),
1398 GLenumToString(GLESEnum::MatrixMode, mode));
1399
1400 if (context)
1401 {
1402 MatrixType modePacked = PackParam<MatrixType>(mode);
1403 bool isCallValid = (context->skipValidation() ||
1404 ValidateMatrixMode(context->getPrivateState(),
1405 context->getMutableErrorSetForValidation(),
1406 angle::EntryPoint::GLMatrixMode, modePacked));
1407 if (isCallValid)
1408 {
1409 ContextPrivateMatrixMode(context->getMutablePrivateState(),
1410 context->getMutablePrivateStateCache(), modePacked);
1411 }
1412 ANGLE_CAPTURE_GL(MatrixMode, isCallValid, context, modePacked);
1413 }
1414 else
1415 {
1416 GenerateContextLostErrorOnCurrentGlobalContext();
1417 }
1418 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1419 }
1420
GL_MultMatrixf(const GLfloat * m)1421 void GL_APIENTRY GL_MultMatrixf(const GLfloat *m)
1422 {
1423 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1424 Context *context = GetValidGlobalContext();
1425 EVENT(context, GLMultMatrixf, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
1426 (uintptr_t)m);
1427
1428 if (context)
1429 {
1430 bool isCallValid = (context->skipValidation() ||
1431 ValidateMultMatrixf(context->getPrivateState(),
1432 context->getMutableErrorSetForValidation(),
1433 angle::EntryPoint::GLMultMatrixf, m));
1434 if (isCallValid)
1435 {
1436 ContextPrivateMultMatrixf(context->getMutablePrivateState(),
1437 context->getMutablePrivateStateCache(), m);
1438 }
1439 ANGLE_CAPTURE_GL(MultMatrixf, isCallValid, context, m);
1440 }
1441 else
1442 {
1443 GenerateContextLostErrorOnCurrentGlobalContext();
1444 }
1445 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1446 }
1447
GL_MultMatrixx(const GLfixed * m)1448 void GL_APIENTRY GL_MultMatrixx(const GLfixed *m)
1449 {
1450 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1451 Context *context = GetValidGlobalContext();
1452 EVENT(context, GLMultMatrixx, "context = %d, m = 0x%016" PRIxPTR "", CID(context),
1453 (uintptr_t)m);
1454
1455 if (context)
1456 {
1457 bool isCallValid = (context->skipValidation() ||
1458 ValidateMultMatrixx(context->getPrivateState(),
1459 context->getMutableErrorSetForValidation(),
1460 angle::EntryPoint::GLMultMatrixx, m));
1461 if (isCallValid)
1462 {
1463 ContextPrivateMultMatrixx(context->getMutablePrivateState(),
1464 context->getMutablePrivateStateCache(), m);
1465 }
1466 ANGLE_CAPTURE_GL(MultMatrixx, isCallValid, context, m);
1467 }
1468 else
1469 {
1470 GenerateContextLostErrorOnCurrentGlobalContext();
1471 }
1472 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1473 }
1474
GL_MultiTexCoord4f(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)1475 void GL_APIENTRY GL_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1476 {
1477 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1478 Context *context = GetValidGlobalContext();
1479 EVENT(context, GLMultiTexCoord4f, "context = %d, target = %s, s = %f, t = %f, r = %f, q = %f",
1480 CID(context), GLenumToString(GLESEnum::TextureUnit, target), s, t, r, q);
1481
1482 if (context)
1483 {
1484 bool isCallValid =
1485 (context->skipValidation() ||
1486 ValidateMultiTexCoord4f(context->getPrivateState(),
1487 context->getMutableErrorSetForValidation(),
1488 angle::EntryPoint::GLMultiTexCoord4f, target, s, t, r, q));
1489 if (isCallValid)
1490 {
1491 ContextPrivateMultiTexCoord4f(context->getMutablePrivateState(),
1492 context->getMutablePrivateStateCache(), target, s, t, r,
1493 q);
1494 }
1495 ANGLE_CAPTURE_GL(MultiTexCoord4f, isCallValid, context, target, s, t, r, q);
1496 }
1497 else
1498 {
1499 GenerateContextLostErrorOnCurrentGlobalContext();
1500 }
1501 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1502 }
1503
GL_MultiTexCoord4x(GLenum texture,GLfixed s,GLfixed t,GLfixed r,GLfixed q)1504 void GL_APIENTRY GL_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
1505 {
1506 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1507 Context *context = GetValidGlobalContext();
1508 EVENT(context, GLMultiTexCoord4x,
1509 "context = %d, texture = %s, s = 0x%X, t = 0x%X, r = 0x%X, q = 0x%X", CID(context),
1510 GLenumToString(GLESEnum::TextureUnit, texture), s, t, r, q);
1511
1512 if (context)
1513 {
1514 bool isCallValid =
1515 (context->skipValidation() ||
1516 ValidateMultiTexCoord4x(context->getPrivateState(),
1517 context->getMutableErrorSetForValidation(),
1518 angle::EntryPoint::GLMultiTexCoord4x, texture, s, t, r, q));
1519 if (isCallValid)
1520 {
1521 ContextPrivateMultiTexCoord4x(context->getMutablePrivateState(),
1522 context->getMutablePrivateStateCache(), texture, s, t, r,
1523 q);
1524 }
1525 ANGLE_CAPTURE_GL(MultiTexCoord4x, isCallValid, context, texture, s, t, r, q);
1526 }
1527 else
1528 {
1529 GenerateContextLostErrorOnCurrentGlobalContext();
1530 }
1531 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1532 }
1533
GL_Normal3f(GLfloat nx,GLfloat ny,GLfloat nz)1534 void GL_APIENTRY GL_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1535 {
1536 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1537 Context *context = GetValidGlobalContext();
1538 EVENT(context, GLNormal3f, "context = %d, nx = %f, ny = %f, nz = %f", CID(context), nx, ny, nz);
1539
1540 if (context)
1541 {
1542 bool isCallValid = (context->skipValidation() ||
1543 ValidateNormal3f(context->getPrivateState(),
1544 context->getMutableErrorSetForValidation(),
1545 angle::EntryPoint::GLNormal3f, nx, ny, nz));
1546 if (isCallValid)
1547 {
1548 ContextPrivateNormal3f(context->getMutablePrivateState(),
1549 context->getMutablePrivateStateCache(), nx, ny, nz);
1550 }
1551 ANGLE_CAPTURE_GL(Normal3f, isCallValid, context, nx, ny, nz);
1552 }
1553 else
1554 {
1555 GenerateContextLostErrorOnCurrentGlobalContext();
1556 }
1557 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1558 }
1559
GL_Normal3x(GLfixed nx,GLfixed ny,GLfixed nz)1560 void GL_APIENTRY GL_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz)
1561 {
1562 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1563 Context *context = GetValidGlobalContext();
1564 EVENT(context, GLNormal3x, "context = %d, nx = 0x%X, ny = 0x%X, nz = 0x%X", CID(context), nx,
1565 ny, nz);
1566
1567 if (context)
1568 {
1569 bool isCallValid = (context->skipValidation() ||
1570 ValidateNormal3x(context->getPrivateState(),
1571 context->getMutableErrorSetForValidation(),
1572 angle::EntryPoint::GLNormal3x, nx, ny, nz));
1573 if (isCallValid)
1574 {
1575 ContextPrivateNormal3x(context->getMutablePrivateState(),
1576 context->getMutablePrivateStateCache(), nx, ny, nz);
1577 }
1578 ANGLE_CAPTURE_GL(Normal3x, isCallValid, context, nx, ny, nz);
1579 }
1580 else
1581 {
1582 GenerateContextLostErrorOnCurrentGlobalContext();
1583 }
1584 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1585 }
1586
GL_NormalPointer(GLenum type,GLsizei stride,const void * pointer)1587 void GL_APIENTRY GL_NormalPointer(GLenum type, GLsizei stride, const void *pointer)
1588 {
1589 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1590 Context *context = GetValidGlobalContext();
1591 EVENT(context, GLNormalPointer,
1592 "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
1593 GLenumToString(GLESEnum::NormalPointerType, type), stride, (uintptr_t)pointer);
1594
1595 if (context)
1596 {
1597 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
1598 SCOPED_SHARE_CONTEXT_LOCK(context);
1599 bool isCallValid = (context->skipValidation() ||
1600 ValidateNormalPointer(context, angle::EntryPoint::GLNormalPointer,
1601 typePacked, stride, pointer));
1602 if (isCallValid)
1603 {
1604 context->normalPointer(typePacked, stride, pointer);
1605 }
1606 ANGLE_CAPTURE_GL(NormalPointer, isCallValid, context, typePacked, stride, pointer);
1607 }
1608 else
1609 {
1610 GenerateContextLostErrorOnCurrentGlobalContext();
1611 }
1612 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1613 }
1614
GL_Orthof(GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f)1615 void GL_APIENTRY GL_Orthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
1616 {
1617 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1618 Context *context = GetValidGlobalContext();
1619 EVENT(context, GLOrthof, "context = %d, l = %f, r = %f, b = %f, t = %f, n = %f, f = %f",
1620 CID(context), l, r, b, t, n, f);
1621
1622 if (context)
1623 {
1624 bool isCallValid =
1625 (context->skipValidation() ||
1626 ValidateOrthof(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1627 angle::EntryPoint::GLOrthof, l, r, b, t, n, f));
1628 if (isCallValid)
1629 {
1630 ContextPrivateOrthof(context->getMutablePrivateState(),
1631 context->getMutablePrivateStateCache(), l, r, b, t, n, f);
1632 }
1633 ANGLE_CAPTURE_GL(Orthof, isCallValid, context, l, r, b, t, n, f);
1634 }
1635 else
1636 {
1637 GenerateContextLostErrorOnCurrentGlobalContext();
1638 }
1639 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1640 }
1641
GL_Orthox(GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f)1642 void GL_APIENTRY GL_Orthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
1643 {
1644 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1645 Context *context = GetValidGlobalContext();
1646 EVENT(context, GLOrthox,
1647 "context = %d, l = 0x%X, r = 0x%X, b = 0x%X, t = 0x%X, n = 0x%X, f = 0x%X", CID(context),
1648 l, r, b, t, n, f);
1649
1650 if (context)
1651 {
1652 bool isCallValid =
1653 (context->skipValidation() ||
1654 ValidateOrthox(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1655 angle::EntryPoint::GLOrthox, l, r, b, t, n, f));
1656 if (isCallValid)
1657 {
1658 ContextPrivateOrthox(context->getMutablePrivateState(),
1659 context->getMutablePrivateStateCache(), l, r, b, t, n, f);
1660 }
1661 ANGLE_CAPTURE_GL(Orthox, isCallValid, context, l, r, b, t, n, f);
1662 }
1663 else
1664 {
1665 GenerateContextLostErrorOnCurrentGlobalContext();
1666 }
1667 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1668 }
1669
GL_PointParameterf(GLenum pname,GLfloat param)1670 void GL_APIENTRY GL_PointParameterf(GLenum pname, GLfloat param)
1671 {
1672 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1673 Context *context = GetValidGlobalContext();
1674 EVENT(context, GLPointParameterf, "context = %d, pname = %s, param = %f", CID(context),
1675 GLenumToString(GLESEnum::AllEnums, pname), param);
1676
1677 if (context)
1678 {
1679 PointParameter pnamePacked = PackParam<PointParameter>(pname);
1680 bool isCallValid =
1681 (context->skipValidation() ||
1682 ValidatePointParameterf(context->getPrivateState(),
1683 context->getMutableErrorSetForValidation(),
1684 angle::EntryPoint::GLPointParameterf, pnamePacked, param));
1685 if (isCallValid)
1686 {
1687 ContextPrivatePointParameterf(context->getMutablePrivateState(),
1688 context->getMutablePrivateStateCache(), pnamePacked,
1689 param);
1690 }
1691 ANGLE_CAPTURE_GL(PointParameterf, isCallValid, context, pnamePacked, param);
1692 }
1693 else
1694 {
1695 GenerateContextLostErrorOnCurrentGlobalContext();
1696 }
1697 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1698 }
1699
GL_PointParameterfv(GLenum pname,const GLfloat * params)1700 void GL_APIENTRY GL_PointParameterfv(GLenum pname, const GLfloat *params)
1701 {
1702 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1703 Context *context = GetValidGlobalContext();
1704 EVENT(context, GLPointParameterfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
1705 CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
1706
1707 if (context)
1708 {
1709 PointParameter pnamePacked = PackParam<PointParameter>(pname);
1710 bool isCallValid =
1711 (context->skipValidation() ||
1712 ValidatePointParameterfv(context->getPrivateState(),
1713 context->getMutableErrorSetForValidation(),
1714 angle::EntryPoint::GLPointParameterfv, pnamePacked, params));
1715 if (isCallValid)
1716 {
1717 ContextPrivatePointParameterfv(context->getMutablePrivateState(),
1718 context->getMutablePrivateStateCache(), pnamePacked,
1719 params);
1720 }
1721 ANGLE_CAPTURE_GL(PointParameterfv, isCallValid, context, pnamePacked, params);
1722 }
1723 else
1724 {
1725 GenerateContextLostErrorOnCurrentGlobalContext();
1726 }
1727 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1728 }
1729
GL_PointParameterx(GLenum pname,GLfixed param)1730 void GL_APIENTRY GL_PointParameterx(GLenum pname, GLfixed param)
1731 {
1732 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1733 Context *context = GetValidGlobalContext();
1734 EVENT(context, GLPointParameterx, "context = %d, pname = %s, param = 0x%X", CID(context),
1735 GLenumToString(GLESEnum::AllEnums, pname), param);
1736
1737 if (context)
1738 {
1739 PointParameter pnamePacked = PackParam<PointParameter>(pname);
1740 bool isCallValid =
1741 (context->skipValidation() ||
1742 ValidatePointParameterx(context->getPrivateState(),
1743 context->getMutableErrorSetForValidation(),
1744 angle::EntryPoint::GLPointParameterx, pnamePacked, param));
1745 if (isCallValid)
1746 {
1747 ContextPrivatePointParameterx(context->getMutablePrivateState(),
1748 context->getMutablePrivateStateCache(), pnamePacked,
1749 param);
1750 }
1751 ANGLE_CAPTURE_GL(PointParameterx, isCallValid, context, pnamePacked, param);
1752 }
1753 else
1754 {
1755 GenerateContextLostErrorOnCurrentGlobalContext();
1756 }
1757 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1758 }
1759
GL_PointParameterxv(GLenum pname,const GLfixed * params)1760 void GL_APIENTRY GL_PointParameterxv(GLenum pname, const GLfixed *params)
1761 {
1762 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1763 Context *context = GetValidGlobalContext();
1764 EVENT(context, GLPointParameterxv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
1765 CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
1766
1767 if (context)
1768 {
1769 PointParameter pnamePacked = PackParam<PointParameter>(pname);
1770 bool isCallValid =
1771 (context->skipValidation() ||
1772 ValidatePointParameterxv(context->getPrivateState(),
1773 context->getMutableErrorSetForValidation(),
1774 angle::EntryPoint::GLPointParameterxv, pnamePacked, params));
1775 if (isCallValid)
1776 {
1777 ContextPrivatePointParameterxv(context->getMutablePrivateState(),
1778 context->getMutablePrivateStateCache(), pnamePacked,
1779 params);
1780 }
1781 ANGLE_CAPTURE_GL(PointParameterxv, isCallValid, context, pnamePacked, params);
1782 }
1783 else
1784 {
1785 GenerateContextLostErrorOnCurrentGlobalContext();
1786 }
1787 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1788 }
1789
GL_PointSize(GLfloat size)1790 void GL_APIENTRY GL_PointSize(GLfloat size)
1791 {
1792 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1793 Context *context = GetValidGlobalContext();
1794 EVENT(context, GLPointSize, "context = %d, size = %f", CID(context), size);
1795
1796 if (context)
1797 {
1798 bool isCallValid = (context->skipValidation() ||
1799 ValidatePointSize(context->getPrivateState(),
1800 context->getMutableErrorSetForValidation(),
1801 angle::EntryPoint::GLPointSize, size));
1802 if (isCallValid)
1803 {
1804 ContextPrivatePointSize(context->getMutablePrivateState(),
1805 context->getMutablePrivateStateCache(), size);
1806 }
1807 ANGLE_CAPTURE_GL(PointSize, isCallValid, context, size);
1808 }
1809 else
1810 {
1811 GenerateContextLostErrorOnCurrentGlobalContext();
1812 }
1813 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1814 }
1815
GL_PointSizex(GLfixed size)1816 void GL_APIENTRY GL_PointSizex(GLfixed size)
1817 {
1818 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1819 Context *context = GetValidGlobalContext();
1820 EVENT(context, GLPointSizex, "context = %d, size = 0x%X", CID(context), size);
1821
1822 if (context)
1823 {
1824 bool isCallValid = (context->skipValidation() ||
1825 ValidatePointSizex(context->getPrivateState(),
1826 context->getMutableErrorSetForValidation(),
1827 angle::EntryPoint::GLPointSizex, size));
1828 if (isCallValid)
1829 {
1830 ContextPrivatePointSizex(context->getMutablePrivateState(),
1831 context->getMutablePrivateStateCache(), size);
1832 }
1833 ANGLE_CAPTURE_GL(PointSizex, isCallValid, context, size);
1834 }
1835 else
1836 {
1837 GenerateContextLostErrorOnCurrentGlobalContext();
1838 }
1839 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1840 }
1841
GL_PolygonOffsetx(GLfixed factor,GLfixed units)1842 void GL_APIENTRY GL_PolygonOffsetx(GLfixed factor, GLfixed units)
1843 {
1844 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1845 Context *context = GetValidGlobalContext();
1846 EVENT(context, GLPolygonOffsetx, "context = %d, factor = 0x%X, units = 0x%X", CID(context),
1847 factor, units);
1848
1849 if (context)
1850 {
1851 bool isCallValid =
1852 (context->skipValidation() ||
1853 ValidatePolygonOffsetx(context->getPrivateState(),
1854 context->getMutableErrorSetForValidation(),
1855 angle::EntryPoint::GLPolygonOffsetx, factor, units));
1856 if (isCallValid)
1857 {
1858 ContextPrivatePolygonOffsetx(context->getMutablePrivateState(),
1859 context->getMutablePrivateStateCache(), factor, units);
1860 }
1861 ANGLE_CAPTURE_GL(PolygonOffsetx, isCallValid, context, factor, units);
1862 }
1863 else
1864 {
1865 GenerateContextLostErrorOnCurrentGlobalContext();
1866 }
1867 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1868 }
1869
GL_PopMatrix()1870 void GL_APIENTRY GL_PopMatrix()
1871 {
1872 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1873 Context *context = GetValidGlobalContext();
1874 EVENT(context, GLPopMatrix, "context = %d", CID(context));
1875
1876 if (context)
1877 {
1878 bool isCallValid = (context->skipValidation() ||
1879 ValidatePopMatrix(context->getPrivateState(),
1880 context->getMutableErrorSetForValidation(),
1881 angle::EntryPoint::GLPopMatrix));
1882 if (isCallValid)
1883 {
1884 ContextPrivatePopMatrix(context->getMutablePrivateState(),
1885 context->getMutablePrivateStateCache());
1886 }
1887 ANGLE_CAPTURE_GL(PopMatrix, isCallValid, context);
1888 }
1889 else
1890 {
1891 GenerateContextLostErrorOnCurrentGlobalContext();
1892 }
1893 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1894 }
1895
GL_PushMatrix()1896 void GL_APIENTRY GL_PushMatrix()
1897 {
1898 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1899 Context *context = GetValidGlobalContext();
1900 EVENT(context, GLPushMatrix, "context = %d", CID(context));
1901
1902 if (context)
1903 {
1904 bool isCallValid = (context->skipValidation() ||
1905 ValidatePushMatrix(context->getPrivateState(),
1906 context->getMutableErrorSetForValidation(),
1907 angle::EntryPoint::GLPushMatrix));
1908 if (isCallValid)
1909 {
1910 ContextPrivatePushMatrix(context->getMutablePrivateState(),
1911 context->getMutablePrivateStateCache());
1912 }
1913 ANGLE_CAPTURE_GL(PushMatrix, isCallValid, context);
1914 }
1915 else
1916 {
1917 GenerateContextLostErrorOnCurrentGlobalContext();
1918 }
1919 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1920 }
1921
GL_Rotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)1922 void GL_APIENTRY GL_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
1923 {
1924 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1925 Context *context = GetValidGlobalContext();
1926 EVENT(context, GLRotatef, "context = %d, angle = %f, x = %f, y = %f, z = %f", CID(context),
1927 angle, x, y, z);
1928
1929 if (context)
1930 {
1931 bool isCallValid =
1932 (context->skipValidation() ||
1933 ValidateRotatef(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1934 angle::EntryPoint::GLRotatef, angle, x, y, z));
1935 if (isCallValid)
1936 {
1937 ContextPrivateRotatef(context->getMutablePrivateState(),
1938 context->getMutablePrivateStateCache(), angle, x, y, z);
1939 }
1940 ANGLE_CAPTURE_GL(Rotatef, isCallValid, context, angle, x, y, z);
1941 }
1942 else
1943 {
1944 GenerateContextLostErrorOnCurrentGlobalContext();
1945 }
1946 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1947 }
1948
GL_Rotatex(GLfixed angle,GLfixed x,GLfixed y,GLfixed z)1949 void GL_APIENTRY GL_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
1950 {
1951 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1952 Context *context = GetValidGlobalContext();
1953 EVENT(context, GLRotatex, "context = %d, angle = 0x%X, x = 0x%X, y = 0x%X, z = 0x%X",
1954 CID(context), angle, x, y, z);
1955
1956 if (context)
1957 {
1958 bool isCallValid =
1959 (context->skipValidation() ||
1960 ValidateRotatex(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1961 angle::EntryPoint::GLRotatex, angle, x, y, z));
1962 if (isCallValid)
1963 {
1964 ContextPrivateRotatex(context->getMutablePrivateState(),
1965 context->getMutablePrivateStateCache(), angle, x, y, z);
1966 }
1967 ANGLE_CAPTURE_GL(Rotatex, isCallValid, context, angle, x, y, z);
1968 }
1969 else
1970 {
1971 GenerateContextLostErrorOnCurrentGlobalContext();
1972 }
1973 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1974 }
1975
GL_SampleCoveragex(GLclampx value,GLboolean invert)1976 void GL_APIENTRY GL_SampleCoveragex(GLclampx value, GLboolean invert)
1977 {
1978 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1979 Context *context = GetValidGlobalContext();
1980 EVENT(context, GLSampleCoveragex, "context = %d, value = 0x%X, invert = %s", CID(context),
1981 value, GLbooleanToString(invert));
1982
1983 if (context)
1984 {
1985 bool isCallValid =
1986 (context->skipValidation() ||
1987 ValidateSampleCoveragex(context->getPrivateState(),
1988 context->getMutableErrorSetForValidation(),
1989 angle::EntryPoint::GLSampleCoveragex, value, invert));
1990 if (isCallValid)
1991 {
1992 ContextPrivateSampleCoveragex(context->getMutablePrivateState(),
1993 context->getMutablePrivateStateCache(), value, invert);
1994 }
1995 ANGLE_CAPTURE_GL(SampleCoveragex, isCallValid, context, value, invert);
1996 }
1997 else
1998 {
1999 GenerateContextLostErrorOnCurrentGlobalContext();
2000 }
2001 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2002 }
2003
GL_Scalef(GLfloat x,GLfloat y,GLfloat z)2004 void GL_APIENTRY GL_Scalef(GLfloat x, GLfloat y, GLfloat z)
2005 {
2006 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2007 Context *context = GetValidGlobalContext();
2008 EVENT(context, GLScalef, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
2009
2010 if (context)
2011 {
2012 bool isCallValid =
2013 (context->skipValidation() ||
2014 ValidateScalef(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2015 angle::EntryPoint::GLScalef, x, y, z));
2016 if (isCallValid)
2017 {
2018 ContextPrivateScalef(context->getMutablePrivateState(),
2019 context->getMutablePrivateStateCache(), x, y, z);
2020 }
2021 ANGLE_CAPTURE_GL(Scalef, isCallValid, context, x, y, z);
2022 }
2023 else
2024 {
2025 GenerateContextLostErrorOnCurrentGlobalContext();
2026 }
2027 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2028 }
2029
GL_Scalex(GLfixed x,GLfixed y,GLfixed z)2030 void GL_APIENTRY GL_Scalex(GLfixed x, GLfixed y, GLfixed z)
2031 {
2032 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2033 Context *context = GetValidGlobalContext();
2034 EVENT(context, GLScalex, "context = %d, x = 0x%X, y = 0x%X, z = 0x%X", CID(context), x, y, z);
2035
2036 if (context)
2037 {
2038 bool isCallValid =
2039 (context->skipValidation() ||
2040 ValidateScalex(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2041 angle::EntryPoint::GLScalex, x, y, z));
2042 if (isCallValid)
2043 {
2044 ContextPrivateScalex(context->getMutablePrivateState(),
2045 context->getMutablePrivateStateCache(), x, y, z);
2046 }
2047 ANGLE_CAPTURE_GL(Scalex, isCallValid, context, x, y, z);
2048 }
2049 else
2050 {
2051 GenerateContextLostErrorOnCurrentGlobalContext();
2052 }
2053 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2054 }
2055
GL_ShadeModel(GLenum mode)2056 void GL_APIENTRY GL_ShadeModel(GLenum mode)
2057 {
2058 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2059 Context *context = GetValidGlobalContext();
2060 EVENT(context, GLShadeModel, "context = %d, mode = %s", CID(context),
2061 GLenumToString(GLESEnum::ShadingModel, mode));
2062
2063 if (context)
2064 {
2065 ShadingModel modePacked = PackParam<ShadingModel>(mode);
2066 bool isCallValid = (context->skipValidation() ||
2067 ValidateShadeModel(context->getPrivateState(),
2068 context->getMutableErrorSetForValidation(),
2069 angle::EntryPoint::GLShadeModel, modePacked));
2070 if (isCallValid)
2071 {
2072 ContextPrivateShadeModel(context->getMutablePrivateState(),
2073 context->getMutablePrivateStateCache(), modePacked);
2074 }
2075 ANGLE_CAPTURE_GL(ShadeModel, isCallValid, context, modePacked);
2076 }
2077 else
2078 {
2079 GenerateContextLostErrorOnCurrentGlobalContext();
2080 }
2081 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2082 }
2083
GL_TexCoordPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)2084 void GL_APIENTRY GL_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
2085 {
2086 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2087 Context *context = GetValidGlobalContext();
2088 EVENT(context, GLTexCoordPointer,
2089 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
2090 CID(context), size, GLenumToString(GLESEnum::TexCoordPointerType, type), stride,
2091 (uintptr_t)pointer);
2092
2093 if (context)
2094 {
2095 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
2096 SCOPED_SHARE_CONTEXT_LOCK(context);
2097 bool isCallValid = (context->skipValidation() ||
2098 ValidateTexCoordPointer(context, angle::EntryPoint::GLTexCoordPointer,
2099 size, typePacked, stride, pointer));
2100 if (isCallValid)
2101 {
2102 context->texCoordPointer(size, typePacked, stride, pointer);
2103 }
2104 ANGLE_CAPTURE_GL(TexCoordPointer, isCallValid, context, size, typePacked, stride, pointer);
2105 }
2106 else
2107 {
2108 GenerateContextLostErrorOnCurrentGlobalContext();
2109 }
2110 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2111 }
2112
GL_TexEnvf(GLenum target,GLenum pname,GLfloat param)2113 void GL_APIENTRY GL_TexEnvf(GLenum target, GLenum pname, GLfloat param)
2114 {
2115 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2116 Context *context = GetValidGlobalContext();
2117 EVENT(context, GLTexEnvf, "context = %d, target = %s, pname = %s, param = %f", CID(context),
2118 GLenumToString(GLESEnum::TextureEnvTarget, target),
2119 GLenumToString(GLESEnum::TextureEnvParameter, pname), param);
2120
2121 if (context)
2122 {
2123 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
2124 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
2125 bool isCallValid =
2126 (context->skipValidation() ||
2127 ValidateTexEnvf(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2128 angle::EntryPoint::GLTexEnvf, targetPacked, pnamePacked, param));
2129 if (isCallValid)
2130 {
2131 ContextPrivateTexEnvf(context->getMutablePrivateState(),
2132 context->getMutablePrivateStateCache(), targetPacked, pnamePacked,
2133 param);
2134 }
2135 ANGLE_CAPTURE_GL(TexEnvf, isCallValid, context, targetPacked, pnamePacked, param);
2136 }
2137 else
2138 {
2139 GenerateContextLostErrorOnCurrentGlobalContext();
2140 }
2141 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2142 }
2143
GL_TexEnvfv(GLenum target,GLenum pname,const GLfloat * params)2144 void GL_APIENTRY GL_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
2145 {
2146 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2147 Context *context = GetValidGlobalContext();
2148 EVENT(context, GLTexEnvfv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "",
2149 CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target),
2150 GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params);
2151
2152 if (context)
2153 {
2154 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
2155 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
2156 bool isCallValid =
2157 (context->skipValidation() ||
2158 ValidateTexEnvfv(context->getPrivateState(),
2159 context->getMutableErrorSetForValidation(),
2160 angle::EntryPoint::GLTexEnvfv, targetPacked, pnamePacked, params));
2161 if (isCallValid)
2162 {
2163 ContextPrivateTexEnvfv(context->getMutablePrivateState(),
2164 context->getMutablePrivateStateCache(), targetPacked,
2165 pnamePacked, params);
2166 }
2167 ANGLE_CAPTURE_GL(TexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
2168 }
2169 else
2170 {
2171 GenerateContextLostErrorOnCurrentGlobalContext();
2172 }
2173 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2174 }
2175
GL_TexEnvi(GLenum target,GLenum pname,GLint param)2176 void GL_APIENTRY GL_TexEnvi(GLenum target, GLenum pname, GLint param)
2177 {
2178 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2179 Context *context = GetValidGlobalContext();
2180 EVENT(context, GLTexEnvi, "context = %d, target = %s, pname = %s, param = %d", CID(context),
2181 GLenumToString(GLESEnum::TextureEnvTarget, target),
2182 GLenumToString(GLESEnum::TextureEnvParameter, pname), param);
2183
2184 if (context)
2185 {
2186 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
2187 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
2188 bool isCallValid =
2189 (context->skipValidation() ||
2190 ValidateTexEnvi(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2191 angle::EntryPoint::GLTexEnvi, targetPacked, pnamePacked, param));
2192 if (isCallValid)
2193 {
2194 ContextPrivateTexEnvi(context->getMutablePrivateState(),
2195 context->getMutablePrivateStateCache(), targetPacked, pnamePacked,
2196 param);
2197 }
2198 ANGLE_CAPTURE_GL(TexEnvi, isCallValid, context, targetPacked, pnamePacked, param);
2199 }
2200 else
2201 {
2202 GenerateContextLostErrorOnCurrentGlobalContext();
2203 }
2204 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2205 }
2206
GL_TexEnviv(GLenum target,GLenum pname,const GLint * params)2207 void GL_APIENTRY GL_TexEnviv(GLenum target, GLenum pname, const GLint *params)
2208 {
2209 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2210 Context *context = GetValidGlobalContext();
2211 EVENT(context, GLTexEnviv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "",
2212 CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target),
2213 GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params);
2214
2215 if (context)
2216 {
2217 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
2218 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
2219 bool isCallValid =
2220 (context->skipValidation() ||
2221 ValidateTexEnviv(context->getPrivateState(),
2222 context->getMutableErrorSetForValidation(),
2223 angle::EntryPoint::GLTexEnviv, targetPacked, pnamePacked, params));
2224 if (isCallValid)
2225 {
2226 ContextPrivateTexEnviv(context->getMutablePrivateState(),
2227 context->getMutablePrivateStateCache(), targetPacked,
2228 pnamePacked, params);
2229 }
2230 ANGLE_CAPTURE_GL(TexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
2231 }
2232 else
2233 {
2234 GenerateContextLostErrorOnCurrentGlobalContext();
2235 }
2236 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2237 }
2238
GL_TexEnvx(GLenum target,GLenum pname,GLfixed param)2239 void GL_APIENTRY GL_TexEnvx(GLenum target, GLenum pname, GLfixed param)
2240 {
2241 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2242 Context *context = GetValidGlobalContext();
2243 EVENT(context, GLTexEnvx, "context = %d, target = %s, pname = %s, param = 0x%X", CID(context),
2244 GLenumToString(GLESEnum::TextureEnvTarget, target),
2245 GLenumToString(GLESEnum::TextureEnvParameter, pname), param);
2246
2247 if (context)
2248 {
2249 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
2250 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
2251 bool isCallValid =
2252 (context->skipValidation() ||
2253 ValidateTexEnvx(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2254 angle::EntryPoint::GLTexEnvx, targetPacked, pnamePacked, param));
2255 if (isCallValid)
2256 {
2257 ContextPrivateTexEnvx(context->getMutablePrivateState(),
2258 context->getMutablePrivateStateCache(), targetPacked, pnamePacked,
2259 param);
2260 }
2261 ANGLE_CAPTURE_GL(TexEnvx, isCallValid, context, targetPacked, pnamePacked, param);
2262 }
2263 else
2264 {
2265 GenerateContextLostErrorOnCurrentGlobalContext();
2266 }
2267 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2268 }
2269
GL_TexEnvxv(GLenum target,GLenum pname,const GLfixed * params)2270 void GL_APIENTRY GL_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
2271 {
2272 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2273 Context *context = GetValidGlobalContext();
2274 EVENT(context, GLTexEnvxv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "",
2275 CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target),
2276 GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params);
2277
2278 if (context)
2279 {
2280 TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target);
2281 TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
2282 bool isCallValid =
2283 (context->skipValidation() ||
2284 ValidateTexEnvxv(context->getPrivateState(),
2285 context->getMutableErrorSetForValidation(),
2286 angle::EntryPoint::GLTexEnvxv, targetPacked, pnamePacked, params));
2287 if (isCallValid)
2288 {
2289 ContextPrivateTexEnvxv(context->getMutablePrivateState(),
2290 context->getMutablePrivateStateCache(), targetPacked,
2291 pnamePacked, params);
2292 }
2293 ANGLE_CAPTURE_GL(TexEnvxv, isCallValid, context, targetPacked, pnamePacked, params);
2294 }
2295 else
2296 {
2297 GenerateContextLostErrorOnCurrentGlobalContext();
2298 }
2299 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2300 }
2301
GL_TexParameterx(GLenum target,GLenum pname,GLfixed param)2302 void GL_APIENTRY GL_TexParameterx(GLenum target, GLenum pname, GLfixed param)
2303 {
2304 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2305 Context *context = GetValidGlobalContext();
2306 EVENT(context, GLTexParameterx, "context = %d, target = %s, pname = %s, param = 0x%X",
2307 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
2308 GLenumToString(GLESEnum::GetTextureParameter, pname), param);
2309
2310 if (context)
2311 {
2312 TextureType targetPacked = PackParam<TextureType>(target);
2313 SCOPED_SHARE_CONTEXT_LOCK(context);
2314 bool isCallValid = (context->skipValidation() ||
2315 ValidateTexParameterx(context, angle::EntryPoint::GLTexParameterx,
2316 targetPacked, pname, param));
2317 if (isCallValid)
2318 {
2319 context->texParameterx(targetPacked, pname, param);
2320 }
2321 ANGLE_CAPTURE_GL(TexParameterx, isCallValid, context, targetPacked, pname, param);
2322 }
2323 else
2324 {
2325 GenerateContextLostErrorOnCurrentGlobalContext();
2326 }
2327 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2328 }
2329
GL_TexParameterxv(GLenum target,GLenum pname,const GLfixed * params)2330 void GL_APIENTRY GL_TexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
2331 {
2332 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2333 Context *context = GetValidGlobalContext();
2334 EVENT(context, GLTexParameterxv,
2335 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2336 GLenumToString(GLESEnum::TextureTarget, target),
2337 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
2338
2339 if (context)
2340 {
2341 TextureType targetPacked = PackParam<TextureType>(target);
2342 SCOPED_SHARE_CONTEXT_LOCK(context);
2343 bool isCallValid = (context->skipValidation() ||
2344 ValidateTexParameterxv(context, angle::EntryPoint::GLTexParameterxv,
2345 targetPacked, pname, params));
2346 if (isCallValid)
2347 {
2348 context->texParameterxv(targetPacked, pname, params);
2349 }
2350 ANGLE_CAPTURE_GL(TexParameterxv, isCallValid, context, targetPacked, pname, params);
2351 }
2352 else
2353 {
2354 GenerateContextLostErrorOnCurrentGlobalContext();
2355 }
2356 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2357 }
2358
GL_Translatef(GLfloat x,GLfloat y,GLfloat z)2359 void GL_APIENTRY GL_Translatef(GLfloat x, GLfloat y, GLfloat z)
2360 {
2361 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2362 Context *context = GetValidGlobalContext();
2363 EVENT(context, GLTranslatef, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z);
2364
2365 if (context)
2366 {
2367 bool isCallValid = (context->skipValidation() ||
2368 ValidateTranslatef(context->getPrivateState(),
2369 context->getMutableErrorSetForValidation(),
2370 angle::EntryPoint::GLTranslatef, x, y, z));
2371 if (isCallValid)
2372 {
2373 ContextPrivateTranslatef(context->getMutablePrivateState(),
2374 context->getMutablePrivateStateCache(), x, y, z);
2375 }
2376 ANGLE_CAPTURE_GL(Translatef, isCallValid, context, x, y, z);
2377 }
2378 else
2379 {
2380 GenerateContextLostErrorOnCurrentGlobalContext();
2381 }
2382 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2383 }
2384
GL_Translatex(GLfixed x,GLfixed y,GLfixed z)2385 void GL_APIENTRY GL_Translatex(GLfixed x, GLfixed y, GLfixed z)
2386 {
2387 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2388 Context *context = GetValidGlobalContext();
2389 EVENT(context, GLTranslatex, "context = %d, x = 0x%X, y = 0x%X, z = 0x%X", CID(context), x, y,
2390 z);
2391
2392 if (context)
2393 {
2394 bool isCallValid = (context->skipValidation() ||
2395 ValidateTranslatex(context->getPrivateState(),
2396 context->getMutableErrorSetForValidation(),
2397 angle::EntryPoint::GLTranslatex, x, y, z));
2398 if (isCallValid)
2399 {
2400 ContextPrivateTranslatex(context->getMutablePrivateState(),
2401 context->getMutablePrivateStateCache(), x, y, z);
2402 }
2403 ANGLE_CAPTURE_GL(Translatex, isCallValid, context, x, y, z);
2404 }
2405 else
2406 {
2407 GenerateContextLostErrorOnCurrentGlobalContext();
2408 }
2409 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2410 }
2411
GL_VertexPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)2412 void GL_APIENTRY GL_VertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
2413 {
2414 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2415 Context *context = GetValidGlobalContext();
2416 EVENT(context, GLVertexPointer,
2417 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
2418 CID(context), size, GLenumToString(GLESEnum::VertexPointerType, type), stride,
2419 (uintptr_t)pointer);
2420
2421 if (context)
2422 {
2423 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
2424 SCOPED_SHARE_CONTEXT_LOCK(context);
2425 bool isCallValid = (context->skipValidation() ||
2426 ValidateVertexPointer(context, angle::EntryPoint::GLVertexPointer, size,
2427 typePacked, stride, pointer));
2428 if (isCallValid)
2429 {
2430 context->vertexPointer(size, typePacked, stride, pointer);
2431 }
2432 ANGLE_CAPTURE_GL(VertexPointer, isCallValid, context, size, typePacked, stride, pointer);
2433 }
2434 else
2435 {
2436 GenerateContextLostErrorOnCurrentGlobalContext();
2437 }
2438 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2439 }
2440
2441 } // extern "C"
2442