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_2_0_autogen.cpp:
9 // Defines the GLES 2.0 entry points.
10
11 #include "libGLESv2/entry_points_gles_2_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_2_0_autogen.h"
18 #include "libANGLE/context_private_call_autogen.h"
19 #include "libANGLE/entry_points_utils.h"
20 #include "libANGLE/validationES2.h"
21 #include "libGLESv2/global_state.h"
22
23 using namespace gl;
24
25 extern "C" {
GL_ActiveTexture(GLenum texture)26 void GL_APIENTRY GL_ActiveTexture(GLenum texture)
27 {
28 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
29 Context *context = GetValidGlobalContext();
30 EVENT(context, GLActiveTexture, "context = %d, texture = %s", CID(context),
31 GLenumToString(GLESEnum::TextureUnit, texture));
32
33 if (context)
34 {
35 bool isCallValid = (context->skipValidation() ||
36 ValidateActiveTexture(context->getPrivateState(),
37 context->getMutableErrorSetForValidation(),
38 angle::EntryPoint::GLActiveTexture, texture));
39 if (isCallValid)
40 {
41 ContextPrivateActiveTexture(context->getMutablePrivateState(),
42 context->getMutablePrivateStateCache(), texture);
43 }
44 ANGLE_CAPTURE_GL(ActiveTexture, isCallValid, context, texture);
45 }
46 else
47 {
48 GenerateContextLostErrorOnCurrentGlobalContext();
49 }
50 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
51 }
52
GL_AttachShader(GLuint program,GLuint shader)53 void GL_APIENTRY GL_AttachShader(GLuint program, GLuint shader)
54 {
55 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
56 Context *context = GetValidGlobalContext();
57 EVENT(context, GLAttachShader, "context = %d, program = %u, shader = %u", CID(context), program,
58 shader);
59
60 if (context)
61 {
62 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
63 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
64 SCOPED_SHARE_CONTEXT_LOCK(context);
65 bool isCallValid =
66 (context->skipValidation() ||
67 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
68 context->getMutableErrorSetForValidation(),
69 angle::EntryPoint::GLAttachShader) &&
70 ValidateAttachShader(context, angle::EntryPoint::GLAttachShader, programPacked,
71 shaderPacked)));
72 if (isCallValid)
73 {
74 context->attachShader(programPacked, shaderPacked);
75 }
76 ANGLE_CAPTURE_GL(AttachShader, isCallValid, context, programPacked, shaderPacked);
77 }
78 else
79 {
80 GenerateContextLostErrorOnCurrentGlobalContext();
81 }
82 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
83 }
84
GL_BindAttribLocation(GLuint program,GLuint index,const GLchar * name)85 void GL_APIENTRY GL_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
86 {
87 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
88 Context *context = GetValidGlobalContext();
89 EVENT(context, GLBindAttribLocation,
90 "context = %d, program = %u, index = %u, name = 0x%016" PRIxPTR "", CID(context), program,
91 index, (uintptr_t)name);
92
93 if (context)
94 {
95 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
96 SCOPED_SHARE_CONTEXT_LOCK(context);
97 bool isCallValid =
98 (context->skipValidation() ||
99 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
100 context->getMutableErrorSetForValidation(),
101 angle::EntryPoint::GLBindAttribLocation) &&
102 ValidateBindAttribLocation(context, angle::EntryPoint::GLBindAttribLocation,
103 programPacked, index, name)));
104 if (isCallValid)
105 {
106 context->bindAttribLocation(programPacked, index, name);
107 }
108 ANGLE_CAPTURE_GL(BindAttribLocation, isCallValid, context, programPacked, index, name);
109 }
110 else
111 {
112 GenerateContextLostErrorOnCurrentGlobalContext();
113 }
114 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
115 }
116
GL_BindBuffer(GLenum target,GLuint buffer)117 void GL_APIENTRY GL_BindBuffer(GLenum target, GLuint buffer)
118 {
119 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
120 Context *context = GetValidGlobalContext();
121 EVENT(context, GLBindBuffer, "context = %d, target = %s, buffer = %u", CID(context),
122 GLenumToString(GLESEnum::BufferTargetARB, target), buffer);
123
124 if (context)
125 {
126 BufferBinding targetPacked = PackParam<BufferBinding>(target);
127 BufferID bufferPacked = PackParam<BufferID>(buffer);
128
129 bool isCallValid = (context->skipValidation() ||
130 ValidateBindBuffer(context, angle::EntryPoint::GLBindBuffer,
131 targetPacked, bufferPacked));
132 if (isCallValid)
133 {
134 context->bindBuffer(targetPacked, bufferPacked);
135 }
136 ANGLE_CAPTURE_GL(BindBuffer, isCallValid, context, targetPacked, bufferPacked);
137 }
138 else
139 {
140 GenerateContextLostErrorOnCurrentGlobalContext();
141 }
142 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
143 }
144
GL_BindFramebuffer(GLenum target,GLuint framebuffer)145 void GL_APIENTRY GL_BindFramebuffer(GLenum target, GLuint framebuffer)
146 {
147 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
148 Context *context = GetValidGlobalContext();
149 EVENT(context, GLBindFramebuffer, "context = %d, target = %s, framebuffer = %u", CID(context),
150 GLenumToString(GLESEnum::FramebufferTarget, target), framebuffer);
151
152 if (context)
153 {
154 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
155 SCOPED_SHARE_CONTEXT_LOCK(context);
156 bool isCallValid = (context->skipValidation() ||
157 ValidateBindFramebuffer(context, angle::EntryPoint::GLBindFramebuffer,
158 target, framebufferPacked));
159 if (isCallValid)
160 {
161 context->bindFramebuffer(target, framebufferPacked);
162 }
163 ANGLE_CAPTURE_GL(BindFramebuffer, isCallValid, context, target, framebufferPacked);
164 }
165 else
166 {
167 GenerateContextLostErrorOnCurrentGlobalContext();
168 }
169 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
170 }
171
GL_BindRenderbuffer(GLenum target,GLuint renderbuffer)172 void GL_APIENTRY GL_BindRenderbuffer(GLenum target, GLuint renderbuffer)
173 {
174 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
175 Context *context = GetValidGlobalContext();
176 EVENT(context, GLBindRenderbuffer, "context = %d, target = %s, renderbuffer = %u", CID(context),
177 GLenumToString(GLESEnum::RenderbufferTarget, target), renderbuffer);
178
179 if (context)
180 {
181 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
182 SCOPED_SHARE_CONTEXT_LOCK(context);
183 bool isCallValid =
184 (context->skipValidation() ||
185 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
186 context->getMutableErrorSetForValidation(),
187 angle::EntryPoint::GLBindRenderbuffer) &&
188 ValidateBindRenderbuffer(context, angle::EntryPoint::GLBindRenderbuffer, target,
189 renderbufferPacked)));
190 if (isCallValid)
191 {
192 context->bindRenderbuffer(target, renderbufferPacked);
193 }
194 ANGLE_CAPTURE_GL(BindRenderbuffer, isCallValid, context, target, renderbufferPacked);
195 }
196 else
197 {
198 GenerateContextLostErrorOnCurrentGlobalContext();
199 }
200 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
201 }
202
GL_BindTexture(GLenum target,GLuint texture)203 void GL_APIENTRY GL_BindTexture(GLenum target, GLuint texture)
204 {
205 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
206 Context *context = GetValidGlobalContext();
207 EVENT(context, GLBindTexture, "context = %d, target = %s, texture = %u", CID(context),
208 GLenumToString(GLESEnum::TextureTarget, target), texture);
209
210 if (context)
211 {
212 TextureType targetPacked = PackParam<TextureType>(target);
213 TextureID texturePacked = PackParam<TextureID>(texture);
214 SCOPED_SHARE_CONTEXT_LOCK(context);
215 bool isCallValid = (context->skipValidation() ||
216 ValidateBindTexture(context, angle::EntryPoint::GLBindTexture,
217 targetPacked, texturePacked));
218 if (isCallValid)
219 {
220 context->bindTexture(targetPacked, texturePacked);
221 }
222 ANGLE_CAPTURE_GL(BindTexture, isCallValid, context, targetPacked, texturePacked);
223 }
224 else
225 {
226 GenerateContextLostErrorOnCurrentGlobalContext();
227 }
228 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
229 }
230
GL_BlendColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)231 void GL_APIENTRY GL_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
232 {
233 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
234 Context *context = GetValidGlobalContext();
235 EVENT(context, GLBlendColor, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
236 CID(context), red, green, blue, alpha);
237
238 if (context)
239 {
240 bool isCallValid =
241 (context->skipValidation() ||
242 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
243 context->getMutableErrorSetForValidation(),
244 angle::EntryPoint::GLBlendColor) &&
245 ValidateBlendColor(context->getPrivateState(),
246 context->getMutableErrorSetForValidation(),
247 angle::EntryPoint::GLBlendColor, red, green, blue, alpha)));
248 if (isCallValid)
249 {
250 ContextPrivateBlendColor(context->getMutablePrivateState(),
251 context->getMutablePrivateStateCache(), red, green, blue,
252 alpha);
253 }
254 ANGLE_CAPTURE_GL(BlendColor, isCallValid, context, red, green, blue, alpha);
255 }
256 else
257 {
258 GenerateContextLostErrorOnCurrentGlobalContext();
259 }
260 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
261 }
262
GL_BlendEquation(GLenum mode)263 void GL_APIENTRY GL_BlendEquation(GLenum mode)
264 {
265 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
266 Context *context = GetValidGlobalContext();
267 EVENT(context, GLBlendEquation, "context = %d, mode = %s", CID(context),
268 GLenumToString(GLESEnum::BlendEquationModeEXT, mode));
269
270 if (context)
271 {
272 bool isCallValid = (context->skipValidation() ||
273 ValidateBlendEquation(context->getPrivateState(),
274 context->getMutableErrorSetForValidation(),
275 angle::EntryPoint::GLBlendEquation, mode));
276 if (isCallValid)
277 {
278 ContextPrivateBlendEquation(context->getMutablePrivateState(),
279 context->getMutablePrivateStateCache(), mode);
280 }
281 ANGLE_CAPTURE_GL(BlendEquation, isCallValid, context, mode);
282 }
283 else
284 {
285 GenerateContextLostErrorOnCurrentGlobalContext();
286 }
287 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
288 }
289
GL_BlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)290 void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
291 {
292 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
293 Context *context = GetValidGlobalContext();
294 EVENT(context, GLBlendEquationSeparate, "context = %d, modeRGB = %s, modeAlpha = %s",
295 CID(context), GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB),
296 GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha));
297
298 if (context)
299 {
300 bool isCallValid =
301 (context->skipValidation() ||
302 ValidateBlendEquationSeparate(
303 context->getPrivateState(), context->getMutableErrorSetForValidation(),
304 angle::EntryPoint::GLBlendEquationSeparate, modeRGB, modeAlpha));
305 if (isCallValid)
306 {
307 ContextPrivateBlendEquationSeparate(context->getMutablePrivateState(),
308 context->getMutablePrivateStateCache(), modeRGB,
309 modeAlpha);
310 }
311 ANGLE_CAPTURE_GL(BlendEquationSeparate, isCallValid, context, modeRGB, modeAlpha);
312 }
313 else
314 {
315 GenerateContextLostErrorOnCurrentGlobalContext();
316 }
317 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
318 }
319
GL_BlendFunc(GLenum sfactor,GLenum dfactor)320 void GL_APIENTRY GL_BlendFunc(GLenum sfactor, GLenum dfactor)
321 {
322 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
323 Context *context = GetValidGlobalContext();
324 EVENT(context, GLBlendFunc, "context = %d, sfactor = %s, dfactor = %s", CID(context),
325 GLenumToString(GLESEnum::BlendingFactor, sfactor),
326 GLenumToString(GLESEnum::BlendingFactor, dfactor));
327
328 if (context)
329 {
330 bool isCallValid = (context->skipValidation() ||
331 ValidateBlendFunc(context->getPrivateState(),
332 context->getMutableErrorSetForValidation(),
333 angle::EntryPoint::GLBlendFunc, sfactor, dfactor));
334 if (isCallValid)
335 {
336 ContextPrivateBlendFunc(context->getMutablePrivateState(),
337 context->getMutablePrivateStateCache(), sfactor, dfactor);
338 }
339 ANGLE_CAPTURE_GL(BlendFunc, isCallValid, context, sfactor, dfactor);
340 }
341 else
342 {
343 GenerateContextLostErrorOnCurrentGlobalContext();
344 }
345 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
346 }
347
GL_BlendFuncSeparate(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha)348 void GL_APIENTRY GL_BlendFuncSeparate(GLenum sfactorRGB,
349 GLenum dfactorRGB,
350 GLenum sfactorAlpha,
351 GLenum dfactorAlpha)
352 {
353 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
354 Context *context = GetValidGlobalContext();
355 EVENT(context, GLBlendFuncSeparate,
356 "context = %d, sfactorRGB = %s, dfactorRGB = %s, sfactorAlpha = %s, dfactorAlpha = %s",
357 CID(context), GLenumToString(GLESEnum::BlendingFactor, sfactorRGB),
358 GLenumToString(GLESEnum::BlendingFactor, dfactorRGB),
359 GLenumToString(GLESEnum::BlendingFactor, sfactorAlpha),
360 GLenumToString(GLESEnum::BlendingFactor, dfactorAlpha));
361
362 if (context)
363 {
364 bool isCallValid =
365 (context->skipValidation() ||
366 ValidateBlendFuncSeparate(context->getPrivateState(),
367 context->getMutableErrorSetForValidation(),
368 angle::EntryPoint::GLBlendFuncSeparate, sfactorRGB,
369 dfactorRGB, sfactorAlpha, dfactorAlpha));
370 if (isCallValid)
371 {
372 ContextPrivateBlendFuncSeparate(context->getMutablePrivateState(),
373 context->getMutablePrivateStateCache(), sfactorRGB,
374 dfactorRGB, sfactorAlpha, dfactorAlpha);
375 }
376 ANGLE_CAPTURE_GL(BlendFuncSeparate, isCallValid, context, sfactorRGB, dfactorRGB,
377 sfactorAlpha, dfactorAlpha);
378 }
379 else
380 {
381 GenerateContextLostErrorOnCurrentGlobalContext();
382 }
383 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
384 }
385
GL_BufferData(GLenum target,GLsizeiptr size,const void * data,GLenum usage)386 void GL_APIENTRY GL_BufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
387 {
388 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
389 Context *context = GetValidGlobalContext();
390 EVENT(context, GLBufferData,
391 "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", usage = %s",
392 CID(context), GLenumToString(GLESEnum::BufferTargetARB, target),
393 static_cast<unsigned long long>(size), (uintptr_t)data,
394 GLenumToString(GLESEnum::BufferUsageARB, usage));
395
396 if (context)
397 {
398 BufferBinding targetPacked = PackParam<BufferBinding>(target);
399 BufferUsage usagePacked = PackParam<BufferUsage>(usage);
400 SCOPED_SHARE_CONTEXT_LOCK(context);
401 bool isCallValid = (context->skipValidation() ||
402 ValidateBufferData(context, angle::EntryPoint::GLBufferData,
403 targetPacked, size, data, usagePacked));
404 if (isCallValid)
405 {
406 context->bufferData(targetPacked, size, data, usagePacked);
407 }
408 ANGLE_CAPTURE_GL(BufferData, isCallValid, context, targetPacked, size, data, usagePacked);
409 }
410 else
411 {
412 GenerateContextLostErrorOnCurrentGlobalContext();
413 }
414 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
415 }
416
GL_BufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const void * data)417 void GL_APIENTRY GL_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
418 {
419 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
420 Context *context = GetValidGlobalContext();
421 EVENT(context, GLBufferSubData,
422 "context = %d, target = %s, offset = %llu, size = %llu, data = 0x%016" PRIxPTR "",
423 CID(context), GLenumToString(GLESEnum::BufferTargetARB, target),
424 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
425 (uintptr_t)data);
426
427 if (context)
428 {
429 BufferBinding targetPacked = PackParam<BufferBinding>(target);
430 SCOPED_SHARE_CONTEXT_LOCK(context);
431 bool isCallValid = (context->skipValidation() ||
432 ValidateBufferSubData(context, angle::EntryPoint::GLBufferSubData,
433 targetPacked, offset, size, data));
434 if (isCallValid)
435 {
436 context->bufferSubData(targetPacked, offset, size, data);
437 }
438 ANGLE_CAPTURE_GL(BufferSubData, isCallValid, context, targetPacked, offset, size, data);
439 }
440 else
441 {
442 GenerateContextLostErrorOnCurrentGlobalContext();
443 }
444 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
445 }
446
GL_CheckFramebufferStatus(GLenum target)447 GLenum GL_APIENTRY GL_CheckFramebufferStatus(GLenum target)
448 {
449 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
450 Context *context = GetValidGlobalContext();
451 EVENT(context, GLCheckFramebufferStatus, "context = %d, target = %s", CID(context),
452 GLenumToString(GLESEnum::FramebufferTarget, target));
453
454 GLenum returnValue;
455 if (context)
456 {
457 SCOPED_SHARE_CONTEXT_LOCK(context);
458 bool isCallValid = (context->skipValidation() ||
459 ValidateCheckFramebufferStatus(
460 context, angle::EntryPoint::GLCheckFramebufferStatus, target));
461 if (isCallValid)
462 {
463 returnValue = context->checkFramebufferStatus(target);
464 }
465 else
466 {
467 returnValue =
468 GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatus, GLenum>();
469 }
470 ANGLE_CAPTURE_GL(CheckFramebufferStatus, isCallValid, context, target, returnValue);
471 }
472 else
473 {
474 GenerateContextLostErrorOnCurrentGlobalContext();
475 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatus, GLenum>();
476 }
477 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
478 return returnValue;
479 }
480
GL_Clear(GLbitfield mask)481 void GL_APIENTRY GL_Clear(GLbitfield mask)
482 {
483 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
484 Context *context = GetValidGlobalContext();
485 EVENT(context, GLClear, "context = %d, mask = %s", CID(context),
486 GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str());
487
488 if (context)
489 {
490 SCOPED_SHARE_CONTEXT_LOCK(context);
491 bool isCallValid =
492 (context->skipValidation() ||
493 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
494 context->getMutableErrorSetForValidation(),
495 angle::EntryPoint::GLClear) &&
496 ValidateClear(context, angle::EntryPoint::GLClear, mask)));
497 if (isCallValid)
498 {
499 context->clear(mask);
500 }
501 ANGLE_CAPTURE_GL(Clear, isCallValid, context, mask);
502 }
503 else
504 {
505 GenerateContextLostErrorOnCurrentGlobalContext();
506 }
507 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
508 }
509
GL_ClearColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)510 void GL_APIENTRY GL_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
511 {
512 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
513 Context *context = GetValidGlobalContext();
514 EVENT(context, GLClearColor, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
515 CID(context), red, green, blue, alpha);
516
517 if (context)
518 {
519 bool isCallValid =
520 (context->skipValidation() ||
521 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
522 context->getMutableErrorSetForValidation(),
523 angle::EntryPoint::GLClearColor) &&
524 ValidateClearColor(context->getPrivateState(),
525 context->getMutableErrorSetForValidation(),
526 angle::EntryPoint::GLClearColor, red, green, blue, alpha)));
527 if (isCallValid)
528 {
529 ContextPrivateClearColor(context->getMutablePrivateState(),
530 context->getMutablePrivateStateCache(), red, green, blue,
531 alpha);
532 }
533 ANGLE_CAPTURE_GL(ClearColor, isCallValid, context, red, green, blue, alpha);
534 }
535 else
536 {
537 GenerateContextLostErrorOnCurrentGlobalContext();
538 }
539 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
540 }
541
GL_ClearDepthf(GLfloat d)542 void GL_APIENTRY GL_ClearDepthf(GLfloat d)
543 {
544 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
545 Context *context = GetValidGlobalContext();
546 EVENT(context, GLClearDepthf, "context = %d, d = %f", CID(context), d);
547
548 if (context)
549 {
550 bool isCallValid =
551 (context->skipValidation() ||
552 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
553 context->getMutableErrorSetForValidation(),
554 angle::EntryPoint::GLClearDepthf) &&
555 ValidateClearDepthf(context->getPrivateState(),
556 context->getMutableErrorSetForValidation(),
557 angle::EntryPoint::GLClearDepthf, d)));
558 if (isCallValid)
559 {
560 ContextPrivateClearDepthf(context->getMutablePrivateState(),
561 context->getMutablePrivateStateCache(), d);
562 }
563 ANGLE_CAPTURE_GL(ClearDepthf, isCallValid, context, d);
564 }
565 else
566 {
567 GenerateContextLostErrorOnCurrentGlobalContext();
568 }
569 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
570 }
571
GL_ClearStencil(GLint s)572 void GL_APIENTRY GL_ClearStencil(GLint s)
573 {
574 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
575 Context *context = GetValidGlobalContext();
576 EVENT(context, GLClearStencil, "context = %d, s = %d", CID(context), s);
577
578 if (context)
579 {
580 bool isCallValid =
581 (context->skipValidation() ||
582 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
583 context->getMutableErrorSetForValidation(),
584 angle::EntryPoint::GLClearStencil) &&
585 ValidateClearStencil(context->getPrivateState(),
586 context->getMutableErrorSetForValidation(),
587 angle::EntryPoint::GLClearStencil, s)));
588 if (isCallValid)
589 {
590 ContextPrivateClearStencil(context->getMutablePrivateState(),
591 context->getMutablePrivateStateCache(), s);
592 }
593 ANGLE_CAPTURE_GL(ClearStencil, isCallValid, context, s);
594 }
595 else
596 {
597 GenerateContextLostErrorOnCurrentGlobalContext();
598 }
599 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
600 }
601
GL_ColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)602 void GL_APIENTRY GL_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
603 {
604 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
605 Context *context = GetValidGlobalContext();
606 EVENT(context, GLColorMask, "context = %d, red = %s, green = %s, blue = %s, alpha = %s",
607 CID(context), GLbooleanToString(red), GLbooleanToString(green), GLbooleanToString(blue),
608 GLbooleanToString(alpha));
609
610 if (context)
611 {
612 bool isCallValid =
613 (context->skipValidation() ||
614 ValidateColorMask(context->getPrivateState(),
615 context->getMutableErrorSetForValidation(),
616 angle::EntryPoint::GLColorMask, red, green, blue, alpha));
617 if (isCallValid)
618 {
619 ContextPrivateColorMask(context->getMutablePrivateState(),
620 context->getMutablePrivateStateCache(), red, green, blue,
621 alpha);
622 }
623 ANGLE_CAPTURE_GL(ColorMask, isCallValid, context, red, green, blue, alpha);
624 }
625 else
626 {
627 GenerateContextLostErrorOnCurrentGlobalContext();
628 }
629 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
630 }
631
GL_CompileShader(GLuint shader)632 void GL_APIENTRY GL_CompileShader(GLuint shader)
633 {
634 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
635 Context *context = GetValidGlobalContext();
636 EVENT(context, GLCompileShader, "context = %d, shader = %u", CID(context), shader);
637
638 if (context)
639 {
640 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
641 SCOPED_SHARE_CONTEXT_LOCK(context);
642 bool isCallValid =
643 (context->skipValidation() ||
644 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
645 context->getMutableErrorSetForValidation(),
646 angle::EntryPoint::GLCompileShader) &&
647 ValidateCompileShader(context, angle::EntryPoint::GLCompileShader, shaderPacked)));
648 if (isCallValid)
649 {
650 context->compileShader(shaderPacked);
651 }
652 ANGLE_CAPTURE_GL(CompileShader, isCallValid, context, shaderPacked);
653 }
654 else
655 {
656 GenerateContextLostErrorOnCurrentGlobalContext();
657 }
658 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
659 }
660
GL_CompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void * data)661 void GL_APIENTRY GL_CompressedTexImage2D(GLenum target,
662 GLint level,
663 GLenum internalformat,
664 GLsizei width,
665 GLsizei height,
666 GLint border,
667 GLsizei imageSize,
668 const void *data)
669 {
670 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
671 Context *context = GetValidGlobalContext();
672 EVENT(context, GLCompressedTexImage2D,
673 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
674 "border = %d, imageSize = %d, data = 0x%016" PRIxPTR "",
675 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
676 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, border,
677 imageSize, (uintptr_t)data);
678
679 if (context)
680 {
681 TextureTarget targetPacked = PackParam<TextureTarget>(target);
682 SCOPED_SHARE_CONTEXT_LOCK(context);
683 bool isCallValid =
684 (context->skipValidation() ||
685 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
686 context->getMutableErrorSetForValidation(),
687 angle::EntryPoint::GLCompressedTexImage2D) &&
688 ValidateCompressedTexImage2D(context, angle::EntryPoint::GLCompressedTexImage2D,
689 targetPacked, level, internalformat, width, height,
690 border, imageSize, data)));
691 if (isCallValid)
692 {
693 context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
694 border, imageSize, data);
695 }
696 ANGLE_CAPTURE_GL(CompressedTexImage2D, isCallValid, context, targetPacked, level,
697 internalformat, width, height, border, imageSize, data);
698 }
699 else
700 {
701 GenerateContextLostErrorOnCurrentGlobalContext();
702 }
703 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
704 }
705
GL_CompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void * data)706 void GL_APIENTRY GL_CompressedTexSubImage2D(GLenum target,
707 GLint level,
708 GLint xoffset,
709 GLint yoffset,
710 GLsizei width,
711 GLsizei height,
712 GLenum format,
713 GLsizei imageSize,
714 const void *data)
715 {
716 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
717 Context *context = GetValidGlobalContext();
718 EVENT(context, GLCompressedTexSubImage2D,
719 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
720 "%d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "",
721 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset,
722 width, height, GLenumToString(GLESEnum::InternalFormat, format), imageSize,
723 (uintptr_t)data);
724
725 if (context)
726 {
727 TextureTarget targetPacked = PackParam<TextureTarget>(target);
728 SCOPED_SHARE_CONTEXT_LOCK(context);
729 bool isCallValid =
730 (context->skipValidation() ||
731 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
732 context->getMutableErrorSetForValidation(),
733 angle::EntryPoint::GLCompressedTexSubImage2D) &&
734 ValidateCompressedTexSubImage2D(context, angle::EntryPoint::GLCompressedTexSubImage2D,
735 targetPacked, level, xoffset, yoffset, width, height,
736 format, imageSize, data)));
737 if (isCallValid)
738 {
739 context->compressedTexSubImage2D(targetPacked, level, xoffset, yoffset, width, height,
740 format, imageSize, data);
741 }
742 ANGLE_CAPTURE_GL(CompressedTexSubImage2D, isCallValid, context, targetPacked, level,
743 xoffset, yoffset, width, height, format, imageSize, data);
744 }
745 else
746 {
747 GenerateContextLostErrorOnCurrentGlobalContext();
748 }
749 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
750 }
751
GL_CopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)752 void GL_APIENTRY GL_CopyTexImage2D(GLenum target,
753 GLint level,
754 GLenum internalformat,
755 GLint x,
756 GLint y,
757 GLsizei width,
758 GLsizei height,
759 GLint border)
760 {
761 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
762 Context *context = GetValidGlobalContext();
763 EVENT(context, GLCopyTexImage2D,
764 "context = %d, target = %s, level = %d, internalformat = %s, x = %d, y = %d, width = %d, "
765 "height = %d, border = %d",
766 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
767 GLenumToString(GLESEnum::InternalFormat, internalformat), x, y, width, height, border);
768
769 if (context)
770 {
771 TextureTarget targetPacked = PackParam<TextureTarget>(target);
772 SCOPED_SHARE_CONTEXT_LOCK(context);
773 bool isCallValid =
774 (context->skipValidation() ||
775 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
776 context->getMutableErrorSetForValidation(),
777 angle::EntryPoint::GLCopyTexImage2D) &&
778 ValidateCopyTexImage2D(context, angle::EntryPoint::GLCopyTexImage2D, targetPacked,
779 level, internalformat, x, y, width, height, border)));
780 if (isCallValid)
781 {
782 context->copyTexImage2D(targetPacked, level, internalformat, x, y, width, height,
783 border);
784 }
785 ANGLE_CAPTURE_GL(CopyTexImage2D, isCallValid, context, targetPacked, level, internalformat,
786 x, y, width, height, border);
787 }
788 else
789 {
790 GenerateContextLostErrorOnCurrentGlobalContext();
791 }
792 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
793 }
794
GL_CopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)795 void GL_APIENTRY GL_CopyTexSubImage2D(GLenum target,
796 GLint level,
797 GLint xoffset,
798 GLint yoffset,
799 GLint x,
800 GLint y,
801 GLsizei width,
802 GLsizei height)
803 {
804 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
805 Context *context = GetValidGlobalContext();
806 EVENT(context, GLCopyTexSubImage2D,
807 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, x = %d, y = %d, "
808 "width = %d, height = %d",
809 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, x,
810 y, width, height);
811
812 if (context)
813 {
814 TextureTarget targetPacked = PackParam<TextureTarget>(target);
815 SCOPED_SHARE_CONTEXT_LOCK(context);
816 bool isCallValid =
817 (context->skipValidation() ||
818 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
819 context->getMutableErrorSetForValidation(),
820 angle::EntryPoint::GLCopyTexSubImage2D) &&
821 ValidateCopyTexSubImage2D(context, angle::EntryPoint::GLCopyTexSubImage2D,
822 targetPacked, level, xoffset, yoffset, x, y, width,
823 height)));
824 if (isCallValid)
825 {
826 context->copyTexSubImage2D(targetPacked, level, xoffset, yoffset, x, y, width, height);
827 }
828 ANGLE_CAPTURE_GL(CopyTexSubImage2D, isCallValid, context, targetPacked, level, xoffset,
829 yoffset, x, y, width, height);
830 }
831 else
832 {
833 GenerateContextLostErrorOnCurrentGlobalContext();
834 }
835 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
836 }
837
GL_CreateProgram()838 GLuint GL_APIENTRY GL_CreateProgram()
839 {
840 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
841 Context *context = GetValidGlobalContext();
842 EVENT(context, GLCreateProgram, "context = %d", CID(context));
843
844 GLuint returnValue;
845 if (context)
846 {
847 SCOPED_SHARE_CONTEXT_LOCK(context);
848 bool isCallValid =
849 (context->skipValidation() ||
850 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
851 context->getMutableErrorSetForValidation(),
852 angle::EntryPoint::GLCreateProgram) &&
853 ValidateCreateProgram(context, angle::EntryPoint::GLCreateProgram)));
854 if (isCallValid)
855 {
856 returnValue = context->createProgram();
857 }
858 else
859 {
860 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
861 }
862 ANGLE_CAPTURE_GL(CreateProgram, isCallValid, context, returnValue);
863 }
864 else
865 {
866 GenerateContextLostErrorOnCurrentGlobalContext();
867 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
868 }
869 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
870 return returnValue;
871 }
872
GL_CreateShader(GLenum type)873 GLuint GL_APIENTRY GL_CreateShader(GLenum type)
874 {
875 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
876 Context *context = GetValidGlobalContext();
877 EVENT(context, GLCreateShader, "context = %d, type = %s", CID(context),
878 GLenumToString(GLESEnum::ShaderType, type));
879
880 GLuint returnValue;
881 if (context)
882 {
883 ShaderType typePacked = PackParam<ShaderType>(type);
884 SCOPED_SHARE_CONTEXT_LOCK(context);
885 bool isCallValid =
886 (context->skipValidation() ||
887 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
888 context->getMutableErrorSetForValidation(),
889 angle::EntryPoint::GLCreateShader) &&
890 ValidateCreateShader(context, angle::EntryPoint::GLCreateShader, typePacked)));
891 if (isCallValid)
892 {
893 returnValue = context->createShader(typePacked);
894 }
895 else
896 {
897 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
898 }
899 ANGLE_CAPTURE_GL(CreateShader, isCallValid, context, typePacked, returnValue);
900 }
901 else
902 {
903 GenerateContextLostErrorOnCurrentGlobalContext();
904 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
905 }
906 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
907 return returnValue;
908 }
909
GL_CullFace(GLenum mode)910 void GL_APIENTRY GL_CullFace(GLenum mode)
911 {
912 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
913 Context *context = GetValidGlobalContext();
914 EVENT(context, GLCullFace, "context = %d, mode = %s", CID(context),
915 GLenumToString(GLESEnum::TriangleFace, mode));
916
917 if (context)
918 {
919 CullFaceMode modePacked = PackParam<CullFaceMode>(mode);
920 bool isCallValid = (context->skipValidation() ||
921 ValidateCullFace(context->getPrivateState(),
922 context->getMutableErrorSetForValidation(),
923 angle::EntryPoint::GLCullFace, modePacked));
924 if (isCallValid)
925 {
926 ContextPrivateCullFace(context->getMutablePrivateState(),
927 context->getMutablePrivateStateCache(), modePacked);
928 }
929 ANGLE_CAPTURE_GL(CullFace, isCallValid, context, modePacked);
930 }
931 else
932 {
933 GenerateContextLostErrorOnCurrentGlobalContext();
934 }
935 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
936 }
937
GL_DeleteBuffers(GLsizei n,const GLuint * buffers)938 void GL_APIENTRY GL_DeleteBuffers(GLsizei n, const GLuint *buffers)
939 {
940 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
941 Context *context = GetValidGlobalContext();
942 EVENT(context, GLDeleteBuffers, "context = %d, n = %d, buffers = 0x%016" PRIxPTR "",
943 CID(context), n, (uintptr_t)buffers);
944
945 if (context)
946 {
947 const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
948 SCOPED_SHARE_CONTEXT_LOCK(context);
949 bool isCallValid =
950 (context->skipValidation() ||
951 ValidateDeleteBuffers(context, angle::EntryPoint::GLDeleteBuffers, n, buffersPacked));
952 if (isCallValid)
953 {
954 context->deleteBuffers(n, buffersPacked);
955 }
956 ANGLE_CAPTURE_GL(DeleteBuffers, isCallValid, context, n, buffersPacked);
957 }
958 else
959 {
960 GenerateContextLostErrorOnCurrentGlobalContext();
961 }
962 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
963 }
964
GL_DeleteFramebuffers(GLsizei n,const GLuint * framebuffers)965 void GL_APIENTRY GL_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
966 {
967 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
968 Context *context = GetValidGlobalContext();
969 EVENT(context, GLDeleteFramebuffers, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
970 CID(context), n, (uintptr_t)framebuffers);
971
972 if (context)
973 {
974 const FramebufferID *framebuffersPacked = PackParam<const FramebufferID *>(framebuffers);
975 SCOPED_SHARE_CONTEXT_LOCK(context);
976 bool isCallValid =
977 (context->skipValidation() ||
978 ValidateDeleteFramebuffers(context, angle::EntryPoint::GLDeleteFramebuffers, n,
979 framebuffersPacked));
980 if (isCallValid)
981 {
982 context->deleteFramebuffers(n, framebuffersPacked);
983 }
984 ANGLE_CAPTURE_GL(DeleteFramebuffers, isCallValid, context, n, framebuffersPacked);
985 }
986 else
987 {
988 GenerateContextLostErrorOnCurrentGlobalContext();
989 }
990 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
991 }
992
GL_DeleteProgram(GLuint program)993 void GL_APIENTRY GL_DeleteProgram(GLuint program)
994 {
995 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
996 Context *context = GetValidGlobalContext();
997 EVENT(context, GLDeleteProgram, "context = %d, program = %u", CID(context), program);
998
999 if (context)
1000 {
1001 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1002 SCOPED_SHARE_CONTEXT_LOCK(context);
1003 bool isCallValid =
1004 (context->skipValidation() ||
1005 ValidateDeleteProgram(context, angle::EntryPoint::GLDeleteProgram, programPacked));
1006 if (isCallValid)
1007 {
1008 context->deleteProgram(programPacked);
1009 }
1010 ANGLE_CAPTURE_GL(DeleteProgram, isCallValid, context, programPacked);
1011 }
1012 else
1013 {
1014 GenerateContextLostErrorOnCurrentGlobalContext();
1015 }
1016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1017 }
1018
GL_DeleteRenderbuffers(GLsizei n,const GLuint * renderbuffers)1019 void GL_APIENTRY GL_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
1020 {
1021 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1022 Context *context = GetValidGlobalContext();
1023 EVENT(context, GLDeleteRenderbuffers, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
1024 CID(context), n, (uintptr_t)renderbuffers);
1025
1026 if (context)
1027 {
1028 const RenderbufferID *renderbuffersPacked =
1029 PackParam<const RenderbufferID *>(renderbuffers);
1030 SCOPED_SHARE_CONTEXT_LOCK(context);
1031 bool isCallValid =
1032 (context->skipValidation() ||
1033 ValidateDeleteRenderbuffers(context, angle::EntryPoint::GLDeleteRenderbuffers, n,
1034 renderbuffersPacked));
1035 if (isCallValid)
1036 {
1037 context->deleteRenderbuffers(n, renderbuffersPacked);
1038 }
1039 ANGLE_CAPTURE_GL(DeleteRenderbuffers, isCallValid, context, n, renderbuffersPacked);
1040 }
1041 else
1042 {
1043 GenerateContextLostErrorOnCurrentGlobalContext();
1044 }
1045 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1046 }
1047
GL_DeleteShader(GLuint shader)1048 void GL_APIENTRY GL_DeleteShader(GLuint shader)
1049 {
1050 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1051 Context *context = GetValidGlobalContext();
1052 EVENT(context, GLDeleteShader, "context = %d, shader = %u", CID(context), shader);
1053
1054 if (context)
1055 {
1056 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
1057 SCOPED_SHARE_CONTEXT_LOCK(context);
1058 bool isCallValid =
1059 (context->skipValidation() ||
1060 ValidateDeleteShader(context, angle::EntryPoint::GLDeleteShader, shaderPacked));
1061 if (isCallValid)
1062 {
1063 context->deleteShader(shaderPacked);
1064 }
1065 ANGLE_CAPTURE_GL(DeleteShader, isCallValid, context, shaderPacked);
1066 }
1067 else
1068 {
1069 GenerateContextLostErrorOnCurrentGlobalContext();
1070 }
1071 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1072 }
1073
GL_DeleteTextures(GLsizei n,const GLuint * textures)1074 void GL_APIENTRY GL_DeleteTextures(GLsizei n, const GLuint *textures)
1075 {
1076 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1077 Context *context = GetValidGlobalContext();
1078 EVENT(context, GLDeleteTextures, "context = %d, n = %d, textures = 0x%016" PRIxPTR "",
1079 CID(context), n, (uintptr_t)textures);
1080
1081 if (context)
1082 {
1083 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
1084 SCOPED_SHARE_CONTEXT_LOCK(context);
1085 bool isCallValid = (context->skipValidation() ||
1086 ValidateDeleteTextures(context, angle::EntryPoint::GLDeleteTextures, n,
1087 texturesPacked));
1088 if (isCallValid)
1089 {
1090 context->deleteTextures(n, texturesPacked);
1091 }
1092 ANGLE_CAPTURE_GL(DeleteTextures, isCallValid, context, n, texturesPacked);
1093 }
1094 else
1095 {
1096 GenerateContextLostErrorOnCurrentGlobalContext();
1097 }
1098 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1099 }
1100
GL_DepthFunc(GLenum func)1101 void GL_APIENTRY GL_DepthFunc(GLenum func)
1102 {
1103 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1104 Context *context = GetValidGlobalContext();
1105 EVENT(context, GLDepthFunc, "context = %d, func = %s", CID(context),
1106 GLenumToString(GLESEnum::DepthFunction, func));
1107
1108 if (context)
1109 {
1110 bool isCallValid = (context->skipValidation() ||
1111 ValidateDepthFunc(context->getPrivateState(),
1112 context->getMutableErrorSetForValidation(),
1113 angle::EntryPoint::GLDepthFunc, func));
1114 if (isCallValid)
1115 {
1116 ContextPrivateDepthFunc(context->getMutablePrivateState(),
1117 context->getMutablePrivateStateCache(), func);
1118 }
1119 ANGLE_CAPTURE_GL(DepthFunc, isCallValid, context, func);
1120 }
1121 else
1122 {
1123 GenerateContextLostErrorOnCurrentGlobalContext();
1124 }
1125 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1126 }
1127
GL_DepthMask(GLboolean flag)1128 void GL_APIENTRY GL_DepthMask(GLboolean flag)
1129 {
1130 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1131 Context *context = GetValidGlobalContext();
1132 EVENT(context, GLDepthMask, "context = %d, flag = %s", CID(context), GLbooleanToString(flag));
1133
1134 if (context)
1135 {
1136 bool isCallValid = (context->skipValidation() ||
1137 ValidateDepthMask(context->getPrivateState(),
1138 context->getMutableErrorSetForValidation(),
1139 angle::EntryPoint::GLDepthMask, flag));
1140 if (isCallValid)
1141 {
1142 ContextPrivateDepthMask(context->getMutablePrivateState(),
1143 context->getMutablePrivateStateCache(), flag);
1144 }
1145 ANGLE_CAPTURE_GL(DepthMask, isCallValid, context, flag);
1146 }
1147 else
1148 {
1149 GenerateContextLostErrorOnCurrentGlobalContext();
1150 }
1151 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1152 }
1153
GL_DepthRangef(GLfloat n,GLfloat f)1154 void GL_APIENTRY GL_DepthRangef(GLfloat n, GLfloat f)
1155 {
1156 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1157 Context *context = GetValidGlobalContext();
1158 EVENT(context, GLDepthRangef, "context = %d, n = %f, f = %f", CID(context), n, f);
1159
1160 if (context)
1161 {
1162 bool isCallValid = (context->skipValidation() ||
1163 ValidateDepthRangef(context->getPrivateState(),
1164 context->getMutableErrorSetForValidation(),
1165 angle::EntryPoint::GLDepthRangef, n, f));
1166 if (isCallValid)
1167 {
1168 ContextPrivateDepthRangef(context->getMutablePrivateState(),
1169 context->getMutablePrivateStateCache(), n, f);
1170 }
1171 ANGLE_CAPTURE_GL(DepthRangef, isCallValid, context, n, f);
1172 }
1173 else
1174 {
1175 GenerateContextLostErrorOnCurrentGlobalContext();
1176 }
1177 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1178 }
1179
GL_DetachShader(GLuint program,GLuint shader)1180 void GL_APIENTRY GL_DetachShader(GLuint program, GLuint shader)
1181 {
1182 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1183 Context *context = GetValidGlobalContext();
1184 EVENT(context, GLDetachShader, "context = %d, program = %u, shader = %u", CID(context), program,
1185 shader);
1186
1187 if (context)
1188 {
1189 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1190 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
1191 SCOPED_SHARE_CONTEXT_LOCK(context);
1192 bool isCallValid =
1193 (context->skipValidation() ||
1194 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1195 context->getMutableErrorSetForValidation(),
1196 angle::EntryPoint::GLDetachShader) &&
1197 ValidateDetachShader(context, angle::EntryPoint::GLDetachShader, programPacked,
1198 shaderPacked)));
1199 if (isCallValid)
1200 {
1201 context->detachShader(programPacked, shaderPacked);
1202 }
1203 ANGLE_CAPTURE_GL(DetachShader, isCallValid, context, programPacked, shaderPacked);
1204 }
1205 else
1206 {
1207 GenerateContextLostErrorOnCurrentGlobalContext();
1208 }
1209 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1210 }
1211
GL_Disable(GLenum cap)1212 void GL_APIENTRY GL_Disable(GLenum cap)
1213 {
1214 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1215 Context *context = GetValidGlobalContext();
1216 EVENT(context, GLDisable, "context = %d, cap = %s", CID(context),
1217 GLenumToString(GLESEnum::EnableCap, cap));
1218
1219 if (context)
1220 {
1221 bool isCallValid =
1222 (context->skipValidation() ||
1223 ValidateDisable(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1224 angle::EntryPoint::GLDisable, cap));
1225 if (isCallValid)
1226 {
1227 ContextPrivateDisable(context->getMutablePrivateState(),
1228 context->getMutablePrivateStateCache(), cap);
1229 }
1230 ANGLE_CAPTURE_GL(Disable, isCallValid, context, cap);
1231 }
1232 else
1233 {
1234 GenerateContextLostErrorOnCurrentGlobalContext();
1235 }
1236 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1237 }
1238
GL_DisableVertexAttribArray(GLuint index)1239 void GL_APIENTRY GL_DisableVertexAttribArray(GLuint index)
1240 {
1241 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1242 Context *context = GetValidGlobalContext();
1243 EVENT(context, GLDisableVertexAttribArray, "context = %d, index = %u", CID(context), index);
1244
1245 if (context)
1246 {
1247 SCOPED_SHARE_CONTEXT_LOCK(context);
1248 bool isCallValid = (context->skipValidation() ||
1249 ValidateDisableVertexAttribArray(
1250 context, angle::EntryPoint::GLDisableVertexAttribArray, index));
1251 if (isCallValid)
1252 {
1253 context->disableVertexAttribArray(index);
1254 }
1255 ANGLE_CAPTURE_GL(DisableVertexAttribArray, isCallValid, context, index);
1256 }
1257 else
1258 {
1259 GenerateContextLostErrorOnCurrentGlobalContext();
1260 }
1261 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1262 }
1263
GL_DrawArrays(GLenum mode,GLint first,GLsizei count)1264 void GL_APIENTRY GL_DrawArrays(GLenum mode, GLint first, GLsizei count)
1265 {
1266 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1267 Context *context = GetValidGlobalContext();
1268 EVENT(context, GLDrawArrays, "context = %d, mode = %s, first = %d, count = %d", CID(context),
1269 GLenumToString(GLESEnum::PrimitiveType, mode), first, count);
1270
1271 if (context)
1272 {
1273 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1274 SCOPED_SHARE_CONTEXT_LOCK(context);
1275 bool isCallValid = (context->skipValidation() ||
1276 ValidateDrawArrays(context, angle::EntryPoint::GLDrawArrays, modePacked,
1277 first, count));
1278 if (isCallValid)
1279 {
1280 context->drawArrays(modePacked, first, count);
1281 }
1282 ANGLE_CAPTURE_GL(DrawArrays, isCallValid, context, modePacked, first, count);
1283 }
1284 else
1285 {
1286 GenerateContextLostErrorOnCurrentGlobalContext();
1287 }
1288 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1289 }
1290
GL_DrawElements(GLenum mode,GLsizei count,GLenum type,const void * indices)1291 void GL_APIENTRY GL_DrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
1292 {
1293 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1294 Context *context = GetValidGlobalContext();
1295 EVENT(context, GLDrawElements,
1296 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR "",
1297 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
1298 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices);
1299
1300 if (context)
1301 {
1302 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1303 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
1304 SCOPED_SHARE_CONTEXT_LOCK(context);
1305 bool isCallValid = (context->skipValidation() ||
1306 ValidateDrawElements(context, angle::EntryPoint::GLDrawElements,
1307 modePacked, count, typePacked, indices));
1308 if (isCallValid)
1309 {
1310 context->drawElements(modePacked, count, typePacked, indices);
1311 }
1312 ANGLE_CAPTURE_GL(DrawElements, isCallValid, context, modePacked, count, typePacked,
1313 indices);
1314 }
1315 else
1316 {
1317 GenerateContextLostErrorOnCurrentGlobalContext();
1318 }
1319 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1320 }
1321
GL_Enable(GLenum cap)1322 void GL_APIENTRY GL_Enable(GLenum cap)
1323 {
1324 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1325 Context *context = GetValidGlobalContext();
1326 EVENT(context, GLEnable, "context = %d, cap = %s", CID(context),
1327 GLenumToString(GLESEnum::EnableCap, cap));
1328
1329 if (context)
1330 {
1331 bool isCallValid =
1332 (context->skipValidation() ||
1333 ValidateEnable(context->getPrivateState(), context->getMutableErrorSetForValidation(),
1334 angle::EntryPoint::GLEnable, cap));
1335 if (isCallValid)
1336 {
1337 ContextPrivateEnable(context->getMutablePrivateState(),
1338 context->getMutablePrivateStateCache(), cap);
1339 }
1340 ANGLE_CAPTURE_GL(Enable, isCallValid, context, cap);
1341 }
1342 else
1343 {
1344 GenerateContextLostErrorOnCurrentGlobalContext();
1345 }
1346 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1347 }
1348
GL_EnableVertexAttribArray(GLuint index)1349 void GL_APIENTRY GL_EnableVertexAttribArray(GLuint index)
1350 {
1351 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1352 Context *context = GetValidGlobalContext();
1353 EVENT(context, GLEnableVertexAttribArray, "context = %d, index = %u", CID(context), index);
1354
1355 if (context)
1356 {
1357 SCOPED_SHARE_CONTEXT_LOCK(context);
1358 bool isCallValid = (context->skipValidation() ||
1359 ValidateEnableVertexAttribArray(
1360 context, angle::EntryPoint::GLEnableVertexAttribArray, index));
1361 if (isCallValid)
1362 {
1363 context->enableVertexAttribArray(index);
1364 }
1365 ANGLE_CAPTURE_GL(EnableVertexAttribArray, isCallValid, context, index);
1366 }
1367 else
1368 {
1369 GenerateContextLostErrorOnCurrentGlobalContext();
1370 }
1371 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1372 }
1373
GL_Finish()1374 void GL_APIENTRY GL_Finish()
1375 {
1376 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1377 Context *context = GetValidGlobalContext();
1378 EVENT(context, GLFinish, "context = %d", CID(context));
1379
1380 if (context)
1381 {
1382 SCOPED_SHARE_CONTEXT_LOCK(context);
1383 bool isCallValid =
1384 (context->skipValidation() ||
1385 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1386 context->getMutableErrorSetForValidation(),
1387 angle::EntryPoint::GLFinish) &&
1388 ValidateFinish(context, angle::EntryPoint::GLFinish)));
1389 if (isCallValid)
1390 {
1391 context->finish();
1392 }
1393 ANGLE_CAPTURE_GL(Finish, isCallValid, context);
1394 }
1395 else
1396 {
1397 GenerateContextLostErrorOnCurrentGlobalContext();
1398 }
1399 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
1400 }
1401
GL_Flush()1402 void GL_APIENTRY GL_Flush()
1403 {
1404 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1405 Context *context = GetValidGlobalContext();
1406 EVENT(context, GLFlush, "context = %d", CID(context));
1407
1408 if (context)
1409 {
1410 SCOPED_SHARE_CONTEXT_LOCK(context);
1411 bool isCallValid =
1412 (context->skipValidation() ||
1413 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1414 context->getMutableErrorSetForValidation(),
1415 angle::EntryPoint::GLFlush) &&
1416 ValidateFlush(context, angle::EntryPoint::GLFlush)));
1417 if (isCallValid)
1418 {
1419 context->flush();
1420 }
1421 ANGLE_CAPTURE_GL(Flush, isCallValid, context);
1422 }
1423 else
1424 {
1425 GenerateContextLostErrorOnCurrentGlobalContext();
1426 }
1427 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
1428 }
1429
GL_FramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)1430 void GL_APIENTRY GL_FramebufferRenderbuffer(GLenum target,
1431 GLenum attachment,
1432 GLenum renderbuffertarget,
1433 GLuint renderbuffer)
1434 {
1435 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1436 Context *context = GetValidGlobalContext();
1437 EVENT(context, GLFramebufferRenderbuffer,
1438 "context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u",
1439 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
1440 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
1441 GLenumToString(GLESEnum::RenderbufferTarget, renderbuffertarget), renderbuffer);
1442
1443 if (context)
1444 {
1445 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
1446 SCOPED_SHARE_CONTEXT_LOCK(context);
1447 bool isCallValid = (context->skipValidation() ||
1448 ValidateFramebufferRenderbuffer(
1449 context, angle::EntryPoint::GLFramebufferRenderbuffer, target,
1450 attachment, renderbuffertarget, renderbufferPacked));
1451 if (isCallValid)
1452 {
1453 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
1454 renderbufferPacked);
1455 }
1456 ANGLE_CAPTURE_GL(FramebufferRenderbuffer, isCallValid, context, target, attachment,
1457 renderbuffertarget, renderbufferPacked);
1458 }
1459 else
1460 {
1461 GenerateContextLostErrorOnCurrentGlobalContext();
1462 }
1463 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1464 }
1465
GL_FramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)1466 void GL_APIENTRY GL_FramebufferTexture2D(GLenum target,
1467 GLenum attachment,
1468 GLenum textarget,
1469 GLuint texture,
1470 GLint level)
1471 {
1472 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1473 Context *context = GetValidGlobalContext();
1474 EVENT(context, GLFramebufferTexture2D,
1475 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
1476 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
1477 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
1478 GLenumToString(GLESEnum::TextureTarget, textarget), texture, level);
1479
1480 if (context)
1481 {
1482 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
1483 TextureID texturePacked = PackParam<TextureID>(texture);
1484 SCOPED_SHARE_CONTEXT_LOCK(context);
1485 bool isCallValid = (context->skipValidation() ||
1486 ValidateFramebufferTexture2D(
1487 context, angle::EntryPoint::GLFramebufferTexture2D, target,
1488 attachment, textargetPacked, texturePacked, level));
1489 if (isCallValid)
1490 {
1491 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
1492 level);
1493 }
1494 ANGLE_CAPTURE_GL(FramebufferTexture2D, isCallValid, context, target, attachment,
1495 textargetPacked, texturePacked, level);
1496 }
1497 else
1498 {
1499 GenerateContextLostErrorOnCurrentGlobalContext();
1500 }
1501 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1502 }
1503
GL_FrontFace(GLenum mode)1504 void GL_APIENTRY GL_FrontFace(GLenum mode)
1505 {
1506 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1507 Context *context = GetValidGlobalContext();
1508 EVENT(context, GLFrontFace, "context = %d, mode = %s", CID(context),
1509 GLenumToString(GLESEnum::FrontFaceDirection, mode));
1510
1511 if (context)
1512 {
1513 bool isCallValid = (context->skipValidation() ||
1514 ValidateFrontFace(context->getPrivateState(),
1515 context->getMutableErrorSetForValidation(),
1516 angle::EntryPoint::GLFrontFace, mode));
1517 if (isCallValid)
1518 {
1519 ContextPrivateFrontFace(context->getMutablePrivateState(),
1520 context->getMutablePrivateStateCache(), mode);
1521 }
1522 ANGLE_CAPTURE_GL(FrontFace, isCallValid, context, mode);
1523 }
1524 else
1525 {
1526 GenerateContextLostErrorOnCurrentGlobalContext();
1527 }
1528 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1529 }
1530
GL_GenBuffers(GLsizei n,GLuint * buffers)1531 void GL_APIENTRY GL_GenBuffers(GLsizei n, GLuint *buffers)
1532 {
1533 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1534 Context *context = GetValidGlobalContext();
1535 EVENT(context, GLGenBuffers, "context = %d, n = %d, buffers = 0x%016" PRIxPTR "", CID(context),
1536 n, (uintptr_t)buffers);
1537
1538 if (context)
1539 {
1540 BufferID *buffersPacked = PackParam<BufferID *>(buffers);
1541 SCOPED_SHARE_CONTEXT_LOCK(context);
1542 bool isCallValid =
1543 (context->skipValidation() ||
1544 ValidateGenBuffers(context, angle::EntryPoint::GLGenBuffers, n, buffersPacked));
1545 if (isCallValid)
1546 {
1547 context->genBuffers(n, buffersPacked);
1548 }
1549 ANGLE_CAPTURE_GL(GenBuffers, isCallValid, context, n, buffersPacked);
1550 }
1551 else
1552 {
1553 GenerateContextLostErrorOnCurrentGlobalContext();
1554 }
1555 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1556 }
1557
GL_GenFramebuffers(GLsizei n,GLuint * framebuffers)1558 void GL_APIENTRY GL_GenFramebuffers(GLsizei n, GLuint *framebuffers)
1559 {
1560 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1561 Context *context = GetValidGlobalContext();
1562 EVENT(context, GLGenFramebuffers, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
1563 CID(context), n, (uintptr_t)framebuffers);
1564
1565 if (context)
1566 {
1567 FramebufferID *framebuffersPacked = PackParam<FramebufferID *>(framebuffers);
1568 SCOPED_SHARE_CONTEXT_LOCK(context);
1569 bool isCallValid = (context->skipValidation() ||
1570 ValidateGenFramebuffers(context, angle::EntryPoint::GLGenFramebuffers,
1571 n, framebuffersPacked));
1572 if (isCallValid)
1573 {
1574 context->genFramebuffers(n, framebuffersPacked);
1575 }
1576 ANGLE_CAPTURE_GL(GenFramebuffers, isCallValid, context, n, framebuffersPacked);
1577 }
1578 else
1579 {
1580 GenerateContextLostErrorOnCurrentGlobalContext();
1581 }
1582 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1583 }
1584
GL_GenRenderbuffers(GLsizei n,GLuint * renderbuffers)1585 void GL_APIENTRY GL_GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
1586 {
1587 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1588 Context *context = GetValidGlobalContext();
1589 EVENT(context, GLGenRenderbuffers, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
1590 CID(context), n, (uintptr_t)renderbuffers);
1591
1592 if (context)
1593 {
1594 RenderbufferID *renderbuffersPacked = PackParam<RenderbufferID *>(renderbuffers);
1595 SCOPED_SHARE_CONTEXT_LOCK(context);
1596 bool isCallValid = (context->skipValidation() ||
1597 ValidateGenRenderbuffers(context, angle::EntryPoint::GLGenRenderbuffers,
1598 n, renderbuffersPacked));
1599 if (isCallValid)
1600 {
1601 context->genRenderbuffers(n, renderbuffersPacked);
1602 }
1603 ANGLE_CAPTURE_GL(GenRenderbuffers, isCallValid, context, n, renderbuffersPacked);
1604 }
1605 else
1606 {
1607 GenerateContextLostErrorOnCurrentGlobalContext();
1608 }
1609 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1610 }
1611
GL_GenTextures(GLsizei n,GLuint * textures)1612 void GL_APIENTRY GL_GenTextures(GLsizei n, GLuint *textures)
1613 {
1614 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1615 Context *context = GetValidGlobalContext();
1616 EVENT(context, GLGenTextures, "context = %d, n = %d, textures = 0x%016" PRIxPTR "",
1617 CID(context), n, (uintptr_t)textures);
1618
1619 if (context)
1620 {
1621 TextureID *texturesPacked = PackParam<TextureID *>(textures);
1622 SCOPED_SHARE_CONTEXT_LOCK(context);
1623 bool isCallValid =
1624 (context->skipValidation() ||
1625 ValidateGenTextures(context, angle::EntryPoint::GLGenTextures, n, texturesPacked));
1626 if (isCallValid)
1627 {
1628 context->genTextures(n, texturesPacked);
1629 }
1630 ANGLE_CAPTURE_GL(GenTextures, isCallValid, context, n, texturesPacked);
1631 }
1632 else
1633 {
1634 GenerateContextLostErrorOnCurrentGlobalContext();
1635 }
1636 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1637 }
1638
GL_GenerateMipmap(GLenum target)1639 void GL_APIENTRY GL_GenerateMipmap(GLenum target)
1640 {
1641 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1642 Context *context = GetValidGlobalContext();
1643 EVENT(context, GLGenerateMipmap, "context = %d, target = %s", CID(context),
1644 GLenumToString(GLESEnum::TextureTarget, target));
1645
1646 if (context)
1647 {
1648 TextureType targetPacked = PackParam<TextureType>(target);
1649 SCOPED_SHARE_CONTEXT_LOCK(context);
1650 bool isCallValid =
1651 (context->skipValidation() ||
1652 ValidateGenerateMipmap(context, angle::EntryPoint::GLGenerateMipmap, targetPacked));
1653 if (isCallValid)
1654 {
1655 context->generateMipmap(targetPacked);
1656 }
1657 ANGLE_CAPTURE_GL(GenerateMipmap, isCallValid, context, targetPacked);
1658 }
1659 else
1660 {
1661 GenerateContextLostErrorOnCurrentGlobalContext();
1662 }
1663 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1664 }
1665
GL_GetActiveAttrib(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)1666 void GL_APIENTRY GL_GetActiveAttrib(GLuint program,
1667 GLuint index,
1668 GLsizei bufSize,
1669 GLsizei *length,
1670 GLint *size,
1671 GLenum *type,
1672 GLchar *name)
1673 {
1674 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1675 Context *context = GetValidGlobalContext();
1676 EVENT(context, GLGetActiveAttrib,
1677 "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
1678 ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
1679 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
1680 (uintptr_t)type, (uintptr_t)name);
1681
1682 if (context)
1683 {
1684 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1685 SCOPED_SHARE_CONTEXT_LOCK(context);
1686 bool isCallValid =
1687 (context->skipValidation() ||
1688 ValidateGetActiveAttrib(context, angle::EntryPoint::GLGetActiveAttrib, programPacked,
1689 index, bufSize, length, size, type, name));
1690 if (isCallValid)
1691 {
1692 context->getActiveAttrib(programPacked, index, bufSize, length, size, type, name);
1693 }
1694 ANGLE_CAPTURE_GL(GetActiveAttrib, isCallValid, context, programPacked, index, bufSize,
1695 length, size, type, name);
1696 }
1697 else
1698 {
1699 GenerateContextLostErrorOnCurrentGlobalContext();
1700 }
1701 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1702 }
1703
GL_GetActiveUniform(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)1704 void GL_APIENTRY GL_GetActiveUniform(GLuint program,
1705 GLuint index,
1706 GLsizei bufSize,
1707 GLsizei *length,
1708 GLint *size,
1709 GLenum *type,
1710 GLchar *name)
1711 {
1712 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1713 Context *context = GetValidGlobalContext();
1714 EVENT(context, GLGetActiveUniform,
1715 "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
1716 ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
1717 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
1718 (uintptr_t)type, (uintptr_t)name);
1719
1720 if (context)
1721 {
1722 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1723 SCOPED_SHARE_CONTEXT_LOCK(context);
1724 bool isCallValid =
1725 (context->skipValidation() ||
1726 ValidateGetActiveUniform(context, angle::EntryPoint::GLGetActiveUniform, programPacked,
1727 index, bufSize, length, size, type, name));
1728 if (isCallValid)
1729 {
1730 context->getActiveUniform(programPacked, index, bufSize, length, size, type, name);
1731 }
1732 ANGLE_CAPTURE_GL(GetActiveUniform, isCallValid, context, programPacked, index, bufSize,
1733 length, size, type, name);
1734 }
1735 else
1736 {
1737 GenerateContextLostErrorOnCurrentGlobalContext();
1738 }
1739 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1740 }
1741
GL_GetAttachedShaders(GLuint program,GLsizei maxCount,GLsizei * count,GLuint * shaders)1742 void GL_APIENTRY GL_GetAttachedShaders(GLuint program,
1743 GLsizei maxCount,
1744 GLsizei *count,
1745 GLuint *shaders)
1746 {
1747 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1748 Context *context = GetValidGlobalContext();
1749 EVENT(context, GLGetAttachedShaders,
1750 "context = %d, program = %u, maxCount = %d, count = 0x%016" PRIxPTR
1751 ", shaders = 0x%016" PRIxPTR "",
1752 CID(context), program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
1753
1754 if (context)
1755 {
1756 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1757 ShaderProgramID *shadersPacked = PackParam<ShaderProgramID *>(shaders);
1758 SCOPED_SHARE_CONTEXT_LOCK(context);
1759 bool isCallValid =
1760 (context->skipValidation() ||
1761 ValidateGetAttachedShaders(context, angle::EntryPoint::GLGetAttachedShaders,
1762 programPacked, maxCount, count, shadersPacked));
1763 if (isCallValid)
1764 {
1765 context->getAttachedShaders(programPacked, maxCount, count, shadersPacked);
1766 }
1767 ANGLE_CAPTURE_GL(GetAttachedShaders, isCallValid, context, programPacked, maxCount, count,
1768 shadersPacked);
1769 }
1770 else
1771 {
1772 GenerateContextLostErrorOnCurrentGlobalContext();
1773 }
1774 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1775 }
1776
GL_GetAttribLocation(GLuint program,const GLchar * name)1777 GLint GL_APIENTRY GL_GetAttribLocation(GLuint program, const GLchar *name)
1778 {
1779 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1780 Context *context = GetValidGlobalContext();
1781 EVENT(context, GLGetAttribLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
1782 CID(context), program, (uintptr_t)name);
1783
1784 GLint returnValue;
1785 if (context)
1786 {
1787 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1788 SCOPED_SHARE_CONTEXT_LOCK(context);
1789 bool isCallValid =
1790 (context->skipValidation() ||
1791 ValidateGetAttribLocation(context, angle::EntryPoint::GLGetAttribLocation,
1792 programPacked, name));
1793 if (isCallValid)
1794 {
1795 returnValue = context->getAttribLocation(programPacked, name);
1796 }
1797 else
1798 {
1799 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
1800 }
1801 ANGLE_CAPTURE_GL(GetAttribLocation, isCallValid, context, programPacked, name, returnValue);
1802 }
1803 else
1804 {
1805 GenerateContextLostErrorOnCurrentGlobalContext();
1806 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
1807 }
1808 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1809 return returnValue;
1810 }
1811
GL_GetBooleanv(GLenum pname,GLboolean * data)1812 void GL_APIENTRY GL_GetBooleanv(GLenum pname, GLboolean *data)
1813 {
1814 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1815 Context *context = GetValidGlobalContext();
1816 EVENT(context, GLGetBooleanv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
1817 CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
1818
1819 if (context)
1820 {
1821 SCOPED_SHARE_CONTEXT_LOCK(context);
1822 bool isCallValid =
1823 (context->skipValidation() ||
1824 ValidateGetBooleanv(context, angle::EntryPoint::GLGetBooleanv, pname, data));
1825 if (isCallValid)
1826 {
1827 context->getBooleanv(pname, data);
1828 }
1829 ANGLE_CAPTURE_GL(GetBooleanv, isCallValid, context, pname, data);
1830 }
1831 else
1832 {
1833 GenerateContextLostErrorOnCurrentGlobalContext();
1834 }
1835 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1836 }
1837
GL_GetBufferParameteriv(GLenum target,GLenum pname,GLint * params)1838 void GL_APIENTRY GL_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
1839 {
1840 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1841 Context *context = GetValidGlobalContext();
1842 EVENT(context, GLGetBufferParameteriv,
1843 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1844 GLenumToString(GLESEnum::BufferTargetARB, target),
1845 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
1846
1847 if (context)
1848 {
1849 BufferBinding targetPacked = PackParam<BufferBinding>(target);
1850 SCOPED_SHARE_CONTEXT_LOCK(context);
1851 bool isCallValid =
1852 (context->skipValidation() ||
1853 ValidateGetBufferParameteriv(context, angle::EntryPoint::GLGetBufferParameteriv,
1854 targetPacked, pname, params));
1855 if (isCallValid)
1856 {
1857 context->getBufferParameteriv(targetPacked, pname, params);
1858 }
1859 ANGLE_CAPTURE_GL(GetBufferParameteriv, isCallValid, context, targetPacked, pname, params);
1860 }
1861 else
1862 {
1863 GenerateContextLostErrorOnCurrentGlobalContext();
1864 }
1865 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1866 }
1867
GL_GetError()1868 GLenum GL_APIENTRY GL_GetError()
1869 {
1870 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1871 Context *context = GetGlobalContext();
1872 EVENT(context, GLGetError, "context = %d", CID(context));
1873
1874 GLenum returnValue;
1875 if (context)
1876 {
1877 SCOPED_SHARE_CONTEXT_LOCK(context);
1878 bool isCallValid =
1879 (context->skipValidation() || ValidateGetError(context, angle::EntryPoint::GLGetError));
1880 if (isCallValid)
1881 {
1882 returnValue = context->getError();
1883 }
1884 else
1885 {
1886 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetError, GLenum>();
1887 }
1888 ANGLE_CAPTURE_GL(GetError, isCallValid, context, returnValue);
1889 }
1890 else
1891 {
1892
1893 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetError, GLenum>();
1894 }
1895 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1896 return returnValue;
1897 }
1898
GL_GetFloatv(GLenum pname,GLfloat * data)1899 void GL_APIENTRY GL_GetFloatv(GLenum pname, GLfloat *data)
1900 {
1901 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1902 Context *context = GetValidGlobalContext();
1903 EVENT(context, GLGetFloatv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", CID(context),
1904 GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
1905
1906 if (context)
1907 {
1908 SCOPED_SHARE_CONTEXT_LOCK(context);
1909 bool isCallValid =
1910 (context->skipValidation() ||
1911 ValidateGetFloatv(context, angle::EntryPoint::GLGetFloatv, pname, data));
1912 if (isCallValid)
1913 {
1914 context->getFloatv(pname, data);
1915 }
1916 ANGLE_CAPTURE_GL(GetFloatv, isCallValid, context, pname, data);
1917 }
1918 else
1919 {
1920 GenerateContextLostErrorOnCurrentGlobalContext();
1921 }
1922 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1923 }
1924
GL_GetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint * params)1925 void GL_APIENTRY GL_GetFramebufferAttachmentParameteriv(GLenum target,
1926 GLenum attachment,
1927 GLenum pname,
1928 GLint *params)
1929 {
1930 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1931 Context *context = GetValidGlobalContext();
1932 EVENT(context, GLGetFramebufferAttachmentParameteriv,
1933 "context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "",
1934 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
1935 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
1936 GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params);
1937
1938 if (context)
1939 {
1940 SCOPED_SHARE_CONTEXT_LOCK(context);
1941 bool isCallValid = (context->skipValidation() ||
1942 ValidateGetFramebufferAttachmentParameteriv(
1943 context, angle::EntryPoint::GLGetFramebufferAttachmentParameteriv,
1944 target, attachment, pname, params));
1945 if (isCallValid)
1946 {
1947 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
1948 }
1949 ANGLE_CAPTURE_GL(GetFramebufferAttachmentParameteriv, isCallValid, context, target,
1950 attachment, pname, params);
1951 }
1952 else
1953 {
1954 GenerateContextLostErrorOnCurrentGlobalContext();
1955 }
1956 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1957 }
1958
GL_GetIntegerv(GLenum pname,GLint * data)1959 void GL_APIENTRY GL_GetIntegerv(GLenum pname, GLint *data)
1960 {
1961 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1962 Context *context = GetValidGlobalContext();
1963 EVENT(context, GLGetIntegerv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
1964 CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
1965
1966 if (context)
1967 {
1968 SCOPED_SHARE_CONTEXT_LOCK(context);
1969 bool isCallValid =
1970 (context->skipValidation() ||
1971 ValidateGetIntegerv(context, angle::EntryPoint::GLGetIntegerv, pname, data));
1972 if (isCallValid)
1973 {
1974 context->getIntegerv(pname, data);
1975 }
1976 ANGLE_CAPTURE_GL(GetIntegerv, isCallValid, context, pname, data);
1977 }
1978 else
1979 {
1980 GenerateContextLostErrorOnCurrentGlobalContext();
1981 }
1982 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1983 }
1984
GL_GetProgramInfoLog(GLuint program,GLsizei bufSize,GLsizei * length,GLchar * infoLog)1985 void GL_APIENTRY GL_GetProgramInfoLog(GLuint program,
1986 GLsizei bufSize,
1987 GLsizei *length,
1988 GLchar *infoLog)
1989 {
1990 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1991 Context *context = GetValidGlobalContext();
1992 EVENT(context, GLGetProgramInfoLog,
1993 "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
1994 ", infoLog = 0x%016" PRIxPTR "",
1995 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
1996
1997 if (context)
1998 {
1999 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2000 SCOPED_SHARE_CONTEXT_LOCK(context);
2001 bool isCallValid =
2002 (context->skipValidation() ||
2003 ValidateGetProgramInfoLog(context, angle::EntryPoint::GLGetProgramInfoLog,
2004 programPacked, bufSize, length, infoLog));
2005 if (isCallValid)
2006 {
2007 context->getProgramInfoLog(programPacked, bufSize, length, infoLog);
2008 }
2009 ANGLE_CAPTURE_GL(GetProgramInfoLog, isCallValid, context, programPacked, bufSize, length,
2010 infoLog);
2011 }
2012 else
2013 {
2014 GenerateContextLostErrorOnCurrentGlobalContext();
2015 }
2016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2017 }
2018
GL_GetProgramiv(GLuint program,GLenum pname,GLint * params)2019 void GL_APIENTRY GL_GetProgramiv(GLuint program, GLenum pname, GLint *params)
2020 {
2021 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2022 Context *context = GetGlobalContext();
2023 EVENT(context, GLGetProgramiv,
2024 "context = %d, program = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2025 program, GLenumToString(GLESEnum::ProgramPropertyARB, pname), (uintptr_t)params);
2026
2027 if (context)
2028 {
2029 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2030 SCOPED_SHARE_CONTEXT_LOCK(context);
2031 bool isCallValid = (context->skipValidation() ||
2032 ValidateGetProgramiv(context, angle::EntryPoint::GLGetProgramiv,
2033 programPacked, pname, params));
2034 if (isCallValid)
2035 {
2036 context->getProgramiv(programPacked, pname, params);
2037 }
2038 ANGLE_CAPTURE_GL(GetProgramiv, isCallValid, context, programPacked, pname, params);
2039 }
2040 else
2041 {
2042 }
2043 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2044 }
2045
GL_GetRenderbufferParameteriv(GLenum target,GLenum pname,GLint * params)2046 void GL_APIENTRY GL_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
2047 {
2048 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2049 Context *context = GetValidGlobalContext();
2050 EVENT(context, GLGetRenderbufferParameteriv,
2051 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2052 GLenumToString(GLESEnum::RenderbufferTarget, target),
2053 GLenumToString(GLESEnum::RenderbufferParameterName, pname), (uintptr_t)params);
2054
2055 if (context)
2056 {
2057 SCOPED_SHARE_CONTEXT_LOCK(context);
2058 bool isCallValid =
2059 (context->skipValidation() ||
2060 ValidateGetRenderbufferParameteriv(
2061 context, angle::EntryPoint::GLGetRenderbufferParameteriv, target, pname, params));
2062 if (isCallValid)
2063 {
2064 context->getRenderbufferParameteriv(target, pname, params);
2065 }
2066 ANGLE_CAPTURE_GL(GetRenderbufferParameteriv, isCallValid, context, target, pname, params);
2067 }
2068 else
2069 {
2070 GenerateContextLostErrorOnCurrentGlobalContext();
2071 }
2072 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2073 }
2074
GL_GetShaderInfoLog(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * infoLog)2075 void GL_APIENTRY GL_GetShaderInfoLog(GLuint shader,
2076 GLsizei bufSize,
2077 GLsizei *length,
2078 GLchar *infoLog)
2079 {
2080 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2081 Context *context = GetValidGlobalContext();
2082 EVENT(context, GLGetShaderInfoLog,
2083 "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
2084 ", infoLog = 0x%016" PRIxPTR "",
2085 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
2086
2087 if (context)
2088 {
2089 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
2090 SCOPED_SHARE_CONTEXT_LOCK(context);
2091 bool isCallValid = (context->skipValidation() ||
2092 ValidateGetShaderInfoLog(context, angle::EntryPoint::GLGetShaderInfoLog,
2093 shaderPacked, bufSize, length, infoLog));
2094 if (isCallValid)
2095 {
2096 context->getShaderInfoLog(shaderPacked, bufSize, length, infoLog);
2097 }
2098 ANGLE_CAPTURE_GL(GetShaderInfoLog, isCallValid, context, shaderPacked, bufSize, length,
2099 infoLog);
2100 }
2101 else
2102 {
2103 GenerateContextLostErrorOnCurrentGlobalContext();
2104 }
2105 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2106 }
2107
GL_GetShaderPrecisionFormat(GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision)2108 void GL_APIENTRY GL_GetShaderPrecisionFormat(GLenum shadertype,
2109 GLenum precisiontype,
2110 GLint *range,
2111 GLint *precision)
2112 {
2113 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2114 Context *context = GetValidGlobalContext();
2115 EVENT(context, GLGetShaderPrecisionFormat,
2116 "context = %d, shadertype = %s, precisiontype = %s, range = 0x%016" PRIxPTR
2117 ", precision = 0x%016" PRIxPTR "",
2118 CID(context), GLenumToString(GLESEnum::ShaderType, shadertype),
2119 GLenumToString(GLESEnum::PrecisionType, precisiontype), (uintptr_t)range,
2120 (uintptr_t)precision);
2121
2122 if (context)
2123 {
2124 SCOPED_SHARE_CONTEXT_LOCK(context);
2125 bool isCallValid = (context->skipValidation() ||
2126 ValidateGetShaderPrecisionFormat(
2127 context, angle::EntryPoint::GLGetShaderPrecisionFormat, shadertype,
2128 precisiontype, range, precision));
2129 if (isCallValid)
2130 {
2131 context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
2132 }
2133 ANGLE_CAPTURE_GL(GetShaderPrecisionFormat, isCallValid, context, shadertype, precisiontype,
2134 range, precision);
2135 }
2136 else
2137 {
2138 GenerateContextLostErrorOnCurrentGlobalContext();
2139 }
2140 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2141 }
2142
GL_GetShaderSource(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source)2143 void GL_APIENTRY GL_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
2144 {
2145 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2146 Context *context = GetValidGlobalContext();
2147 EVENT(context, GLGetShaderSource,
2148 "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
2149 ", source = 0x%016" PRIxPTR "",
2150 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
2151
2152 if (context)
2153 {
2154 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
2155 SCOPED_SHARE_CONTEXT_LOCK(context);
2156 bool isCallValid = (context->skipValidation() ||
2157 ValidateGetShaderSource(context, angle::EntryPoint::GLGetShaderSource,
2158 shaderPacked, bufSize, length, source));
2159 if (isCallValid)
2160 {
2161 context->getShaderSource(shaderPacked, bufSize, length, source);
2162 }
2163 ANGLE_CAPTURE_GL(GetShaderSource, isCallValid, context, shaderPacked, bufSize, length,
2164 source);
2165 }
2166 else
2167 {
2168 GenerateContextLostErrorOnCurrentGlobalContext();
2169 }
2170 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2171 }
2172
GL_GetShaderiv(GLuint shader,GLenum pname,GLint * params)2173 void GL_APIENTRY GL_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
2174 {
2175 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2176 Context *context = GetGlobalContext();
2177 EVENT(context, GLGetShaderiv,
2178 "context = %d, shader = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), shader,
2179 GLenumToString(GLESEnum::ShaderParameterName, pname), (uintptr_t)params);
2180
2181 if (context)
2182 {
2183 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
2184 SCOPED_SHARE_CONTEXT_LOCK(context);
2185 bool isCallValid = (context->skipValidation() ||
2186 ValidateGetShaderiv(context, angle::EntryPoint::GLGetShaderiv,
2187 shaderPacked, pname, params));
2188 if (isCallValid)
2189 {
2190 context->getShaderiv(shaderPacked, pname, params);
2191 }
2192 ANGLE_CAPTURE_GL(GetShaderiv, isCallValid, context, shaderPacked, pname, params);
2193 }
2194 else
2195 {
2196 }
2197 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2198 }
2199
GL_GetString(GLenum name)2200 const GLubyte *GL_APIENTRY GL_GetString(GLenum name)
2201 {
2202 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2203 Context *context = GetValidGlobalContext();
2204 EVENT(context, GLGetString, "context = %d, name = %s", CID(context),
2205 GLenumToString(GLESEnum::StringName, name));
2206
2207 const GLubyte *returnValue;
2208 if (context)
2209 {
2210 SCOPED_SHARE_CONTEXT_LOCK(context);
2211 bool isCallValid = (context->skipValidation() ||
2212 ValidateGetString(context, angle::EntryPoint::GLGetString, name));
2213 if (isCallValid)
2214 {
2215 returnValue = context->getString(name);
2216 }
2217 else
2218 {
2219 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetString, const GLubyte *>();
2220 }
2221 ANGLE_CAPTURE_GL(GetString, isCallValid, context, name, returnValue);
2222 }
2223 else
2224 {
2225 GenerateContextLostErrorOnCurrentGlobalContext();
2226 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetString, const GLubyte *>();
2227 }
2228 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2229 return returnValue;
2230 }
2231
GL_GetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)2232 void GL_APIENTRY GL_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
2233 {
2234 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2235 Context *context = GetValidGlobalContext();
2236 EVENT(context, GLGetTexParameterfv,
2237 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2238 GLenumToString(GLESEnum::TextureTarget, target),
2239 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
2240
2241 if (context)
2242 {
2243 TextureType targetPacked = PackParam<TextureType>(target);
2244 SCOPED_SHARE_CONTEXT_LOCK(context);
2245 bool isCallValid =
2246 (context->skipValidation() ||
2247 ValidateGetTexParameterfv(context, angle::EntryPoint::GLGetTexParameterfv,
2248 targetPacked, pname, params));
2249 if (isCallValid)
2250 {
2251 context->getTexParameterfv(targetPacked, pname, params);
2252 }
2253 ANGLE_CAPTURE_GL(GetTexParameterfv, isCallValid, context, targetPacked, pname, params);
2254 }
2255 else
2256 {
2257 GenerateContextLostErrorOnCurrentGlobalContext();
2258 }
2259 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2260 }
2261
GL_GetTexParameteriv(GLenum target,GLenum pname,GLint * params)2262 void GL_APIENTRY GL_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
2263 {
2264 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2265 Context *context = GetValidGlobalContext();
2266 EVENT(context, GLGetTexParameteriv,
2267 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
2268 GLenumToString(GLESEnum::TextureTarget, target),
2269 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
2270
2271 if (context)
2272 {
2273 TextureType targetPacked = PackParam<TextureType>(target);
2274 SCOPED_SHARE_CONTEXT_LOCK(context);
2275 bool isCallValid =
2276 (context->skipValidation() ||
2277 ValidateGetTexParameteriv(context, angle::EntryPoint::GLGetTexParameteriv,
2278 targetPacked, pname, params));
2279 if (isCallValid)
2280 {
2281 context->getTexParameteriv(targetPacked, pname, params);
2282 }
2283 ANGLE_CAPTURE_GL(GetTexParameteriv, isCallValid, context, targetPacked, pname, params);
2284 }
2285 else
2286 {
2287 GenerateContextLostErrorOnCurrentGlobalContext();
2288 }
2289 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2290 }
2291
GL_GetUniformLocation(GLuint program,const GLchar * name)2292 GLint GL_APIENTRY GL_GetUniformLocation(GLuint program, const GLchar *name)
2293 {
2294 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2295 Context *context = GetValidGlobalContext();
2296 EVENT(context, GLGetUniformLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
2297 CID(context), program, (uintptr_t)name);
2298
2299 GLint returnValue;
2300 if (context)
2301 {
2302 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2303 SCOPED_SHARE_CONTEXT_LOCK(context);
2304 bool isCallValid =
2305 (context->skipValidation() ||
2306 ValidateGetUniformLocation(context, angle::EntryPoint::GLGetUniformLocation,
2307 programPacked, name));
2308 if (isCallValid)
2309 {
2310 returnValue = context->getUniformLocation(programPacked, name);
2311 }
2312 else
2313 {
2314 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
2315 }
2316 ANGLE_CAPTURE_GL(GetUniformLocation, isCallValid, context, programPacked, name,
2317 returnValue);
2318 }
2319 else
2320 {
2321 GenerateContextLostErrorOnCurrentGlobalContext();
2322 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
2323 }
2324 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2325 return returnValue;
2326 }
2327
GL_GetUniformfv(GLuint program,GLint location,GLfloat * params)2328 void GL_APIENTRY GL_GetUniformfv(GLuint program, GLint location, GLfloat *params)
2329 {
2330 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2331 Context *context = GetValidGlobalContext();
2332 EVENT(context, GLGetUniformfv,
2333 "context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
2334 program, location, (uintptr_t)params);
2335
2336 if (context)
2337 {
2338 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2339 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2340 SCOPED_SHARE_CONTEXT_LOCK(context);
2341 bool isCallValid = (context->skipValidation() ||
2342 ValidateGetUniformfv(context, angle::EntryPoint::GLGetUniformfv,
2343 programPacked, locationPacked, params));
2344 if (isCallValid)
2345 {
2346 context->getUniformfv(programPacked, locationPacked, params);
2347 }
2348 ANGLE_CAPTURE_GL(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
2349 }
2350 else
2351 {
2352 GenerateContextLostErrorOnCurrentGlobalContext();
2353 }
2354 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2355 }
2356
GL_GetUniformiv(GLuint program,GLint location,GLint * params)2357 void GL_APIENTRY GL_GetUniformiv(GLuint program, GLint location, GLint *params)
2358 {
2359 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2360 Context *context = GetValidGlobalContext();
2361 EVENT(context, GLGetUniformiv,
2362 "context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
2363 program, location, (uintptr_t)params);
2364
2365 if (context)
2366 {
2367 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2368 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2369 SCOPED_SHARE_CONTEXT_LOCK(context);
2370 bool isCallValid = (context->skipValidation() ||
2371 ValidateGetUniformiv(context, angle::EntryPoint::GLGetUniformiv,
2372 programPacked, locationPacked, params));
2373 if (isCallValid)
2374 {
2375 context->getUniformiv(programPacked, locationPacked, params);
2376 }
2377 ANGLE_CAPTURE_GL(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
2378 }
2379 else
2380 {
2381 GenerateContextLostErrorOnCurrentGlobalContext();
2382 }
2383 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2384 }
2385
GL_GetVertexAttribPointerv(GLuint index,GLenum pname,void ** pointer)2386 void GL_APIENTRY GL_GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
2387 {
2388 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2389 Context *context = GetValidGlobalContext();
2390 EVENT(context, GLGetVertexAttribPointerv,
2391 "context = %d, index = %u, pname = %s, pointer = 0x%016" PRIxPTR "", CID(context), index,
2392 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)pointer);
2393
2394 if (context)
2395 {
2396 SCOPED_SHARE_CONTEXT_LOCK(context);
2397 bool isCallValid =
2398 (context->skipValidation() ||
2399 ValidateGetVertexAttribPointerv(context, angle::EntryPoint::GLGetVertexAttribPointerv,
2400 index, pname, pointer));
2401 if (isCallValid)
2402 {
2403 context->getVertexAttribPointerv(index, pname, pointer);
2404 }
2405 ANGLE_CAPTURE_GL(GetVertexAttribPointerv, isCallValid, context, index, pname, pointer);
2406 }
2407 else
2408 {
2409 GenerateContextLostErrorOnCurrentGlobalContext();
2410 }
2411 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2412 }
2413
GL_GetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)2414 void GL_APIENTRY GL_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
2415 {
2416 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2417 Context *context = GetValidGlobalContext();
2418 EVENT(context, GLGetVertexAttribfv,
2419 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
2420 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
2421
2422 if (context)
2423 {
2424 SCOPED_SHARE_CONTEXT_LOCK(context);
2425 bool isCallValid =
2426 (context->skipValidation() ||
2427 ValidateGetVertexAttribfv(context, angle::EntryPoint::GLGetVertexAttribfv, index,
2428 pname, params));
2429 if (isCallValid)
2430 {
2431 context->getVertexAttribfv(index, pname, params);
2432 }
2433 ANGLE_CAPTURE_GL(GetVertexAttribfv, isCallValid, context, index, pname, params);
2434 }
2435 else
2436 {
2437 GenerateContextLostErrorOnCurrentGlobalContext();
2438 }
2439 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2440 }
2441
GL_GetVertexAttribiv(GLuint index,GLenum pname,GLint * params)2442 void GL_APIENTRY GL_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
2443 {
2444 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2445 Context *context = GetValidGlobalContext();
2446 EVENT(context, GLGetVertexAttribiv,
2447 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
2448 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
2449
2450 if (context)
2451 {
2452 SCOPED_SHARE_CONTEXT_LOCK(context);
2453 bool isCallValid =
2454 (context->skipValidation() ||
2455 ValidateGetVertexAttribiv(context, angle::EntryPoint::GLGetVertexAttribiv, index,
2456 pname, params));
2457 if (isCallValid)
2458 {
2459 context->getVertexAttribiv(index, pname, params);
2460 }
2461 ANGLE_CAPTURE_GL(GetVertexAttribiv, isCallValid, context, index, pname, params);
2462 }
2463 else
2464 {
2465 GenerateContextLostErrorOnCurrentGlobalContext();
2466 }
2467 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2468 }
2469
GL_Hint(GLenum target,GLenum mode)2470 void GL_APIENTRY GL_Hint(GLenum target, GLenum mode)
2471 {
2472 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2473 Context *context = GetValidGlobalContext();
2474 EVENT(context, GLHint, "context = %d, target = %s, mode = %s", CID(context),
2475 GLenumToString(GLESEnum::HintTarget, target), GLenumToString(GLESEnum::HintMode, mode));
2476
2477 if (context)
2478 {
2479 bool isCallValid =
2480 (context->skipValidation() ||
2481 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2482 context->getMutableErrorSetForValidation(),
2483 angle::EntryPoint::GLHint) &&
2484 ValidateHint(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2485 angle::EntryPoint::GLHint, target, mode)));
2486 if (isCallValid)
2487 {
2488 ContextPrivateHint(context->getMutablePrivateState(),
2489 context->getMutablePrivateStateCache(), target, mode);
2490 }
2491 ANGLE_CAPTURE_GL(Hint, isCallValid, context, target, mode);
2492 }
2493 else
2494 {
2495 GenerateContextLostErrorOnCurrentGlobalContext();
2496 }
2497 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2498 }
2499
GL_IsBuffer(GLuint buffer)2500 GLboolean GL_APIENTRY GL_IsBuffer(GLuint buffer)
2501 {
2502 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2503 Context *context = GetValidGlobalContext();
2504 EVENT(context, GLIsBuffer, "context = %d, buffer = %u", CID(context), buffer);
2505
2506 GLboolean returnValue;
2507 if (context)
2508 {
2509 BufferID bufferPacked = PackParam<BufferID>(buffer);
2510 SCOPED_SHARE_CONTEXT_LOCK(context);
2511 bool isCallValid = (context->skipValidation() ||
2512 ValidateIsBuffer(context, angle::EntryPoint::GLIsBuffer, bufferPacked));
2513 if (isCallValid)
2514 {
2515 returnValue = context->isBuffer(bufferPacked);
2516 }
2517 else
2518 {
2519 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsBuffer, GLboolean>();
2520 }
2521 ANGLE_CAPTURE_GL(IsBuffer, isCallValid, context, bufferPacked, returnValue);
2522 }
2523 else
2524 {
2525 GenerateContextLostErrorOnCurrentGlobalContext();
2526 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsBuffer, GLboolean>();
2527 }
2528 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2529 return returnValue;
2530 }
2531
GL_IsEnabled(GLenum cap)2532 GLboolean GL_APIENTRY GL_IsEnabled(GLenum cap)
2533 {
2534 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2535 Context *context = GetValidGlobalContext();
2536 EVENT(context, GLIsEnabled, "context = %d, cap = %s", CID(context),
2537 GLenumToString(GLESEnum::EnableCap, cap));
2538
2539 GLboolean returnValue;
2540 if (context)
2541 {
2542 bool isCallValid = (context->skipValidation() ||
2543 ValidateIsEnabled(context->getPrivateState(),
2544 context->getMutableErrorSetForValidation(),
2545 angle::EntryPoint::GLIsEnabled, cap));
2546 if (isCallValid)
2547 {
2548 returnValue = ContextPrivateIsEnabled(context->getMutablePrivateState(),
2549 context->getMutablePrivateStateCache(), cap);
2550 }
2551 else
2552 {
2553 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnabled, GLboolean>();
2554 }
2555 ANGLE_CAPTURE_GL(IsEnabled, isCallValid, context, cap, returnValue);
2556 }
2557 else
2558 {
2559 GenerateContextLostErrorOnCurrentGlobalContext();
2560 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnabled, GLboolean>();
2561 }
2562 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2563 return returnValue;
2564 }
2565
GL_IsFramebuffer(GLuint framebuffer)2566 GLboolean GL_APIENTRY GL_IsFramebuffer(GLuint framebuffer)
2567 {
2568 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2569 Context *context = GetValidGlobalContext();
2570 EVENT(context, GLIsFramebuffer, "context = %d, framebuffer = %u", CID(context), framebuffer);
2571
2572 GLboolean returnValue;
2573 if (context)
2574 {
2575 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
2576 SCOPED_SHARE_CONTEXT_LOCK(context);
2577 bool isCallValid =
2578 (context->skipValidation() ||
2579 ValidateIsFramebuffer(context, angle::EntryPoint::GLIsFramebuffer, framebufferPacked));
2580 if (isCallValid)
2581 {
2582 returnValue = context->isFramebuffer(framebufferPacked);
2583 }
2584 else
2585 {
2586 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebuffer, GLboolean>();
2587 }
2588 ANGLE_CAPTURE_GL(IsFramebuffer, isCallValid, context, framebufferPacked, returnValue);
2589 }
2590 else
2591 {
2592 GenerateContextLostErrorOnCurrentGlobalContext();
2593 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebuffer, GLboolean>();
2594 }
2595 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2596 return returnValue;
2597 }
2598
GL_IsProgram(GLuint program)2599 GLboolean GL_APIENTRY GL_IsProgram(GLuint program)
2600 {
2601 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2602 Context *context = GetValidGlobalContext();
2603 EVENT(context, GLIsProgram, "context = %d, program = %u", CID(context), program);
2604
2605 GLboolean returnValue;
2606 if (context)
2607 {
2608 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2609 SCOPED_SHARE_CONTEXT_LOCK(context);
2610 bool isCallValid =
2611 (context->skipValidation() ||
2612 ValidateIsProgram(context, angle::EntryPoint::GLIsProgram, programPacked));
2613 if (isCallValid)
2614 {
2615 returnValue = context->isProgram(programPacked);
2616 }
2617 else
2618 {
2619 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
2620 }
2621 ANGLE_CAPTURE_GL(IsProgram, isCallValid, context, programPacked, returnValue);
2622 }
2623 else
2624 {
2625 GenerateContextLostErrorOnCurrentGlobalContext();
2626 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
2627 }
2628 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2629 return returnValue;
2630 }
2631
GL_IsRenderbuffer(GLuint renderbuffer)2632 GLboolean GL_APIENTRY GL_IsRenderbuffer(GLuint renderbuffer)
2633 {
2634 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2635 Context *context = GetValidGlobalContext();
2636 EVENT(context, GLIsRenderbuffer, "context = %d, renderbuffer = %u", CID(context), renderbuffer);
2637
2638 GLboolean returnValue;
2639 if (context)
2640 {
2641 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
2642 SCOPED_SHARE_CONTEXT_LOCK(context);
2643 bool isCallValid = (context->skipValidation() ||
2644 ValidateIsRenderbuffer(context, angle::EntryPoint::GLIsRenderbuffer,
2645 renderbufferPacked));
2646 if (isCallValid)
2647 {
2648 returnValue = context->isRenderbuffer(renderbufferPacked);
2649 }
2650 else
2651 {
2652 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbuffer, GLboolean>();
2653 }
2654 ANGLE_CAPTURE_GL(IsRenderbuffer, isCallValid, context, renderbufferPacked, returnValue);
2655 }
2656 else
2657 {
2658 GenerateContextLostErrorOnCurrentGlobalContext();
2659 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbuffer, GLboolean>();
2660 }
2661 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2662 return returnValue;
2663 }
2664
GL_IsShader(GLuint shader)2665 GLboolean GL_APIENTRY GL_IsShader(GLuint shader)
2666 {
2667 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2668 Context *context = GetValidGlobalContext();
2669 EVENT(context, GLIsShader, "context = %d, shader = %u", CID(context), shader);
2670
2671 GLboolean returnValue;
2672 if (context)
2673 {
2674 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
2675 SCOPED_SHARE_CONTEXT_LOCK(context);
2676 bool isCallValid = (context->skipValidation() ||
2677 ValidateIsShader(context, angle::EntryPoint::GLIsShader, shaderPacked));
2678 if (isCallValid)
2679 {
2680 returnValue = context->isShader(shaderPacked);
2681 }
2682 else
2683 {
2684 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
2685 }
2686 ANGLE_CAPTURE_GL(IsShader, isCallValid, context, shaderPacked, returnValue);
2687 }
2688 else
2689 {
2690 GenerateContextLostErrorOnCurrentGlobalContext();
2691 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
2692 }
2693 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2694 return returnValue;
2695 }
2696
GL_IsTexture(GLuint texture)2697 GLboolean GL_APIENTRY GL_IsTexture(GLuint texture)
2698 {
2699 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2700 Context *context = GetValidGlobalContext();
2701 EVENT(context, GLIsTexture, "context = %d, texture = %u", CID(context), texture);
2702
2703 GLboolean returnValue;
2704 if (context)
2705 {
2706 TextureID texturePacked = PackParam<TextureID>(texture);
2707 SCOPED_SHARE_CONTEXT_LOCK(context);
2708 bool isCallValid =
2709 (context->skipValidation() ||
2710 ValidateIsTexture(context, angle::EntryPoint::GLIsTexture, texturePacked));
2711 if (isCallValid)
2712 {
2713 returnValue = context->isTexture(texturePacked);
2714 }
2715 else
2716 {
2717 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsTexture, GLboolean>();
2718 }
2719 ANGLE_CAPTURE_GL(IsTexture, isCallValid, context, texturePacked, returnValue);
2720 }
2721 else
2722 {
2723 GenerateContextLostErrorOnCurrentGlobalContext();
2724 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsTexture, GLboolean>();
2725 }
2726 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2727 return returnValue;
2728 }
2729
GL_LineWidth(GLfloat width)2730 void GL_APIENTRY GL_LineWidth(GLfloat width)
2731 {
2732 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2733 Context *context = GetValidGlobalContext();
2734 EVENT(context, GLLineWidth, "context = %d, width = %f", CID(context), width);
2735
2736 if (context)
2737 {
2738 bool isCallValid =
2739 (context->skipValidation() ||
2740 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2741 context->getMutableErrorSetForValidation(),
2742 angle::EntryPoint::GLLineWidth) &&
2743 ValidateLineWidth(context->getPrivateState(),
2744 context->getMutableErrorSetForValidation(),
2745 angle::EntryPoint::GLLineWidth, width)));
2746 if (isCallValid)
2747 {
2748 ContextPrivateLineWidth(context->getMutablePrivateState(),
2749 context->getMutablePrivateStateCache(), width);
2750 }
2751 ANGLE_CAPTURE_GL(LineWidth, isCallValid, context, width);
2752 }
2753 else
2754 {
2755 GenerateContextLostErrorOnCurrentGlobalContext();
2756 }
2757 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2758 }
2759
GL_LinkProgram(GLuint program)2760 void GL_APIENTRY GL_LinkProgram(GLuint program)
2761 {
2762 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2763 Context *context = GetValidGlobalContext();
2764 EVENT(context, GLLinkProgram, "context = %d, program = %u", CID(context), program);
2765
2766 if (context)
2767 {
2768 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2769 SCOPED_SHARE_CONTEXT_LOCK(context);
2770 bool isCallValid =
2771 (context->skipValidation() ||
2772 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2773 context->getMutableErrorSetForValidation(),
2774 angle::EntryPoint::GLLinkProgram) &&
2775 ValidateLinkProgram(context, angle::EntryPoint::GLLinkProgram, programPacked)));
2776 if (isCallValid)
2777 {
2778 context->linkProgram(programPacked);
2779 }
2780 ANGLE_CAPTURE_GL(LinkProgram, isCallValid, context, programPacked);
2781 }
2782 else
2783 {
2784 GenerateContextLostErrorOnCurrentGlobalContext();
2785 }
2786 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2787 }
2788
GL_PixelStorei(GLenum pname,GLint param)2789 void GL_APIENTRY GL_PixelStorei(GLenum pname, GLint param)
2790 {
2791 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2792 Context *context = GetValidGlobalContext();
2793 EVENT(context, GLPixelStorei, "context = %d, pname = %s, param = %d", CID(context),
2794 GLenumToString(GLESEnum::PixelStoreParameter, pname), param);
2795
2796 if (context)
2797 {
2798 bool isCallValid =
2799 (context->skipValidation() ||
2800 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2801 context->getMutableErrorSetForValidation(),
2802 angle::EntryPoint::GLPixelStorei) &&
2803 ValidatePixelStorei(context->getPrivateState(),
2804 context->getMutableErrorSetForValidation(),
2805 angle::EntryPoint::GLPixelStorei, pname, param)));
2806 if (isCallValid)
2807 {
2808 ContextPrivatePixelStorei(context->getMutablePrivateState(),
2809 context->getMutablePrivateStateCache(), pname, param);
2810 }
2811 ANGLE_CAPTURE_GL(PixelStorei, isCallValid, context, pname, param);
2812 }
2813 else
2814 {
2815 GenerateContextLostErrorOnCurrentGlobalContext();
2816 }
2817 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2818 }
2819
GL_PolygonOffset(GLfloat factor,GLfloat units)2820 void GL_APIENTRY GL_PolygonOffset(GLfloat factor, GLfloat units)
2821 {
2822 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2823 Context *context = GetValidGlobalContext();
2824 EVENT(context, GLPolygonOffset, "context = %d, factor = %f, units = %f", CID(context), factor,
2825 units);
2826
2827 if (context)
2828 {
2829 bool isCallValid =
2830 (context->skipValidation() ||
2831 ValidatePolygonOffset(context->getPrivateState(),
2832 context->getMutableErrorSetForValidation(),
2833 angle::EntryPoint::GLPolygonOffset, factor, units));
2834 if (isCallValid)
2835 {
2836 ContextPrivatePolygonOffset(context->getMutablePrivateState(),
2837 context->getMutablePrivateStateCache(), factor, units);
2838 }
2839 ANGLE_CAPTURE_GL(PolygonOffset, isCallValid, context, factor, units);
2840 }
2841 else
2842 {
2843 GenerateContextLostErrorOnCurrentGlobalContext();
2844 }
2845 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2846 }
2847
GL_ReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void * pixels)2848 void GL_APIENTRY GL_ReadPixels(GLint x,
2849 GLint y,
2850 GLsizei width,
2851 GLsizei height,
2852 GLenum format,
2853 GLenum type,
2854 void *pixels)
2855 {
2856 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2857 Context *context = GetValidGlobalContext();
2858 EVENT(context, GLReadPixels,
2859 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, pixels = "
2860 "0x%016" PRIxPTR "",
2861 CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format),
2862 GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
2863
2864 if (context)
2865 {
2866 SCOPED_SHARE_CONTEXT_LOCK(context);
2867 bool isCallValid =
2868 (context->skipValidation() ||
2869 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2870 context->getMutableErrorSetForValidation(),
2871 angle::EntryPoint::GLReadPixels) &&
2872 ValidateReadPixels(context, angle::EntryPoint::GLReadPixels, x, y, width, height,
2873 format, type, pixels)));
2874 if (isCallValid)
2875 {
2876 context->readPixels(x, y, width, height, format, type, pixels);
2877 }
2878 ANGLE_CAPTURE_GL(ReadPixels, isCallValid, context, x, y, width, height, format, type,
2879 pixels);
2880 }
2881 else
2882 {
2883 GenerateContextLostErrorOnCurrentGlobalContext();
2884 }
2885 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2886 }
2887
GL_ReleaseShaderCompiler()2888 void GL_APIENTRY GL_ReleaseShaderCompiler()
2889 {
2890 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2891 Context *context = GetValidGlobalContext();
2892 EVENT(context, GLReleaseShaderCompiler, "context = %d", CID(context));
2893
2894 if (context)
2895 {
2896 SCOPED_SHARE_CONTEXT_LOCK(context);
2897 bool isCallValid =
2898 (context->skipValidation() ||
2899 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2900 context->getMutableErrorSetForValidation(),
2901 angle::EntryPoint::GLReleaseShaderCompiler) &&
2902 ValidateReleaseShaderCompiler(context, angle::EntryPoint::GLReleaseShaderCompiler)));
2903 if (isCallValid)
2904 {
2905 context->releaseShaderCompiler();
2906 }
2907 ANGLE_CAPTURE_GL(ReleaseShaderCompiler, isCallValid, context);
2908 }
2909 else
2910 {
2911 GenerateContextLostErrorOnCurrentGlobalContext();
2912 }
2913 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2914 }
2915
GL_RenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)2916 void GL_APIENTRY GL_RenderbufferStorage(GLenum target,
2917 GLenum internalformat,
2918 GLsizei width,
2919 GLsizei height)
2920 {
2921 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2922 Context *context = GetValidGlobalContext();
2923 EVENT(context, GLRenderbufferStorage,
2924 "context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context),
2925 GLenumToString(GLESEnum::RenderbufferTarget, target),
2926 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height);
2927
2928 if (context)
2929 {
2930 SCOPED_SHARE_CONTEXT_LOCK(context);
2931 bool isCallValid =
2932 (context->skipValidation() ||
2933 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2934 context->getMutableErrorSetForValidation(),
2935 angle::EntryPoint::GLRenderbufferStorage) &&
2936 ValidateRenderbufferStorage(context, angle::EntryPoint::GLRenderbufferStorage, target,
2937 internalformat, width, height)));
2938 if (isCallValid)
2939 {
2940 context->renderbufferStorage(target, internalformat, width, height);
2941 }
2942 ANGLE_CAPTURE_GL(RenderbufferStorage, isCallValid, context, target, internalformat, width,
2943 height);
2944 }
2945 else
2946 {
2947 GenerateContextLostErrorOnCurrentGlobalContext();
2948 }
2949 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2950 }
2951
GL_SampleCoverage(GLfloat value,GLboolean invert)2952 void GL_APIENTRY GL_SampleCoverage(GLfloat value, GLboolean invert)
2953 {
2954 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2955 Context *context = GetValidGlobalContext();
2956 EVENT(context, GLSampleCoverage, "context = %d, value = %f, invert = %s", CID(context), value,
2957 GLbooleanToString(invert));
2958
2959 if (context)
2960 {
2961 bool isCallValid =
2962 (context->skipValidation() ||
2963 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2964 context->getMutableErrorSetForValidation(),
2965 angle::EntryPoint::GLSampleCoverage) &&
2966 ValidateSampleCoverage(context->getPrivateState(),
2967 context->getMutableErrorSetForValidation(),
2968 angle::EntryPoint::GLSampleCoverage, value, invert)));
2969 if (isCallValid)
2970 {
2971 ContextPrivateSampleCoverage(context->getMutablePrivateState(),
2972 context->getMutablePrivateStateCache(), value, invert);
2973 }
2974 ANGLE_CAPTURE_GL(SampleCoverage, isCallValid, context, value, invert);
2975 }
2976 else
2977 {
2978 GenerateContextLostErrorOnCurrentGlobalContext();
2979 }
2980 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2981 }
2982
GL_Scissor(GLint x,GLint y,GLsizei width,GLsizei height)2983 void GL_APIENTRY GL_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
2984 {
2985 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2986 Context *context = GetValidGlobalContext();
2987 EVENT(context, GLScissor, "context = %d, x = %d, y = %d, width = %d, height = %d", CID(context),
2988 x, y, width, height);
2989
2990 if (context)
2991 {
2992 bool isCallValid =
2993 (context->skipValidation() ||
2994 ValidateScissor(context->getPrivateState(), context->getMutableErrorSetForValidation(),
2995 angle::EntryPoint::GLScissor, x, y, width, height));
2996 if (isCallValid)
2997 {
2998 ContextPrivateScissor(context->getMutablePrivateState(),
2999 context->getMutablePrivateStateCache(), x, y, width, height);
3000 }
3001 ANGLE_CAPTURE_GL(Scissor, isCallValid, context, x, y, width, height);
3002 }
3003 else
3004 {
3005 GenerateContextLostErrorOnCurrentGlobalContext();
3006 }
3007 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3008 }
3009
GL_ShaderBinary(GLsizei count,const GLuint * shaders,GLenum binaryFormat,const void * binary,GLsizei length)3010 void GL_APIENTRY GL_ShaderBinary(GLsizei count,
3011 const GLuint *shaders,
3012 GLenum binaryFormat,
3013 const void *binary,
3014 GLsizei length)
3015 {
3016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3017 Context *context = GetValidGlobalContext();
3018 EVENT(context, GLShaderBinary,
3019 "context = %d, count = %d, shaders = 0x%016" PRIxPTR
3020 ", binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d",
3021 CID(context), count, (uintptr_t)shaders,
3022 GLenumToString(GLESEnum::ShaderBinaryFormat, binaryFormat), (uintptr_t)binary, length);
3023
3024 if (context)
3025 {
3026 const ShaderProgramID *shadersPacked = PackParam<const ShaderProgramID *>(shaders);
3027 SCOPED_SHARE_CONTEXT_LOCK(context);
3028 bool isCallValid =
3029 (context->skipValidation() ||
3030 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3031 context->getMutableErrorSetForValidation(),
3032 angle::EntryPoint::GLShaderBinary) &&
3033 ValidateShaderBinary(context, angle::EntryPoint::GLShaderBinary, count, shadersPacked,
3034 binaryFormat, binary, length)));
3035 if (isCallValid)
3036 {
3037 context->shaderBinary(count, shadersPacked, binaryFormat, binary, length);
3038 }
3039 ANGLE_CAPTURE_GL(ShaderBinary, isCallValid, context, count, shadersPacked, binaryFormat,
3040 binary, length);
3041 }
3042 else
3043 {
3044 GenerateContextLostErrorOnCurrentGlobalContext();
3045 }
3046 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
3047 }
3048
GL_ShaderSource(GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length)3049 void GL_APIENTRY GL_ShaderSource(GLuint shader,
3050 GLsizei count,
3051 const GLchar *const *string,
3052 const GLint *length)
3053 {
3054 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3055 Context *context = GetValidGlobalContext();
3056 EVENT(context, GLShaderSource,
3057 "context = %d, shader = %u, count = %d, string = 0x%016" PRIxPTR
3058 ", length = 0x%016" PRIxPTR "",
3059 CID(context), shader, count, (uintptr_t)string, (uintptr_t)length);
3060
3061 if (context)
3062 {
3063 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
3064 SCOPED_SHARE_CONTEXT_LOCK(context);
3065 bool isCallValid =
3066 (context->skipValidation() ||
3067 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3068 context->getMutableErrorSetForValidation(),
3069 angle::EntryPoint::GLShaderSource) &&
3070 ValidateShaderSource(context, angle::EntryPoint::GLShaderSource, shaderPacked, count,
3071 string, length)));
3072 if (isCallValid)
3073 {
3074 context->shaderSource(shaderPacked, count, string, length);
3075 }
3076 ANGLE_CAPTURE_GL(ShaderSource, isCallValid, context, shaderPacked, count, string, length);
3077 }
3078 else
3079 {
3080 GenerateContextLostErrorOnCurrentGlobalContext();
3081 }
3082 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3083 }
3084
GL_StencilFunc(GLenum func,GLint ref,GLuint mask)3085 void GL_APIENTRY GL_StencilFunc(GLenum func, GLint ref, GLuint mask)
3086 {
3087 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3088 Context *context = GetValidGlobalContext();
3089 EVENT(context, GLStencilFunc, "context = %d, func = %s, ref = %d, mask = %u", CID(context),
3090 GLenumToString(GLESEnum::StencilFunction, func), ref, mask);
3091
3092 if (context)
3093 {
3094 bool isCallValid = (context->skipValidation() ||
3095 ValidateStencilFunc(context->getPrivateState(),
3096 context->getMutableErrorSetForValidation(),
3097 angle::EntryPoint::GLStencilFunc, func, ref, mask));
3098 if (isCallValid)
3099 {
3100 ContextPrivateStencilFunc(context->getMutablePrivateState(),
3101 context->getMutablePrivateStateCache(), func, ref, mask);
3102 }
3103 ANGLE_CAPTURE_GL(StencilFunc, isCallValid, context, func, ref, mask);
3104 }
3105 else
3106 {
3107 GenerateContextLostErrorOnCurrentGlobalContext();
3108 }
3109 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3110 }
3111
GL_StencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)3112 void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
3113 {
3114 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3115 Context *context = GetValidGlobalContext();
3116 EVENT(context, GLStencilFuncSeparate, "context = %d, face = %s, func = %s, ref = %d, mask = %u",
3117 CID(context), GLenumToString(GLESEnum::TriangleFace, face),
3118 GLenumToString(GLESEnum::StencilFunction, func), ref, mask);
3119
3120 if (context)
3121 {
3122 bool isCallValid =
3123 (context->skipValidation() ||
3124 ValidateStencilFuncSeparate(
3125 context->getPrivateState(), context->getMutableErrorSetForValidation(),
3126 angle::EntryPoint::GLStencilFuncSeparate, face, func, ref, mask));
3127 if (isCallValid)
3128 {
3129 ContextPrivateStencilFuncSeparate(context->getMutablePrivateState(),
3130 context->getMutablePrivateStateCache(), face, func,
3131 ref, mask);
3132 }
3133 ANGLE_CAPTURE_GL(StencilFuncSeparate, isCallValid, context, face, func, ref, mask);
3134 }
3135 else
3136 {
3137 GenerateContextLostErrorOnCurrentGlobalContext();
3138 }
3139 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3140 }
3141
GL_StencilMask(GLuint mask)3142 void GL_APIENTRY GL_StencilMask(GLuint mask)
3143 {
3144 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3145 Context *context = GetValidGlobalContext();
3146 EVENT(context, GLStencilMask, "context = %d, mask = %u", CID(context), mask);
3147
3148 if (context)
3149 {
3150 bool isCallValid = (context->skipValidation() ||
3151 ValidateStencilMask(context->getPrivateState(),
3152 context->getMutableErrorSetForValidation(),
3153 angle::EntryPoint::GLStencilMask, mask));
3154 if (isCallValid)
3155 {
3156 ContextPrivateStencilMask(context->getMutablePrivateState(),
3157 context->getMutablePrivateStateCache(), mask);
3158 }
3159 ANGLE_CAPTURE_GL(StencilMask, isCallValid, context, mask);
3160 }
3161 else
3162 {
3163 GenerateContextLostErrorOnCurrentGlobalContext();
3164 }
3165 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3166 }
3167
GL_StencilMaskSeparate(GLenum face,GLuint mask)3168 void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask)
3169 {
3170 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3171 Context *context = GetValidGlobalContext();
3172 EVENT(context, GLStencilMaskSeparate, "context = %d, face = %s, mask = %u", CID(context),
3173 GLenumToString(GLESEnum::TriangleFace, face), mask);
3174
3175 if (context)
3176 {
3177 bool isCallValid =
3178 (context->skipValidation() ||
3179 ValidateStencilMaskSeparate(context->getPrivateState(),
3180 context->getMutableErrorSetForValidation(),
3181 angle::EntryPoint::GLStencilMaskSeparate, face, mask));
3182 if (isCallValid)
3183 {
3184 ContextPrivateStencilMaskSeparate(context->getMutablePrivateState(),
3185 context->getMutablePrivateStateCache(), face, mask);
3186 }
3187 ANGLE_CAPTURE_GL(StencilMaskSeparate, isCallValid, context, face, mask);
3188 }
3189 else
3190 {
3191 GenerateContextLostErrorOnCurrentGlobalContext();
3192 }
3193 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3194 }
3195
GL_StencilOp(GLenum fail,GLenum zfail,GLenum zpass)3196 void GL_APIENTRY GL_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3197 {
3198 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3199 Context *context = GetValidGlobalContext();
3200 EVENT(context, GLStencilOp, "context = %d, fail = %s, zfail = %s, zpass = %s", CID(context),
3201 GLenumToString(GLESEnum::StencilOp, fail), GLenumToString(GLESEnum::StencilOp, zfail),
3202 GLenumToString(GLESEnum::StencilOp, zpass));
3203
3204 if (context)
3205 {
3206 bool isCallValid = (context->skipValidation() ||
3207 ValidateStencilOp(context->getPrivateState(),
3208 context->getMutableErrorSetForValidation(),
3209 angle::EntryPoint::GLStencilOp, fail, zfail, zpass));
3210 if (isCallValid)
3211 {
3212 ContextPrivateStencilOp(context->getMutablePrivateState(),
3213 context->getMutablePrivateStateCache(), fail, zfail, zpass);
3214 }
3215 ANGLE_CAPTURE_GL(StencilOp, isCallValid, context, fail, zfail, zpass);
3216 }
3217 else
3218 {
3219 GenerateContextLostErrorOnCurrentGlobalContext();
3220 }
3221 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3222 }
3223
GL_StencilOpSeparate(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass)3224 void GL_APIENTRY GL_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
3225 {
3226 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3227 Context *context = GetValidGlobalContext();
3228 EVENT(context, GLStencilOpSeparate,
3229 "context = %d, face = %s, sfail = %s, dpfail = %s, dppass = %s", CID(context),
3230 GLenumToString(GLESEnum::TriangleFace, face), GLenumToString(GLESEnum::StencilOp, sfail),
3231 GLenumToString(GLESEnum::StencilOp, dpfail), GLenumToString(GLESEnum::StencilOp, dppass));
3232
3233 if (context)
3234 {
3235 bool isCallValid =
3236 (context->skipValidation() ||
3237 ValidateStencilOpSeparate(
3238 context->getPrivateState(), context->getMutableErrorSetForValidation(),
3239 angle::EntryPoint::GLStencilOpSeparate, face, sfail, dpfail, dppass));
3240 if (isCallValid)
3241 {
3242 ContextPrivateStencilOpSeparate(context->getMutablePrivateState(),
3243 context->getMutablePrivateStateCache(), face, sfail,
3244 dpfail, dppass);
3245 }
3246 ANGLE_CAPTURE_GL(StencilOpSeparate, isCallValid, context, face, sfail, dpfail, dppass);
3247 }
3248 else
3249 {
3250 GenerateContextLostErrorOnCurrentGlobalContext();
3251 }
3252 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3253 }
3254
GL_TexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void * pixels)3255 void GL_APIENTRY GL_TexImage2D(GLenum target,
3256 GLint level,
3257 GLint internalformat,
3258 GLsizei width,
3259 GLsizei height,
3260 GLint border,
3261 GLenum format,
3262 GLenum type,
3263 const void *pixels)
3264 {
3265 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3266 Context *context = GetValidGlobalContext();
3267 EVENT(context, GLTexImage2D,
3268 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
3269 "border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
3270 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat,
3271 width, height, border, GLenumToString(GLESEnum::PixelFormat, format),
3272 GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
3273
3274 if (context)
3275 {
3276 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3277 SCOPED_SHARE_CONTEXT_LOCK(context);
3278 bool isCallValid =
3279 (context->skipValidation() ||
3280 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3281 context->getMutableErrorSetForValidation(),
3282 angle::EntryPoint::GLTexImage2D) &&
3283 ValidateTexImage2D(context, angle::EntryPoint::GLTexImage2D, targetPacked, level,
3284 internalformat, width, height, border, format, type, pixels)));
3285 if (isCallValid)
3286 {
3287 context->texImage2D(targetPacked, level, internalformat, width, height, border, format,
3288 type, pixels);
3289 }
3290 ANGLE_CAPTURE_GL(TexImage2D, isCallValid, context, targetPacked, level, internalformat,
3291 width, height, border, format, type, pixels);
3292 }
3293 else
3294 {
3295 GenerateContextLostErrorOnCurrentGlobalContext();
3296 }
3297 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
3298 }
3299
GL_TexParameterf(GLenum target,GLenum pname,GLfloat param)3300 void GL_APIENTRY GL_TexParameterf(GLenum target, GLenum pname, GLfloat param)
3301 {
3302 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3303 Context *context = GetValidGlobalContext();
3304 EVENT(context, GLTexParameterf, "context = %d, target = %s, pname = %s, param = %f",
3305 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
3306 GLenumToString(GLESEnum::TextureParameterName, pname), param);
3307
3308 if (context)
3309 {
3310 TextureType targetPacked = PackParam<TextureType>(target);
3311 SCOPED_SHARE_CONTEXT_LOCK(context);
3312 bool isCallValid = (context->skipValidation() ||
3313 ValidateTexParameterf(context, angle::EntryPoint::GLTexParameterf,
3314 targetPacked, pname, param));
3315 if (isCallValid)
3316 {
3317 context->texParameterf(targetPacked, pname, param);
3318 }
3319 ANGLE_CAPTURE_GL(TexParameterf, isCallValid, context, targetPacked, pname, param);
3320 }
3321 else
3322 {
3323 GenerateContextLostErrorOnCurrentGlobalContext();
3324 }
3325 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3326 }
3327
GL_TexParameterfv(GLenum target,GLenum pname,const GLfloat * params)3328 void GL_APIENTRY GL_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
3329 {
3330 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3331 Context *context = GetValidGlobalContext();
3332 EVENT(context, GLTexParameterfv,
3333 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
3334 GLenumToString(GLESEnum::TextureTarget, target),
3335 GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
3336
3337 if (context)
3338 {
3339 TextureType targetPacked = PackParam<TextureType>(target);
3340 SCOPED_SHARE_CONTEXT_LOCK(context);
3341 bool isCallValid = (context->skipValidation() ||
3342 ValidateTexParameterfv(context, angle::EntryPoint::GLTexParameterfv,
3343 targetPacked, pname, params));
3344 if (isCallValid)
3345 {
3346 context->texParameterfv(targetPacked, pname, params);
3347 }
3348 ANGLE_CAPTURE_GL(TexParameterfv, isCallValid, context, targetPacked, pname, params);
3349 }
3350 else
3351 {
3352 GenerateContextLostErrorOnCurrentGlobalContext();
3353 }
3354 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3355 }
3356
GL_TexParameteri(GLenum target,GLenum pname,GLint param)3357 void GL_APIENTRY GL_TexParameteri(GLenum target, GLenum pname, GLint param)
3358 {
3359 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3360 Context *context = GetValidGlobalContext();
3361 EVENT(context, GLTexParameteri, "context = %d, target = %s, pname = %s, param = %d",
3362 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
3363 GLenumToString(GLESEnum::TextureParameterName, pname), param);
3364
3365 if (context)
3366 {
3367 TextureType targetPacked = PackParam<TextureType>(target);
3368 SCOPED_SHARE_CONTEXT_LOCK(context);
3369 bool isCallValid = (context->skipValidation() ||
3370 ValidateTexParameteri(context, angle::EntryPoint::GLTexParameteri,
3371 targetPacked, pname, param));
3372 if (isCallValid)
3373 {
3374 context->texParameteri(targetPacked, pname, param);
3375 }
3376 ANGLE_CAPTURE_GL(TexParameteri, isCallValid, context, targetPacked, pname, param);
3377 }
3378 else
3379 {
3380 GenerateContextLostErrorOnCurrentGlobalContext();
3381 }
3382 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3383 }
3384
GL_TexParameteriv(GLenum target,GLenum pname,const GLint * params)3385 void GL_APIENTRY GL_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
3386 {
3387 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3388 Context *context = GetValidGlobalContext();
3389 EVENT(context, GLTexParameteriv,
3390 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
3391 GLenumToString(GLESEnum::TextureTarget, target),
3392 GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
3393
3394 if (context)
3395 {
3396 TextureType targetPacked = PackParam<TextureType>(target);
3397 SCOPED_SHARE_CONTEXT_LOCK(context);
3398 bool isCallValid = (context->skipValidation() ||
3399 ValidateTexParameteriv(context, angle::EntryPoint::GLTexParameteriv,
3400 targetPacked, pname, params));
3401 if (isCallValid)
3402 {
3403 context->texParameteriv(targetPacked, pname, params);
3404 }
3405 ANGLE_CAPTURE_GL(TexParameteriv, isCallValid, context, targetPacked, pname, params);
3406 }
3407 else
3408 {
3409 GenerateContextLostErrorOnCurrentGlobalContext();
3410 }
3411 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3412 }
3413
GL_TexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)3414 void GL_APIENTRY GL_TexSubImage2D(GLenum target,
3415 GLint level,
3416 GLint xoffset,
3417 GLint yoffset,
3418 GLsizei width,
3419 GLsizei height,
3420 GLenum format,
3421 GLenum type,
3422 const void *pixels)
3423 {
3424 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3425 Context *context = GetValidGlobalContext();
3426 EVENT(context, GLTexSubImage2D,
3427 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
3428 "%d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
3429 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset,
3430 width, height, GLenumToString(GLESEnum::PixelFormat, format),
3431 GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
3432
3433 if (context)
3434 {
3435 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3436 SCOPED_SHARE_CONTEXT_LOCK(context);
3437 bool isCallValid =
3438 (context->skipValidation() ||
3439 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3440 context->getMutableErrorSetForValidation(),
3441 angle::EntryPoint::GLTexSubImage2D) &&
3442 ValidateTexSubImage2D(context, angle::EntryPoint::GLTexSubImage2D, targetPacked,
3443 level, xoffset, yoffset, width, height, format, type, pixels)));
3444 if (isCallValid)
3445 {
3446 context->texSubImage2D(targetPacked, level, xoffset, yoffset, width, height, format,
3447 type, pixels);
3448 }
3449 ANGLE_CAPTURE_GL(TexSubImage2D, isCallValid, context, targetPacked, level, xoffset, yoffset,
3450 width, height, format, type, pixels);
3451 }
3452 else
3453 {
3454 GenerateContextLostErrorOnCurrentGlobalContext();
3455 }
3456 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
3457 }
3458
GL_Uniform1f(GLint location,GLfloat v0)3459 void GL_APIENTRY GL_Uniform1f(GLint location, GLfloat v0)
3460 {
3461 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3462 Context *context = GetValidGlobalContext();
3463 EVENT(context, GLUniform1f, "context = %d, location = %d, v0 = %f", CID(context), location, v0);
3464
3465 if (context)
3466 {
3467 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3468
3469 bool isCallValid =
3470 (context->skipValidation() ||
3471 ValidateUniform1f(context, angle::EntryPoint::GLUniform1f, locationPacked, v0));
3472 if (isCallValid)
3473 {
3474 context->uniform1f(locationPacked, v0);
3475 }
3476 ANGLE_CAPTURE_GL(Uniform1f, isCallValid, context, locationPacked, v0);
3477 }
3478 else
3479 {
3480 GenerateContextLostErrorOnCurrentGlobalContext();
3481 }
3482 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3483 }
3484
GL_Uniform1fv(GLint location,GLsizei count,const GLfloat * value)3485 void GL_APIENTRY GL_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
3486 {
3487 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3488 Context *context = GetValidGlobalContext();
3489 EVENT(context, GLUniform1fv,
3490 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3491 location, count, (uintptr_t)value);
3492
3493 if (context)
3494 {
3495 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3496
3497 bool isCallValid = (context->skipValidation() ||
3498 ValidateUniform1fv(context, angle::EntryPoint::GLUniform1fv,
3499 locationPacked, count, value));
3500 if (isCallValid)
3501 {
3502 context->uniform1fv(locationPacked, count, value);
3503 }
3504 ANGLE_CAPTURE_GL(Uniform1fv, isCallValid, context, locationPacked, count, value);
3505 }
3506 else
3507 {
3508 GenerateContextLostErrorOnCurrentGlobalContext();
3509 }
3510 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3511 }
3512
GL_Uniform1i(GLint location,GLint v0)3513 void GL_APIENTRY GL_Uniform1i(GLint location, GLint v0)
3514 {
3515 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3516 Context *context = GetValidGlobalContext();
3517 EVENT(context, GLUniform1i, "context = %d, location = %d, v0 = %d", CID(context), location, v0);
3518
3519 if (context)
3520 {
3521 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3522 SCOPED_SHARE_CONTEXT_LOCK(context);
3523 bool isCallValid =
3524 (context->skipValidation() ||
3525 ValidateUniform1i(context, angle::EntryPoint::GLUniform1i, locationPacked, v0));
3526 if (isCallValid)
3527 {
3528 context->uniform1i(locationPacked, v0);
3529 }
3530 ANGLE_CAPTURE_GL(Uniform1i, isCallValid, context, locationPacked, v0);
3531 }
3532 else
3533 {
3534 GenerateContextLostErrorOnCurrentGlobalContext();
3535 }
3536 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3537 }
3538
GL_Uniform1iv(GLint location,GLsizei count,const GLint * value)3539 void GL_APIENTRY GL_Uniform1iv(GLint location, GLsizei count, const GLint *value)
3540 {
3541 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3542 Context *context = GetValidGlobalContext();
3543 EVENT(context, GLUniform1iv,
3544 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3545 location, count, (uintptr_t)value);
3546
3547 if (context)
3548 {
3549 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3550 SCOPED_SHARE_CONTEXT_LOCK(context);
3551 bool isCallValid = (context->skipValidation() ||
3552 ValidateUniform1iv(context, angle::EntryPoint::GLUniform1iv,
3553 locationPacked, count, value));
3554 if (isCallValid)
3555 {
3556 context->uniform1iv(locationPacked, count, value);
3557 }
3558 ANGLE_CAPTURE_GL(Uniform1iv, isCallValid, context, locationPacked, count, value);
3559 }
3560 else
3561 {
3562 GenerateContextLostErrorOnCurrentGlobalContext();
3563 }
3564 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3565 }
3566
GL_Uniform2f(GLint location,GLfloat v0,GLfloat v1)3567 void GL_APIENTRY GL_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
3568 {
3569 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3570 Context *context = GetValidGlobalContext();
3571 EVENT(context, GLUniform2f, "context = %d, location = %d, v0 = %f, v1 = %f", CID(context),
3572 location, v0, v1);
3573
3574 if (context)
3575 {
3576 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3577
3578 bool isCallValid =
3579 (context->skipValidation() ||
3580 ValidateUniform2f(context, angle::EntryPoint::GLUniform2f, locationPacked, v0, v1));
3581 if (isCallValid)
3582 {
3583 context->uniform2f(locationPacked, v0, v1);
3584 }
3585 ANGLE_CAPTURE_GL(Uniform2f, isCallValid, context, locationPacked, v0, v1);
3586 }
3587 else
3588 {
3589 GenerateContextLostErrorOnCurrentGlobalContext();
3590 }
3591 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3592 }
3593
GL_Uniform2fv(GLint location,GLsizei count,const GLfloat * value)3594 void GL_APIENTRY GL_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
3595 {
3596 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3597 Context *context = GetValidGlobalContext();
3598 EVENT(context, GLUniform2fv,
3599 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3600 location, count, (uintptr_t)value);
3601
3602 if (context)
3603 {
3604 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3605
3606 bool isCallValid = (context->skipValidation() ||
3607 ValidateUniform2fv(context, angle::EntryPoint::GLUniform2fv,
3608 locationPacked, count, value));
3609 if (isCallValid)
3610 {
3611 context->uniform2fv(locationPacked, count, value);
3612 }
3613 ANGLE_CAPTURE_GL(Uniform2fv, isCallValid, context, locationPacked, count, value);
3614 }
3615 else
3616 {
3617 GenerateContextLostErrorOnCurrentGlobalContext();
3618 }
3619 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3620 }
3621
GL_Uniform2i(GLint location,GLint v0,GLint v1)3622 void GL_APIENTRY GL_Uniform2i(GLint location, GLint v0, GLint v1)
3623 {
3624 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3625 Context *context = GetValidGlobalContext();
3626 EVENT(context, GLUniform2i, "context = %d, location = %d, v0 = %d, v1 = %d", CID(context),
3627 location, v0, v1);
3628
3629 if (context)
3630 {
3631 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3632
3633 bool isCallValid =
3634 (context->skipValidation() ||
3635 ValidateUniform2i(context, angle::EntryPoint::GLUniform2i, locationPacked, v0, v1));
3636 if (isCallValid)
3637 {
3638 context->uniform2i(locationPacked, v0, v1);
3639 }
3640 ANGLE_CAPTURE_GL(Uniform2i, isCallValid, context, locationPacked, v0, v1);
3641 }
3642 else
3643 {
3644 GenerateContextLostErrorOnCurrentGlobalContext();
3645 }
3646 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3647 }
3648
GL_Uniform2iv(GLint location,GLsizei count,const GLint * value)3649 void GL_APIENTRY GL_Uniform2iv(GLint location, GLsizei count, const GLint *value)
3650 {
3651 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3652 Context *context = GetValidGlobalContext();
3653 EVENT(context, GLUniform2iv,
3654 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3655 location, count, (uintptr_t)value);
3656
3657 if (context)
3658 {
3659 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3660
3661 bool isCallValid = (context->skipValidation() ||
3662 ValidateUniform2iv(context, angle::EntryPoint::GLUniform2iv,
3663 locationPacked, count, value));
3664 if (isCallValid)
3665 {
3666 context->uniform2iv(locationPacked, count, value);
3667 }
3668 ANGLE_CAPTURE_GL(Uniform2iv, isCallValid, context, locationPacked, count, value);
3669 }
3670 else
3671 {
3672 GenerateContextLostErrorOnCurrentGlobalContext();
3673 }
3674 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3675 }
3676
GL_Uniform3f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2)3677 void GL_APIENTRY GL_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
3678 {
3679 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3680 Context *context = GetValidGlobalContext();
3681 EVENT(context, GLUniform3f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f",
3682 CID(context), location, v0, v1, v2);
3683
3684 if (context)
3685 {
3686 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3687
3688 bool isCallValid =
3689 (context->skipValidation() || ValidateUniform3f(context, angle::EntryPoint::GLUniform3f,
3690 locationPacked, v0, v1, v2));
3691 if (isCallValid)
3692 {
3693 context->uniform3f(locationPacked, v0, v1, v2);
3694 }
3695 ANGLE_CAPTURE_GL(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
3696 }
3697 else
3698 {
3699 GenerateContextLostErrorOnCurrentGlobalContext();
3700 }
3701 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3702 }
3703
GL_Uniform3fv(GLint location,GLsizei count,const GLfloat * value)3704 void GL_APIENTRY GL_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
3705 {
3706 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3707 Context *context = GetValidGlobalContext();
3708 EVENT(context, GLUniform3fv,
3709 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3710 location, count, (uintptr_t)value);
3711
3712 if (context)
3713 {
3714 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3715
3716 bool isCallValid = (context->skipValidation() ||
3717 ValidateUniform3fv(context, angle::EntryPoint::GLUniform3fv,
3718 locationPacked, count, value));
3719 if (isCallValid)
3720 {
3721 context->uniform3fv(locationPacked, count, value);
3722 }
3723 ANGLE_CAPTURE_GL(Uniform3fv, isCallValid, context, locationPacked, count, value);
3724 }
3725 else
3726 {
3727 GenerateContextLostErrorOnCurrentGlobalContext();
3728 }
3729 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3730 }
3731
GL_Uniform3i(GLint location,GLint v0,GLint v1,GLint v2)3732 void GL_APIENTRY GL_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
3733 {
3734 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3735 Context *context = GetValidGlobalContext();
3736 EVENT(context, GLUniform3i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d",
3737 CID(context), location, v0, v1, v2);
3738
3739 if (context)
3740 {
3741 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3742
3743 bool isCallValid =
3744 (context->skipValidation() || ValidateUniform3i(context, angle::EntryPoint::GLUniform3i,
3745 locationPacked, v0, v1, v2));
3746 if (isCallValid)
3747 {
3748 context->uniform3i(locationPacked, v0, v1, v2);
3749 }
3750 ANGLE_CAPTURE_GL(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
3751 }
3752 else
3753 {
3754 GenerateContextLostErrorOnCurrentGlobalContext();
3755 }
3756 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3757 }
3758
GL_Uniform3iv(GLint location,GLsizei count,const GLint * value)3759 void GL_APIENTRY GL_Uniform3iv(GLint location, GLsizei count, const GLint *value)
3760 {
3761 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3762 Context *context = GetValidGlobalContext();
3763 EVENT(context, GLUniform3iv,
3764 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3765 location, count, (uintptr_t)value);
3766
3767 if (context)
3768 {
3769 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3770
3771 bool isCallValid = (context->skipValidation() ||
3772 ValidateUniform3iv(context, angle::EntryPoint::GLUniform3iv,
3773 locationPacked, count, value));
3774 if (isCallValid)
3775 {
3776 context->uniform3iv(locationPacked, count, value);
3777 }
3778 ANGLE_CAPTURE_GL(Uniform3iv, isCallValid, context, locationPacked, count, value);
3779 }
3780 else
3781 {
3782 GenerateContextLostErrorOnCurrentGlobalContext();
3783 }
3784 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3785 }
3786
GL_Uniform4f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)3787 void GL_APIENTRY GL_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
3788 {
3789 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3790 Context *context = GetValidGlobalContext();
3791 EVENT(context, GLUniform4f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
3792 CID(context), location, v0, v1, v2, v3);
3793
3794 if (context)
3795 {
3796 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3797
3798 bool isCallValid =
3799 (context->skipValidation() || ValidateUniform4f(context, angle::EntryPoint::GLUniform4f,
3800 locationPacked, v0, v1, v2, v3));
3801 if (isCallValid)
3802 {
3803 context->uniform4f(locationPacked, v0, v1, v2, v3);
3804 }
3805 ANGLE_CAPTURE_GL(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
3806 }
3807 else
3808 {
3809 GenerateContextLostErrorOnCurrentGlobalContext();
3810 }
3811 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3812 }
3813
GL_Uniform4fv(GLint location,GLsizei count,const GLfloat * value)3814 void GL_APIENTRY GL_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
3815 {
3816 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3817 Context *context = GetValidGlobalContext();
3818 EVENT(context, GLUniform4fv,
3819 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3820 location, count, (uintptr_t)value);
3821
3822 if (context)
3823 {
3824 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3825
3826 bool isCallValid = (context->skipValidation() ||
3827 ValidateUniform4fv(context, angle::EntryPoint::GLUniform4fv,
3828 locationPacked, count, value));
3829 if (isCallValid)
3830 {
3831 context->uniform4fv(locationPacked, count, value);
3832 }
3833 ANGLE_CAPTURE_GL(Uniform4fv, isCallValid, context, locationPacked, count, value);
3834 }
3835 else
3836 {
3837 GenerateContextLostErrorOnCurrentGlobalContext();
3838 }
3839 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3840 }
3841
GL_Uniform4i(GLint location,GLint v0,GLint v1,GLint v2,GLint v3)3842 void GL_APIENTRY GL_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
3843 {
3844 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3845 Context *context = GetValidGlobalContext();
3846 EVENT(context, GLUniform4i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
3847 CID(context), location, v0, v1, v2, v3);
3848
3849 if (context)
3850 {
3851 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3852
3853 bool isCallValid =
3854 (context->skipValidation() || ValidateUniform4i(context, angle::EntryPoint::GLUniform4i,
3855 locationPacked, v0, v1, v2, v3));
3856 if (isCallValid)
3857 {
3858 context->uniform4i(locationPacked, v0, v1, v2, v3);
3859 }
3860 ANGLE_CAPTURE_GL(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
3861 }
3862 else
3863 {
3864 GenerateContextLostErrorOnCurrentGlobalContext();
3865 }
3866 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3867 }
3868
GL_Uniform4iv(GLint location,GLsizei count,const GLint * value)3869 void GL_APIENTRY GL_Uniform4iv(GLint location, GLsizei count, const GLint *value)
3870 {
3871 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3872 Context *context = GetValidGlobalContext();
3873 EVENT(context, GLUniform4iv,
3874 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
3875 location, count, (uintptr_t)value);
3876
3877 if (context)
3878 {
3879 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3880
3881 bool isCallValid = (context->skipValidation() ||
3882 ValidateUniform4iv(context, angle::EntryPoint::GLUniform4iv,
3883 locationPacked, count, value));
3884 if (isCallValid)
3885 {
3886 context->uniform4iv(locationPacked, count, value);
3887 }
3888 ANGLE_CAPTURE_GL(Uniform4iv, isCallValid, context, locationPacked, count, value);
3889 }
3890 else
3891 {
3892 GenerateContextLostErrorOnCurrentGlobalContext();
3893 }
3894 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3895 }
3896
GL_UniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)3897 void GL_APIENTRY GL_UniformMatrix2fv(GLint location,
3898 GLsizei count,
3899 GLboolean transpose,
3900 const GLfloat *value)
3901 {
3902 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3903 Context *context = GetValidGlobalContext();
3904 EVENT(context, GLUniformMatrix2fv,
3905 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
3906 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
3907
3908 if (context)
3909 {
3910 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3911
3912 bool isCallValid = (context->skipValidation() ||
3913 ValidateUniformMatrix2fv(context, angle::EntryPoint::GLUniformMatrix2fv,
3914 locationPacked, count, transpose, value));
3915 if (isCallValid)
3916 {
3917 context->uniformMatrix2fv(locationPacked, count, transpose, value);
3918 }
3919 ANGLE_CAPTURE_GL(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
3920 value);
3921 }
3922 else
3923 {
3924 GenerateContextLostErrorOnCurrentGlobalContext();
3925 }
3926 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3927 }
3928
GL_UniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)3929 void GL_APIENTRY GL_UniformMatrix3fv(GLint location,
3930 GLsizei count,
3931 GLboolean transpose,
3932 const GLfloat *value)
3933 {
3934 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3935 Context *context = GetValidGlobalContext();
3936 EVENT(context, GLUniformMatrix3fv,
3937 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
3938 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
3939
3940 if (context)
3941 {
3942 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3943
3944 bool isCallValid = (context->skipValidation() ||
3945 ValidateUniformMatrix3fv(context, angle::EntryPoint::GLUniformMatrix3fv,
3946 locationPacked, count, transpose, value));
3947 if (isCallValid)
3948 {
3949 context->uniformMatrix3fv(locationPacked, count, transpose, value);
3950 }
3951 ANGLE_CAPTURE_GL(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
3952 value);
3953 }
3954 else
3955 {
3956 GenerateContextLostErrorOnCurrentGlobalContext();
3957 }
3958 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3959 }
3960
GL_UniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)3961 void GL_APIENTRY GL_UniformMatrix4fv(GLint location,
3962 GLsizei count,
3963 GLboolean transpose,
3964 const GLfloat *value)
3965 {
3966 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3967 Context *context = GetValidGlobalContext();
3968 EVENT(context, GLUniformMatrix4fv,
3969 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
3970 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
3971
3972 if (context)
3973 {
3974 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3975
3976 bool isCallValid = (context->skipValidation() ||
3977 ValidateUniformMatrix4fv(context, angle::EntryPoint::GLUniformMatrix4fv,
3978 locationPacked, count, transpose, value));
3979 if (isCallValid)
3980 {
3981 context->uniformMatrix4fv(locationPacked, count, transpose, value);
3982 }
3983 ANGLE_CAPTURE_GL(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
3984 value);
3985 }
3986 else
3987 {
3988 GenerateContextLostErrorOnCurrentGlobalContext();
3989 }
3990 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3991 }
3992
GL_UseProgram(GLuint program)3993 void GL_APIENTRY GL_UseProgram(GLuint program)
3994 {
3995 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3996 Context *context = GetValidGlobalContext();
3997 EVENT(context, GLUseProgram, "context = %d, program = %u", CID(context), program);
3998
3999 if (context)
4000 {
4001 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4002 SCOPED_SHARE_CONTEXT_LOCK(context);
4003 bool isCallValid =
4004 (context->skipValidation() ||
4005 ValidateUseProgram(context, angle::EntryPoint::GLUseProgram, programPacked));
4006 if (isCallValid)
4007 {
4008 context->useProgram(programPacked);
4009 }
4010 ANGLE_CAPTURE_GL(UseProgram, isCallValid, context, programPacked);
4011 }
4012 else
4013 {
4014 GenerateContextLostErrorOnCurrentGlobalContext();
4015 }
4016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4017 }
4018
GL_ValidateProgram(GLuint program)4019 void GL_APIENTRY GL_ValidateProgram(GLuint program)
4020 {
4021 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4022 Context *context = GetValidGlobalContext();
4023 EVENT(context, GLValidateProgram, "context = %d, program = %u", CID(context), program);
4024
4025 if (context)
4026 {
4027 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4028 SCOPED_SHARE_CONTEXT_LOCK(context);
4029 bool isCallValid =
4030 (context->skipValidation() ||
4031 ValidateValidateProgram(context, angle::EntryPoint::GLValidateProgram, programPacked));
4032 if (isCallValid)
4033 {
4034 context->validateProgram(programPacked);
4035 }
4036 ANGLE_CAPTURE_GL(ValidateProgram, isCallValid, context, programPacked);
4037 }
4038 else
4039 {
4040 GenerateContextLostErrorOnCurrentGlobalContext();
4041 }
4042 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4043 }
4044
GL_VertexAttrib1f(GLuint index,GLfloat x)4045 void GL_APIENTRY GL_VertexAttrib1f(GLuint index, GLfloat x)
4046 {
4047 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4048 Context *context = GetValidGlobalContext();
4049 EVENT(context, GLVertexAttrib1f, "context = %d, index = %u, x = %f", CID(context), index, x);
4050
4051 if (context)
4052 {
4053 bool isCallValid = (context->skipValidation() ||
4054 ValidateVertexAttrib1f(context->getPrivateState(),
4055 context->getMutableErrorSetForValidation(),
4056 angle::EntryPoint::GLVertexAttrib1f, index, x));
4057 if (isCallValid)
4058 {
4059 ContextPrivateVertexAttrib1f(context->getMutablePrivateState(),
4060 context->getMutablePrivateStateCache(), index, x);
4061 }
4062 ANGLE_CAPTURE_GL(VertexAttrib1f, isCallValid, context, index, x);
4063 }
4064 else
4065 {
4066 GenerateContextLostErrorOnCurrentGlobalContext();
4067 }
4068 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4069 }
4070
GL_VertexAttrib1fv(GLuint index,const GLfloat * v)4071 void GL_APIENTRY GL_VertexAttrib1fv(GLuint index, const GLfloat *v)
4072 {
4073 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4074 Context *context = GetValidGlobalContext();
4075 EVENT(context, GLVertexAttrib1fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
4076 CID(context), index, (uintptr_t)v);
4077
4078 if (context)
4079 {
4080 bool isCallValid =
4081 (context->skipValidation() ||
4082 ValidateVertexAttrib1fv(context->getPrivateState(),
4083 context->getMutableErrorSetForValidation(),
4084 angle::EntryPoint::GLVertexAttrib1fv, index, v));
4085 if (isCallValid)
4086 {
4087 ContextPrivateVertexAttrib1fv(context->getMutablePrivateState(),
4088 context->getMutablePrivateStateCache(), index, v);
4089 }
4090 ANGLE_CAPTURE_GL(VertexAttrib1fv, isCallValid, context, index, v);
4091 }
4092 else
4093 {
4094 GenerateContextLostErrorOnCurrentGlobalContext();
4095 }
4096 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4097 }
4098
GL_VertexAttrib2f(GLuint index,GLfloat x,GLfloat y)4099 void GL_APIENTRY GL_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
4100 {
4101 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4102 Context *context = GetValidGlobalContext();
4103 EVENT(context, GLVertexAttrib2f, "context = %d, index = %u, x = %f, y = %f", CID(context),
4104 index, x, y);
4105
4106 if (context)
4107 {
4108 bool isCallValid =
4109 (context->skipValidation() ||
4110 ValidateVertexAttrib2f(context->getPrivateState(),
4111 context->getMutableErrorSetForValidation(),
4112 angle::EntryPoint::GLVertexAttrib2f, index, x, y));
4113 if (isCallValid)
4114 {
4115 ContextPrivateVertexAttrib2f(context->getMutablePrivateState(),
4116 context->getMutablePrivateStateCache(), index, x, y);
4117 }
4118 ANGLE_CAPTURE_GL(VertexAttrib2f, isCallValid, context, index, x, y);
4119 }
4120 else
4121 {
4122 GenerateContextLostErrorOnCurrentGlobalContext();
4123 }
4124 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4125 }
4126
GL_VertexAttrib2fv(GLuint index,const GLfloat * v)4127 void GL_APIENTRY GL_VertexAttrib2fv(GLuint index, const GLfloat *v)
4128 {
4129 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4130 Context *context = GetValidGlobalContext();
4131 EVENT(context, GLVertexAttrib2fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
4132 CID(context), index, (uintptr_t)v);
4133
4134 if (context)
4135 {
4136 bool isCallValid =
4137 (context->skipValidation() ||
4138 ValidateVertexAttrib2fv(context->getPrivateState(),
4139 context->getMutableErrorSetForValidation(),
4140 angle::EntryPoint::GLVertexAttrib2fv, index, v));
4141 if (isCallValid)
4142 {
4143 ContextPrivateVertexAttrib2fv(context->getMutablePrivateState(),
4144 context->getMutablePrivateStateCache(), index, v);
4145 }
4146 ANGLE_CAPTURE_GL(VertexAttrib2fv, isCallValid, context, index, v);
4147 }
4148 else
4149 {
4150 GenerateContextLostErrorOnCurrentGlobalContext();
4151 }
4152 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4153 }
4154
GL_VertexAttrib3f(GLuint index,GLfloat x,GLfloat y,GLfloat z)4155 void GL_APIENTRY GL_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
4156 {
4157 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4158 Context *context = GetValidGlobalContext();
4159 EVENT(context, GLVertexAttrib3f, "context = %d, index = %u, x = %f, y = %f, z = %f",
4160 CID(context), index, x, y, z);
4161
4162 if (context)
4163 {
4164 bool isCallValid =
4165 (context->skipValidation() ||
4166 ValidateVertexAttrib3f(context->getPrivateState(),
4167 context->getMutableErrorSetForValidation(),
4168 angle::EntryPoint::GLVertexAttrib3f, index, x, y, z));
4169 if (isCallValid)
4170 {
4171 ContextPrivateVertexAttrib3f(context->getMutablePrivateState(),
4172 context->getMutablePrivateStateCache(), index, x, y, z);
4173 }
4174 ANGLE_CAPTURE_GL(VertexAttrib3f, isCallValid, context, index, x, y, z);
4175 }
4176 else
4177 {
4178 GenerateContextLostErrorOnCurrentGlobalContext();
4179 }
4180 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4181 }
4182
GL_VertexAttrib3fv(GLuint index,const GLfloat * v)4183 void GL_APIENTRY GL_VertexAttrib3fv(GLuint index, const GLfloat *v)
4184 {
4185 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4186 Context *context = GetValidGlobalContext();
4187 EVENT(context, GLVertexAttrib3fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
4188 CID(context), index, (uintptr_t)v);
4189
4190 if (context)
4191 {
4192 bool isCallValid =
4193 (context->skipValidation() ||
4194 ValidateVertexAttrib3fv(context->getPrivateState(),
4195 context->getMutableErrorSetForValidation(),
4196 angle::EntryPoint::GLVertexAttrib3fv, index, v));
4197 if (isCallValid)
4198 {
4199 ContextPrivateVertexAttrib3fv(context->getMutablePrivateState(),
4200 context->getMutablePrivateStateCache(), index, v);
4201 }
4202 ANGLE_CAPTURE_GL(VertexAttrib3fv, isCallValid, context, index, v);
4203 }
4204 else
4205 {
4206 GenerateContextLostErrorOnCurrentGlobalContext();
4207 }
4208 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4209 }
4210
GL_VertexAttrib4f(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)4211 void GL_APIENTRY GL_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4212 {
4213 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4214 Context *context = GetValidGlobalContext();
4215 EVENT(context, GLVertexAttrib4f, "context = %d, index = %u, x = %f, y = %f, z = %f, w = %f",
4216 CID(context), index, x, y, z, w);
4217
4218 if (context)
4219 {
4220 bool isCallValid =
4221 (context->skipValidation() ||
4222 ValidateVertexAttrib4f(context->getPrivateState(),
4223 context->getMutableErrorSetForValidation(),
4224 angle::EntryPoint::GLVertexAttrib4f, index, x, y, z, w));
4225 if (isCallValid)
4226 {
4227 ContextPrivateVertexAttrib4f(context->getMutablePrivateState(),
4228 context->getMutablePrivateStateCache(), index, x, y, z, w);
4229 }
4230 ANGLE_CAPTURE_GL(VertexAttrib4f, isCallValid, context, index, x, y, z, w);
4231 }
4232 else
4233 {
4234 GenerateContextLostErrorOnCurrentGlobalContext();
4235 }
4236 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4237 }
4238
GL_VertexAttrib4fv(GLuint index,const GLfloat * v)4239 void GL_APIENTRY GL_VertexAttrib4fv(GLuint index, const GLfloat *v)
4240 {
4241 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4242 Context *context = GetValidGlobalContext();
4243 EVENT(context, GLVertexAttrib4fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
4244 CID(context), index, (uintptr_t)v);
4245
4246 if (context)
4247 {
4248 bool isCallValid =
4249 (context->skipValidation() ||
4250 ValidateVertexAttrib4fv(context->getPrivateState(),
4251 context->getMutableErrorSetForValidation(),
4252 angle::EntryPoint::GLVertexAttrib4fv, index, v));
4253 if (isCallValid)
4254 {
4255 ContextPrivateVertexAttrib4fv(context->getMutablePrivateState(),
4256 context->getMutablePrivateStateCache(), index, v);
4257 }
4258 ANGLE_CAPTURE_GL(VertexAttrib4fv, isCallValid, context, index, v);
4259 }
4260 else
4261 {
4262 GenerateContextLostErrorOnCurrentGlobalContext();
4263 }
4264 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4265 }
4266
GL_VertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void * pointer)4267 void GL_APIENTRY GL_VertexAttribPointer(GLuint index,
4268 GLint size,
4269 GLenum type,
4270 GLboolean normalized,
4271 GLsizei stride,
4272 const void *pointer)
4273 {
4274 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4275 Context *context = GetValidGlobalContext();
4276 EVENT(context, GLVertexAttribPointer,
4277 "context = %d, index = %u, size = %d, type = %s, normalized = %s, stride = %d, pointer = "
4278 "0x%016" PRIxPTR "",
4279 CID(context), index, size, GLenumToString(GLESEnum::VertexAttribPointerType, type),
4280 GLbooleanToString(normalized), stride, (uintptr_t)pointer);
4281
4282 if (context)
4283 {
4284 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
4285 SCOPED_SHARE_CONTEXT_LOCK(context);
4286 bool isCallValid =
4287 (context->skipValidation() ||
4288 ValidateVertexAttribPointer(context, angle::EntryPoint::GLVertexAttribPointer, index,
4289 size, typePacked, normalized, stride, pointer));
4290 if (isCallValid)
4291 {
4292 context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
4293 }
4294 ANGLE_CAPTURE_GL(VertexAttribPointer, isCallValid, context, index, size, typePacked,
4295 normalized, stride, pointer);
4296 }
4297 else
4298 {
4299 GenerateContextLostErrorOnCurrentGlobalContext();
4300 }
4301 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4302 }
4303
GL_Viewport(GLint x,GLint y,GLsizei width,GLsizei height)4304 void GL_APIENTRY GL_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
4305 {
4306 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4307 Context *context = GetValidGlobalContext();
4308 EVENT(context, GLViewport, "context = %d, x = %d, y = %d, width = %d, height = %d",
4309 CID(context), x, y, width, height);
4310
4311 if (context)
4312 {
4313 bool isCallValid = (context->skipValidation() ||
4314 ValidateViewport(context->getPrivateState(),
4315 context->getMutableErrorSetForValidation(),
4316 angle::EntryPoint::GLViewport, x, y, width, height));
4317 if (isCallValid)
4318 {
4319 ContextPrivateViewport(context->getMutablePrivateState(),
4320 context->getMutablePrivateStateCache(), x, y, width, height);
4321 }
4322 ANGLE_CAPTURE_GL(Viewport, isCallValid, context, x, y, width, height);
4323 }
4324 else
4325 {
4326 GenerateContextLostErrorOnCurrentGlobalContext();
4327 }
4328 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4329 }
4330
4331 } // extern "C"
4332