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