CoCalc -- entry_points_gles_ext

GitHub Repository: PojavLauncherTeam/angle
Path: blob/main_old/src/libGLESv2/entry_points_gles_ext_autogen.cpp
¹⁶⁹³ views
1
// GENERATED FILE - DO NOT EDIT.
2
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.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_ext_autogen.cpp:
9
//   Defines the GLES extension entry points.
10

11
#include "libGLESv2/entry_points_gles_ext_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_ext_autogen.h"
17
#include "libANGLE/capture/gl_enum_utils.h"
18
#include "libANGLE/entry_points_utils.h"
19
#include "libANGLE/validationESEXT.h"
20
#include "libGLESv2/global_state.h"
21

22
using namespace gl;
23

24
#include "libANGLE/capture/capture_gles_1_0_autogen.h"
25
#include "libANGLE/capture/capture_gles_2_0_autogen.h"
26
#include "libANGLE/capture/capture_gles_3_0_autogen.h"
27
#include "libANGLE/capture/capture_gles_3_1_autogen.h"
28
#include "libANGLE/capture/capture_gles_3_2_autogen.h"
29
#include "libANGLE/validationES1.h"
30
#include "libANGLE/validationES2.h"
31
#include "libANGLE/validationES3.h"
32
#include "libANGLE/validationES31.h"
33
#include "libANGLE/validationES32.h"
34

35
using namespace gl;
36

37
extern "C" {
38

39
// GL_ANGLE_base_vertex_base_instance
40
void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode,
41
                                                         GLint first,
42
                                                         GLsizei count,
43
                                                         GLsizei instanceCount,
44
                                                         GLuint baseInstance)
45
{
46
    Context *context = GetValidGlobalContext();
47
    EVENT(context, GLDrawArraysInstancedBaseInstanceANGLE,
48
          "context = %d, mode = %s, first = %d, count = %d, instanceCount = %d, baseInstance = %u",
49
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count,
50
          instanceCount, baseInstance);
51

52
    if (context)
53
    {
54
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
55
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
56
        bool isCallValid                                      = (context->skipValidation() ||
57
                            ValidateDrawArraysInstancedBaseInstanceANGLE(
58
                                context, modePacked, first, count, instanceCount, baseInstance));
59
        if (isCallValid)
60
        {
61
            context->drawArraysInstancedBaseInstance(modePacked, first, count, instanceCount,
62
                                                     baseInstance);
63
        }
64
        ANGLE_CAPTURE(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, first,
65
                      count, instanceCount, baseInstance);
66
    }
67
    else
68
    {
69
        GenerateContextLostErrorOnCurrentGlobalContext();
70
    }
71
}
72

73
void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
74
                                                                     GLsizei count,
75
                                                                     GLenum type,
76
                                                                     const GLvoid *indices,
77
                                                                     GLsizei instanceCounts,
78
                                                                     GLint baseVertex,
79
                                                                     GLuint baseInstance)
80
{
81
    Context *context = GetValidGlobalContext();
82
    EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
83
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
84
          ", instanceCounts = %d, baseVertex = %d, baseInstance = %u",
85
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
86
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instanceCounts,
87
          baseVertex, baseInstance);
88

89
    if (context)
90
    {
91
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
92
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
93
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
94
        bool isCallValid =
95
            (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE(
96
                                              context, modePacked, count, typePacked, indices,
97
                                              instanceCounts, baseVertex, baseInstance));
98
        if (isCallValid)
99
        {
100
            context->drawElementsInstancedBaseVertexBaseInstance(
101
                modePacked, count, typePacked, indices, instanceCounts, baseVertex, baseInstance);
102
        }
103
        ANGLE_CAPTURE(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
104
                      modePacked, count, typePacked, indices, instanceCounts, baseVertex,
105
                      baseInstance);
106
    }
107
    else
108
    {
109
        GenerateContextLostErrorOnCurrentGlobalContext();
110
    }
111
}
112

113
void GL_APIENTRY GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
114
                                                              const GLint *firsts,
115
                                                              const GLsizei *counts,
116
                                                              const GLsizei *instanceCounts,
117
                                                              const GLuint *baseInstances,
118
                                                              GLsizei drawcount)
119
{
120
    Context *context = GetValidGlobalContext();
121
    EVENT(context, GLMultiDrawArraysInstancedBaseInstanceANGLE,
122
          "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
123
          ", instanceCounts = 0x%016" PRIxPTR ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d",
124
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
125
          (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount);
126

127
    if (context)
128
    {
129
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
130
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
131
        bool isCallValid =
132
            (context->skipValidation() ||
133
             ValidateMultiDrawArraysInstancedBaseInstanceANGLE(
134
                 context, modePacked, firsts, counts, instanceCounts, baseInstances, drawcount));
135
        if (isCallValid)
136
        {
137
            context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts,
138
                                                          instanceCounts, baseInstances, drawcount);
139
        }
140
        ANGLE_CAPTURE(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked,
141
                      firsts, counts, instanceCounts, baseInstances, drawcount);
142
    }
143
    else
144
    {
145
        GenerateContextLostErrorOnCurrentGlobalContext();
146
    }
147
}
148

149
void GL_APIENTRY
150
GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
151
                                                         const GLsizei *counts,
152
                                                         GLenum type,
153
                                                         const GLvoid *const *indices,
154
                                                         const GLsizei *instanceCounts,
155
                                                         const GLint *baseVertices,
156
                                                         const GLuint *baseInstances,
157
                                                         GLsizei drawcount)
158
{
159
    Context *context = GetValidGlobalContext();
160
    EVENT(context, GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
161
          "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
162
          ", instanceCounts = 0x%016" PRIxPTR ", baseVertices = 0x%016" PRIxPTR
163
          ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d",
164
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
165
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
166
          (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount);
167

168
    if (context)
169
    {
170
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
171
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
172
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
173
        bool isCallValid                                      = (context->skipValidation() ||
174
                            ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
175
                                context, modePacked, counts, typePacked, indices, instanceCounts,
176
                                baseVertices, baseInstances, drawcount));
177
        if (isCallValid)
178
        {
179
            context->multiDrawElementsInstancedBaseVertexBaseInstance(
180
                modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
181
                baseInstances, drawcount);
182
        }
183
        ANGLE_CAPTURE(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
184
                      modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
185
                      baseInstances, drawcount);
186
    }
187
    else
188
    {
189
        GenerateContextLostErrorOnCurrentGlobalContext();
190
    }
191
}
192

193
// GL_ANGLE_copy_texture_3d
194
void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId,
195
                                       GLint sourceLevel,
196
                                       GLenum destTarget,
197
                                       GLuint destId,
198
                                       GLint destLevel,
199
                                       GLint internalFormat,
200
                                       GLenum destType,
201
                                       GLboolean unpackFlipY,
202
                                       GLboolean unpackPremultiplyAlpha,
203
                                       GLboolean unpackUnmultiplyAlpha)
204
{
205
    Context *context = GetValidGlobalContext();
206
    EVENT(context, GLCopyTexture3DANGLE,
207
          "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
208
          "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = "
209
          "%s, unpackUnmultiplyAlpha = %s",
210
          CID(context), sourceId, sourceLevel,
211
          GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
212
          GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
213
          GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
214

215
    if (context)
216
    {
217
        TextureID sourceIdPacked       = PackParam<TextureID>(sourceId);
218
        TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
219
        TextureID destIdPacked         = PackParam<TextureID>(destId);
220
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
221
        bool isCallValid                                      = (context->skipValidation() ||
222
                            ValidateCopyTexture3DANGLE(
223
                                context, sourceIdPacked, sourceLevel, destTargetPacked,
224
                                destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
225
                                unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
226
        if (isCallValid)
227
        {
228
            context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
229
                                   destLevel, internalFormat, destType, unpackFlipY,
230
                                   unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
231
        }
232
        ANGLE_CAPTURE(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
233
                      destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
234
                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
235
    }
236
    else
237
    {
238
        GenerateContextLostErrorOnCurrentGlobalContext();
239
    }
240
}
241

242
void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId,
243
                                          GLint sourceLevel,
244
                                          GLenum destTarget,
245
                                          GLuint destId,
246
                                          GLint destLevel,
247
                                          GLint xoffset,
248
                                          GLint yoffset,
249
                                          GLint zoffset,
250
                                          GLint x,
251
                                          GLint y,
252
                                          GLint z,
253
                                          GLint width,
254
                                          GLint height,
255
                                          GLint depth,
256
                                          GLboolean unpackFlipY,
257
                                          GLboolean unpackPremultiplyAlpha,
258
                                          GLboolean unpackUnmultiplyAlpha)
259
{
260
    Context *context = GetValidGlobalContext();
261
    EVENT(context, GLCopySubTexture3DANGLE,
262
          "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
263
          "= %d, xoffset = %d, yoffset = %d, zoffset = %d, x = %d, y = %d, z = %d, width = %d, "
264
          "height = %d, depth = %d, unpackFlipY = %s, unpackPremultiplyAlpha = %s, "
265
          "unpackUnmultiplyAlpha = %s",
266
          CID(context), sourceId, sourceLevel,
267
          GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
268
          yoffset, zoffset, x, y, z, width, height, depth, GLbooleanToString(unpackFlipY),
269
          GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
270

271
    if (context)
272
    {
273
        TextureID sourceIdPacked       = PackParam<TextureID>(sourceId);
274
        TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
275
        TextureID destIdPacked         = PackParam<TextureID>(destId);
276
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
277
        bool isCallValid =
278
            (context->skipValidation() ||
279
             ValidateCopySubTexture3DANGLE(context, sourceIdPacked, sourceLevel, destTargetPacked,
280
                                           destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y,
281
                                           z, width, height, depth, unpackFlipY,
282
                                           unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
283
        if (isCallValid)
284
        {
285
            context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
286
                                      destLevel, xoffset, yoffset, zoffset, x, y, z, width, height,
287
                                      depth, unpackFlipY, unpackPremultiplyAlpha,
288
                                      unpackUnmultiplyAlpha);
289
        }
290
        ANGLE_CAPTURE(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
291
                      destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z,
292
                      width, height, depth, unpackFlipY, unpackPremultiplyAlpha,
293
                      unpackUnmultiplyAlpha);
294
    }
295
    else
296
    {
297
        GenerateContextLostErrorOnCurrentGlobalContext();
298
    }
299
}
300

301
// GL_ANGLE_framebuffer_blit
302
void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0,
303
                                         GLint srcY0,
304
                                         GLint srcX1,
305
                                         GLint srcY1,
306
                                         GLint dstX0,
307
                                         GLint dstY0,
308
                                         GLint dstX1,
309
                                         GLint dstY1,
310
                                         GLbitfield mask,
311
                                         GLenum filter)
312
{
313
    Context *context = GetValidGlobalContext();
314
    EVENT(context, GLBlitFramebufferANGLE,
315
          "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
316
          "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
317
          CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
318
          GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
319
          GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
320

321
    if (context)
322
    {
323
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
324
        bool isCallValid                                      = (context->skipValidation() ||
325
                            ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0,
326
                                                         dstY0, dstX1, dstY1, mask, filter));
327
        if (isCallValid)
328
        {
329
            context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
330
                                     filter);
331
        }
332
        ANGLE_CAPTURE(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
333
                      dstY0, dstX1, dstY1, mask, filter);
334
    }
335
    else
336
    {
337
        GenerateContextLostErrorOnCurrentGlobalContext();
338
    }
339
}
340

341
// GL_ANGLE_framebuffer_multisample
342
void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target,
343
                                                        GLsizei samples,
344
                                                        GLenum internalformat,
345
                                                        GLsizei width,
346
                                                        GLsizei height)
347
{
348
    Context *context = GetValidGlobalContext();
349
    EVENT(context, GLRenderbufferStorageMultisampleANGLE,
350
          "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
351
          CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
352
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
353

354
    if (context)
355
    {
356
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
357
        bool isCallValid                                      = (context->skipValidation() ||
358
                            ValidateRenderbufferStorageMultisampleANGLE(
359
                                context, target, samples, internalformat, width, height));
360
        if (isCallValid)
361
        {
362
            context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
363
        }
364
        ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples,
365
                      internalformat, width, height);
366
    }
367
    else
368
    {
369
        GenerateContextLostErrorOnCurrentGlobalContext();
370
    }
371
}
372

373
// GL_ANGLE_get_image
374
void GL_APIENTRY
375
GL_GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
376
{
377
    Context *context = GetValidGlobalContext();
378
    EVENT(context, GLGetTexImageANGLE,
379
          "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR
380
          "",
381
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
382
          GLenumToString(GLenumGroup::PixelFormat, format),
383
          GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
384

385
    if (context)
386
    {
387
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
388
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
389
        bool isCallValid =
390
            (context->skipValidation() ||
391
             ValidateGetTexImageANGLE(context, targetPacked, level, format, type, pixels));
392
        if (isCallValid)
393
        {
394
            context->getTexImage(targetPacked, level, format, type, pixels);
395
        }
396
        ANGLE_CAPTURE(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type,
397
                      pixels);
398
    }
399
    else
400
    {
401
        GenerateContextLostErrorOnCurrentGlobalContext();
402
    }
403
}
404

405
void GL_APIENTRY GL_GetRenderbufferImageANGLE(GLenum target,
406
                                              GLenum format,
407
                                              GLenum type,
408
                                              void *pixels)
409
{
410
    Context *context = GetValidGlobalContext();
411
    EVENT(context, GLGetRenderbufferImageANGLE,
412
          "context = %d, target = %s, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
413
          CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
414
          GLenumToString(GLenumGroup::PixelFormat, format),
415
          GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
416

417
    if (context)
418
    {
419
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
420
        bool isCallValid =
421
            (context->skipValidation() ||
422
             ValidateGetRenderbufferImageANGLE(context, target, format, type, pixels));
423
        if (isCallValid)
424
        {
425
            context->getRenderbufferImage(target, format, type, pixels);
426
        }
427
        ANGLE_CAPTURE(GetRenderbufferImageANGLE, isCallValid, context, target, format, type,
428
                      pixels);
429
    }
430
    else
431
    {
432
        GenerateContextLostErrorOnCurrentGlobalContext();
433
    }
434
}
435

436
// GL_ANGLE_get_tex_level_parameter
437
void GL_APIENTRY GL_GetTexLevelParameterivANGLE(GLenum target,
438
                                                GLint level,
439
                                                GLenum pname,
440
                                                GLint *params)
441
{
442
    Context *context = GetValidGlobalContext();
443
    EVENT(context, GLGetTexLevelParameterivANGLE,
444
          "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
445
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
446
          GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
447

448
    if (context)
449
    {
450
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
451
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
452
        bool isCallValid =
453
            (context->skipValidation() ||
454
             ValidateGetTexLevelParameterivANGLE(context, targetPacked, level, pname, params));
455
        if (isCallValid)
456
        {
457
            context->getTexLevelParameteriv(targetPacked, level, pname, params);
458
        }
459
        ANGLE_CAPTURE(GetTexLevelParameterivANGLE, isCallValid, context, targetPacked, level, pname,
460
                      params);
461
    }
462
    else
463
    {
464
        GenerateContextLostErrorOnCurrentGlobalContext();
465
    }
466
}
467

468
void GL_APIENTRY GL_GetTexLevelParameterfvANGLE(GLenum target,
469
                                                GLint level,
470
                                                GLenum pname,
471
                                                GLfloat *params)
472
{
473
    Context *context = GetValidGlobalContext();
474
    EVENT(context, GLGetTexLevelParameterfvANGLE,
475
          "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
476
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
477
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
478

479
    if (context)
480
    {
481
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
482
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
483
        bool isCallValid =
484
            (context->skipValidation() ||
485
             ValidateGetTexLevelParameterfvANGLE(context, targetPacked, level, pname, params));
486
        if (isCallValid)
487
        {
488
            context->getTexLevelParameterfv(targetPacked, level, pname, params);
489
        }
490
        ANGLE_CAPTURE(GetTexLevelParameterfvANGLE, isCallValid, context, targetPacked, level, pname,
491
                      params);
492
    }
493
    else
494
    {
495
        GenerateContextLostErrorOnCurrentGlobalContext();
496
    }
497
}
498

499
// GL_ANGLE_instanced_arrays
500
void GL_APIENTRY GL_DrawArraysInstancedANGLE(GLenum mode,
501
                                             GLint first,
502
                                             GLsizei count,
503
                                             GLsizei primcount)
504
{
505
    Context *context = GetValidGlobalContext();
506
    EVENT(context, GLDrawArraysInstancedANGLE,
507
          "context = %d, mode = %s, first = %d, count = %d, primcount = %d", CID(context),
508
          GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, primcount);
509

510
    if (context)
511
    {
512
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
513
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
514
        bool isCallValid =
515
            (context->skipValidation() ||
516
             ValidateDrawArraysInstancedANGLE(context, modePacked, first, count, primcount));
517
        if (isCallValid)
518
        {
519
            context->drawArraysInstanced(modePacked, first, count, primcount);
520
        }
521
        ANGLE_CAPTURE(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count,
522
                      primcount);
523
    }
524
    else
525
    {
526
        GenerateContextLostErrorOnCurrentGlobalContext();
527
    }
528
}
529

530
void GL_APIENTRY GL_DrawElementsInstancedANGLE(GLenum mode,
531
                                               GLsizei count,
532
                                               GLenum type,
533
                                               const void *indices,
534
                                               GLsizei primcount)
535
{
536
    Context *context = GetValidGlobalContext();
537
    EVENT(context, GLDrawElementsInstancedANGLE,
538
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
539
          ", primcount = %d",
540
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
541
          GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, primcount);
542

543
    if (context)
544
    {
545
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
546
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
547
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
548
        bool isCallValid                                      = (context->skipValidation() ||
549
                            ValidateDrawElementsInstancedANGLE(context, modePacked, count,
550
                                                               typePacked, indices, primcount));
551
        if (isCallValid)
552
        {
553
            context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
554
        }
555
        ANGLE_CAPTURE(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count,
556
                      typePacked, indices, primcount);
557
    }
558
    else
559
    {
560
        GenerateContextLostErrorOnCurrentGlobalContext();
561
    }
562
}
563

564
void GL_APIENTRY GL_VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
565
{
566
    Context *context = GetValidGlobalContext();
567
    EVENT(context, GLVertexAttribDivisorANGLE, "context = %d, index = %u, divisor = %u",
568
          CID(context), index, divisor);
569

570
    if (context)
571
    {
572
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
573
        bool isCallValid                                      = (context->skipValidation() ||
574
                            ValidateVertexAttribDivisorANGLE(context, index, divisor));
575
        if (isCallValid)
576
        {
577
            context->vertexAttribDivisor(index, divisor);
578
        }
579
        ANGLE_CAPTURE(VertexAttribDivisorANGLE, isCallValid, context, index, divisor);
580
    }
581
    else
582
    {
583
        GenerateContextLostErrorOnCurrentGlobalContext();
584
    }
585
}
586

587
// GL_ANGLE_memory_object_flags
588
void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target,
589
                                              GLsizei levels,
590
                                              GLenum internalFormat,
591
                                              GLsizei width,
592
                                              GLsizei height,
593
                                              GLuint memory,
594
                                              GLuint64 offset,
595
                                              GLbitfield createFlags,
596
                                              GLbitfield usageFlags)
597
{
598
    Context *context = GetValidGlobalContext();
599
    EVENT(context, GLTexStorageMemFlags2DANGLE,
600
          "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
601
          "memory = %u, offset = %llu, createFlags = %s, usageFlags = %s",
602
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
603
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory,
604
          static_cast<unsigned long long>(offset),
605
          GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
606
          GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str());
607

608
    if (context)
609
    {
610
        TextureType targetPacked                              = PackParam<TextureType>(target);
611
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
612
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
613
        bool isCallValid                                      = (context->skipValidation() ||
614
                            ValidateTexStorageMemFlags2DANGLE(
615
                                context, targetPacked, levels, internalFormat, width, height,
616
                                memoryPacked, offset, createFlags, usageFlags));
617
        if (isCallValid)
618
        {
619
            context->texStorageMemFlags2D(targetPacked, levels, internalFormat, width, height,
620
                                          memoryPacked, offset, createFlags, usageFlags);
621
        }
622
        ANGLE_CAPTURE(TexStorageMemFlags2DANGLE, isCallValid, context, targetPacked, levels,
623
                      internalFormat, width, height, memoryPacked, offset, createFlags, usageFlags);
624
    }
625
    else
626
    {
627
        GenerateContextLostErrorOnCurrentGlobalContext();
628
    }
629
}
630

631
void GL_APIENTRY GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target,
632
                                                         GLsizei samples,
633
                                                         GLenum internalFormat,
634
                                                         GLsizei width,
635
                                                         GLsizei height,
636
                                                         GLboolean fixedSampleLocations,
637
                                                         GLuint memory,
638
                                                         GLuint64 offset,
639
                                                         GLbitfield createFlags,
640
                                                         GLbitfield usageFlags)
641
{
642
    Context *context = GetValidGlobalContext();
643
    EVENT(
644
        context, GLTexStorageMemFlags2DMultisampleANGLE,
645
        "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
646
        "fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, usageFlags = %s",
647
        CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
648
        GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height,
649
        GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset),
650
        GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
651
        GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str());
652

653
    if (context)
654
    {
655
        TextureType targetPacked                              = PackParam<TextureType>(target);
656
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
657
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
658
        bool isCallValid =
659
            (context->skipValidation() ||
660
             ValidateTexStorageMemFlags2DMultisampleANGLE(
661
                 context, targetPacked, samples, internalFormat, width, height,
662
                 fixedSampleLocations, memoryPacked, offset, createFlags, usageFlags));
663
        if (isCallValid)
664
        {
665
            context->texStorageMemFlags2DMultisample(targetPacked, samples, internalFormat, width,
666
                                                     height, fixedSampleLocations, memoryPacked,
667
                                                     offset, createFlags, usageFlags);
668
        }
669
        ANGLE_CAPTURE(TexStorageMemFlags2DMultisampleANGLE, isCallValid, context, targetPacked,
670
                      samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
671
                      offset, createFlags, usageFlags);
672
    }
673
    else
674
    {
675
        GenerateContextLostErrorOnCurrentGlobalContext();
676
    }
677
}
678

679
void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target,
680
                                              GLsizei levels,
681
                                              GLenum internalFormat,
682
                                              GLsizei width,
683
                                              GLsizei height,
684
                                              GLsizei depth,
685
                                              GLuint memory,
686
                                              GLuint64 offset,
687
                                              GLbitfield createFlags,
688
                                              GLbitfield usageFlags)
689
{
690
    Context *context = GetValidGlobalContext();
691
    EVENT(context, GLTexStorageMemFlags3DANGLE,
692
          "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
693
          "depth = %d, memory = %u, offset = %llu, createFlags = %s, usageFlags = %s",
694
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
695
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory,
696
          static_cast<unsigned long long>(offset),
697
          GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
698
          GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str());
699

700
    if (context)
701
    {
702
        TextureType targetPacked                              = PackParam<TextureType>(target);
703
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
704
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
705
        bool isCallValid                                      = (context->skipValidation() ||
706
                            ValidateTexStorageMemFlags3DANGLE(
707
                                context, targetPacked, levels, internalFormat, width, height, depth,
708
                                memoryPacked, offset, createFlags, usageFlags));
709
        if (isCallValid)
710
        {
711
            context->texStorageMemFlags3D(targetPacked, levels, internalFormat, width, height,
712
                                          depth, memoryPacked, offset, createFlags, usageFlags);
713
        }
714
        ANGLE_CAPTURE(TexStorageMemFlags3DANGLE, isCallValid, context, targetPacked, levels,
715
                      internalFormat, width, height, depth, memoryPacked, offset, createFlags,
716
                      usageFlags);
717
    }
718
    else
719
    {
720
        GenerateContextLostErrorOnCurrentGlobalContext();
721
    }
722
}
723

724
void GL_APIENTRY GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target,
725
                                                         GLsizei samples,
726
                                                         GLenum internalFormat,
727
                                                         GLsizei width,
728
                                                         GLsizei height,
729
                                                         GLsizei depth,
730
                                                         GLboolean fixedSampleLocations,
731
                                                         GLuint memory,
732
                                                         GLuint64 offset,
733
                                                         GLbitfield createFlags,
734
                                                         GLbitfield usageFlags)
735
{
736
    Context *context = GetValidGlobalContext();
737
    EVENT(context, GLTexStorageMemFlags3DMultisampleANGLE,
738
          "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
739
          "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, "
740
          "usageFlags = %s",
741
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
742
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth,
743
          GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset),
744
          GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
745
          GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str());
746

747
    if (context)
748
    {
749
        TextureType targetPacked                              = PackParam<TextureType>(target);
750
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
751
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
752
        bool isCallValid =
753
            (context->skipValidation() ||
754
             ValidateTexStorageMemFlags3DMultisampleANGLE(
755
                 context, targetPacked, samples, internalFormat, width, height, depth,
756
                 fixedSampleLocations, memoryPacked, offset, createFlags, usageFlags));
757
        if (isCallValid)
758
        {
759
            context->texStorageMemFlags3DMultisample(targetPacked, samples, internalFormat, width,
760
                                                     height, depth, fixedSampleLocations,
761
                                                     memoryPacked, offset, createFlags, usageFlags);
762
        }
763
        ANGLE_CAPTURE(TexStorageMemFlags3DMultisampleANGLE, isCallValid, context, targetPacked,
764
                      samples, internalFormat, width, height, depth, fixedSampleLocations,
765
                      memoryPacked, offset, createFlags, usageFlags);
766
    }
767
    else
768
    {
769
        GenerateContextLostErrorOnCurrentGlobalContext();
770
    }
771
}
772

773
// GL_ANGLE_memory_object_fuchsia
774
void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory,
775
                                                  GLuint64 size,
776
                                                  GLenum handleType,
777
                                                  GLuint handle)
778
{
779
    Context *context = GetValidGlobalContext();
780
    EVENT(context, GLImportMemoryZirconHandleANGLE,
781
          "context = %d, memory = %u, size = %llu, handleType = %s, handle = %u", CID(context),
782
          memory, static_cast<unsigned long long>(size),
783
          GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle);
784

785
    if (context)
786
    {
787
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
788
        HandleType handleTypePacked                           = PackParam<HandleType>(handleType);
789
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
790
        bool isCallValid                                      = (context->skipValidation() ||
791
                            ValidateImportMemoryZirconHandleANGLE(context, memoryPacked, size,
792
                                                                  handleTypePacked, handle));
793
        if (isCallValid)
794
        {
795
            context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle);
796
        }
797
        ANGLE_CAPTURE(ImportMemoryZirconHandleANGLE, isCallValid, context, memoryPacked, size,
798
                      handleTypePacked, handle);
799
    }
800
    else
801
    {
802
        GenerateContextLostErrorOnCurrentGlobalContext();
803
    }
804
}
805

806
// GL_ANGLE_multi_draw
807
void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode,
808
                                         const GLint *firsts,
809
                                         const GLsizei *counts,
810
                                         GLsizei drawcount)
811
{
812
    Context *context = GetValidGlobalContext();
813
    EVENT(context, GLMultiDrawArraysANGLE,
814
          "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
815
          ", drawcount = %d",
816
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
817
          (uintptr_t)counts, drawcount);
818

819
    if (context)
820
    {
821
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
822
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
823
        bool isCallValid =
824
            (context->skipValidation() ||
825
             ValidateMultiDrawArraysANGLE(context, modePacked, firsts, counts, drawcount));
826
        if (isCallValid)
827
        {
828
            context->multiDrawArrays(modePacked, firsts, counts, drawcount);
829
        }
830
        ANGLE_CAPTURE(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts,
831
                      drawcount);
832
    }
833
    else
834
    {
835
        GenerateContextLostErrorOnCurrentGlobalContext();
836
    }
837
}
838

839
void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode,
840
                                                  const GLint *firsts,
841
                                                  const GLsizei *counts,
842
                                                  const GLsizei *instanceCounts,
843
                                                  GLsizei drawcount)
844
{
845
    Context *context = GetValidGlobalContext();
846
    EVENT(context, GLMultiDrawArraysInstancedANGLE,
847
          "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
848
          ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d",
849
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
850
          (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
851

852
    if (context)
853
    {
854
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
855
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
856
        bool isCallValid                                      = (context->skipValidation() ||
857
                            ValidateMultiDrawArraysInstancedANGLE(
858
                                context, modePacked, firsts, counts, instanceCounts, drawcount));
859
        if (isCallValid)
860
        {
861
            context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
862
                                              drawcount);
863
        }
864
        ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts,
865
                      counts, instanceCounts, drawcount);
866
    }
867
    else
868
    {
869
        GenerateContextLostErrorOnCurrentGlobalContext();
870
    }
871
}
872

873
void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode,
874
                                           const GLsizei *counts,
875
                                           GLenum type,
876
                                           const GLvoid *const *indices,
877
                                           GLsizei drawcount)
878
{
879
    Context *context = GetValidGlobalContext();
880
    EVENT(context, GLMultiDrawElementsANGLE,
881
          "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
882
          ", drawcount = %d",
883
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
884
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount);
885

886
    if (context)
887
    {
888
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
889
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
890
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
891
        bool isCallValid                                      = (context->skipValidation() ||
892
                            ValidateMultiDrawElementsANGLE(context, modePacked, counts, typePacked,
893
                                                           indices, drawcount));
894
        if (isCallValid)
895
        {
896
            context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
897
        }
898
        ANGLE_CAPTURE(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts, typePacked,
899
                      indices, drawcount);
900
    }
901
    else
902
    {
903
        GenerateContextLostErrorOnCurrentGlobalContext();
904
    }
905
}
906

907
void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode,
908
                                                    const GLsizei *counts,
909
                                                    GLenum type,
910
                                                    const GLvoid *const *indices,
911
                                                    const GLsizei *instanceCounts,
912
                                                    GLsizei drawcount)
913
{
914
    Context *context = GetValidGlobalContext();
915
    EVENT(context, GLMultiDrawElementsInstancedANGLE,
916
          "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
917
          ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d",
918
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
919
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
920
          (uintptr_t)instanceCounts, drawcount);
921

922
    if (context)
923
    {
924
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
925
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
926
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
927
        bool isCallValid =
928
            (context->skipValidation() ||
929
             ValidateMultiDrawElementsInstancedANGLE(context, modePacked, counts, typePacked,
930
                                                     indices, instanceCounts, drawcount));
931
        if (isCallValid)
932
        {
933
            context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
934
                                                instanceCounts, drawcount);
935
        }
936
        ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts,
937
                      typePacked, indices, instanceCounts, drawcount);
938
    }
939
    else
940
    {
941
        GenerateContextLostErrorOnCurrentGlobalContext();
942
    }
943
}
944

945
// GL_ANGLE_program_binary
946

947
// GL_ANGLE_provoking_vertex
948
void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum mode)
949
{
950
    Context *context = GetValidGlobalContext();
951
    EVENT(context, GLProvokingVertexANGLE, "context = %d, mode = %s", CID(context),
952
          GLenumToString(GLenumGroup::VertexProvokingMode, mode));
953

954
    if (context)
955
    {
956
        ProvokingVertexConvention modePacked = PackParam<ProvokingVertexConvention>(mode);
957
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
958
        bool isCallValid =
959
            (context->skipValidation() || ValidateProvokingVertexANGLE(context, modePacked));
960
        if (isCallValid)
961
        {
962
            context->provokingVertex(modePacked);
963
        }
964
        ANGLE_CAPTURE(ProvokingVertexANGLE, isCallValid, context, modePacked);
965
    }
966
    else
967
    {
968
        GenerateContextLostErrorOnCurrentGlobalContext();
969
    }
970
}
971

972
// GL_ANGLE_request_extension
973
void GL_APIENTRY GL_RequestExtensionANGLE(const GLchar *name)
974
{
975
    Context *context = GetValidGlobalContext();
976
    EVENT(context, GLRequestExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context),
977
          (uintptr_t)name);
978

979
    if (context)
980
    {
981
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
982
        bool isCallValid =
983
            (context->skipValidation() || ValidateRequestExtensionANGLE(context, name));
984
        if (isCallValid)
985
        {
986
            context->requestExtension(name);
987
        }
988
        ANGLE_CAPTURE(RequestExtensionANGLE, isCallValid, context, name);
989
    }
990
    else
991
    {
992
        GenerateContextLostErrorOnCurrentGlobalContext();
993
    }
994
}
995

996
void GL_APIENTRY GL_DisableExtensionANGLE(const GLchar *name)
997
{
998
    Context *context = GetValidGlobalContext();
999
    EVENT(context, GLDisableExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context),
1000
          (uintptr_t)name);
1001

1002
    if (context)
1003
    {
1004
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1005
        bool isCallValid =
1006
            (context->skipValidation() || ValidateDisableExtensionANGLE(context, name));
1007
        if (isCallValid)
1008
        {
1009
            context->disableExtension(name);
1010
        }
1011
        ANGLE_CAPTURE(DisableExtensionANGLE, isCallValid, context, name);
1012
    }
1013
    else
1014
    {
1015
        GenerateContextLostErrorOnCurrentGlobalContext();
1016
    }
1017
}
1018

1019
// GL_ANGLE_robust_client_memory
1020
void GL_APIENTRY GL_GetBooleanvRobustANGLE(GLenum pname,
1021
                                           GLsizei bufSize,
1022
                                           GLsizei *length,
1023
                                           GLboolean *params)
1024
{
1025
    Context *context = GetValidGlobalContext();
1026
    EVENT(context, GLGetBooleanvRobustANGLE,
1027
          "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1028
          ", params = 0x%016" PRIxPTR "",
1029
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1030
          (uintptr_t)length, (uintptr_t)params);
1031

1032
    if (context)
1033
    {
1034
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1035
        bool isCallValid =
1036
            (context->skipValidation() ||
1037
             ValidateGetBooleanvRobustANGLE(context, pname, bufSize, length, params));
1038
        if (isCallValid)
1039
        {
1040
            context->getBooleanvRobust(pname, bufSize, length, params);
1041
        }
1042
        ANGLE_CAPTURE(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
1043
    }
1044
    else
1045
    {
1046
        GenerateContextLostErrorOnCurrentGlobalContext();
1047
    }
1048
}
1049

1050
void GL_APIENTRY GL_GetBufferParameterivRobustANGLE(GLenum target,
1051
                                                    GLenum pname,
1052
                                                    GLsizei bufSize,
1053
                                                    GLsizei *length,
1054
                                                    GLint *params)
1055
{
1056
    Context *context = GetValidGlobalContext();
1057
    EVENT(context, GLGetBufferParameterivRobustANGLE,
1058
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1059
          ", params = 0x%016" PRIxPTR "",
1060
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1061
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1062
          (uintptr_t)params);
1063

1064
    if (context)
1065
    {
1066
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
1067
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1068
        bool isCallValid                                      = (context->skipValidation() ||
1069
                            ValidateGetBufferParameterivRobustANGLE(context, targetPacked, pname,
1070
                                                                    bufSize, length, params));
1071
        if (isCallValid)
1072
        {
1073
            context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
1074
        }
1075
        ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
1076
                      bufSize, length, params);
1077
    }
1078
    else
1079
    {
1080
        GenerateContextLostErrorOnCurrentGlobalContext();
1081
    }
1082
}
1083

1084
void GL_APIENTRY GL_GetFloatvRobustANGLE(GLenum pname,
1085
                                         GLsizei bufSize,
1086
                                         GLsizei *length,
1087
                                         GLfloat *params)
1088
{
1089
    Context *context = GetValidGlobalContext();
1090
    EVENT(context, GLGetFloatvRobustANGLE,
1091
          "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1092
          ", params = 0x%016" PRIxPTR "",
1093
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1094
          (uintptr_t)length, (uintptr_t)params);
1095

1096
    if (context)
1097
    {
1098
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1099
        bool isCallValid                                      = (context->skipValidation() ||
1100
                            ValidateGetFloatvRobustANGLE(context, pname, bufSize, length, params));
1101
        if (isCallValid)
1102
        {
1103
            context->getFloatvRobust(pname, bufSize, length, params);
1104
        }
1105
        ANGLE_CAPTURE(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
1106
    }
1107
    else
1108
    {
1109
        GenerateContextLostErrorOnCurrentGlobalContext();
1110
    }
1111
}
1112

1113
void GL_APIENTRY GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
1114
                                                                   GLenum attachment,
1115
                                                                   GLenum pname,
1116
                                                                   GLsizei bufSize,
1117
                                                                   GLsizei *length,
1118
                                                                   GLint *params)
1119
{
1120
    Context *context = GetValidGlobalContext();
1121
    EVENT(context, GLGetFramebufferAttachmentParameterivRobustANGLE,
1122
          "context = %d, target = %s, attachment = %s, pname = %s, bufSize = %d, length = "
1123
          "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
1124
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1125
          GLenumToString(GLenumGroup::DefaultGroup, attachment),
1126
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1127
          (uintptr_t)params);
1128

1129
    if (context)
1130
    {
1131
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1132
        bool isCallValid                                      = (context->skipValidation() ||
1133
                            ValidateGetFramebufferAttachmentParameterivRobustANGLE(
1134
                                context, target, attachment, pname, bufSize, length, params));
1135
        if (isCallValid)
1136
        {
1137
            context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
1138
                                                               length, params);
1139
        }
1140
        ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context, target,
1141
                      attachment, pname, bufSize, length, params);
1142
    }
1143
    else
1144
    {
1145
        GenerateContextLostErrorOnCurrentGlobalContext();
1146
    }
1147
}
1148

1149
void GL_APIENTRY GL_GetIntegervRobustANGLE(GLenum pname,
1150
                                           GLsizei bufSize,
1151
                                           GLsizei *length,
1152
                                           GLint *data)
1153
{
1154
    Context *context = GetValidGlobalContext();
1155
    EVENT(context, GLGetIntegervRobustANGLE,
1156
          "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1157
          ", data = 0x%016" PRIxPTR "",
1158
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1159
          (uintptr_t)length, (uintptr_t)data);
1160

1161
    if (context)
1162
    {
1163
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1164
        bool isCallValid                                      = (context->skipValidation() ||
1165
                            ValidateGetIntegervRobustANGLE(context, pname, bufSize, length, data));
1166
        if (isCallValid)
1167
        {
1168
            context->getIntegervRobust(pname, bufSize, length, data);
1169
        }
1170
        ANGLE_CAPTURE(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length, data);
1171
    }
1172
    else
1173
    {
1174
        GenerateContextLostErrorOnCurrentGlobalContext();
1175
    }
1176
}
1177

1178
void GL_APIENTRY GL_GetProgramivRobustANGLE(GLuint program,
1179
                                            GLenum pname,
1180
                                            GLsizei bufSize,
1181
                                            GLsizei *length,
1182
                                            GLint *params)
1183
{
1184
    Context *context = GetGlobalContext();
1185
    EVENT(context, GLGetProgramivRobustANGLE,
1186
          "context = %d, program = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1187
          ", params = 0x%016" PRIxPTR "",
1188
          CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1189
          (uintptr_t)length, (uintptr_t)params);
1190

1191
    if (context)
1192
    {
1193
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
1194
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1195
        bool isCallValid                                      = (context->skipValidation() ||
1196
                            ValidateGetProgramivRobustANGLE(context, programPacked, pname, bufSize,
1197
                                                            length, params));
1198
        if (isCallValid)
1199
        {
1200
            context->getProgramivRobust(programPacked, pname, bufSize, length, params);
1201
        }
1202
        ANGLE_CAPTURE(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname, bufSize,
1203
                      length, params);
1204
    }
1205
    else
1206
    {}
1207
}
1208

1209
void GL_APIENTRY GL_GetRenderbufferParameterivRobustANGLE(GLenum target,
1210
                                                          GLenum pname,
1211
                                                          GLsizei bufSize,
1212
                                                          GLsizei *length,
1213
                                                          GLint *params)
1214
{
1215
    Context *context = GetValidGlobalContext();
1216
    EVENT(context, GLGetRenderbufferParameterivRobustANGLE,
1217
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1218
          ", params = 0x%016" PRIxPTR "",
1219
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1220
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1221
          (uintptr_t)params);
1222

1223
    if (context)
1224
    {
1225
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1226
        bool isCallValid =
1227
            (context->skipValidation() || ValidateGetRenderbufferParameterivRobustANGLE(
1228
                                              context, target, pname, bufSize, length, params));
1229
        if (isCallValid)
1230
        {
1231
            context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
1232
        }
1233
        ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname,
1234
                      bufSize, length, params);
1235
    }
1236
    else
1237
    {
1238
        GenerateContextLostErrorOnCurrentGlobalContext();
1239
    }
1240
}
1241

1242
void GL_APIENTRY GL_GetShaderivRobustANGLE(GLuint shader,
1243
                                           GLenum pname,
1244
                                           GLsizei bufSize,
1245
                                           GLsizei *length,
1246
                                           GLint *params)
1247
{
1248
    Context *context = GetGlobalContext();
1249
    EVENT(context, GLGetShaderivRobustANGLE,
1250
          "context = %d, shader = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1251
          ", params = 0x%016" PRIxPTR "",
1252
          CID(context), shader, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1253
          (uintptr_t)length, (uintptr_t)params);
1254

1255
    if (context)
1256
    {
1257
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
1258
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1259
        bool isCallValid =
1260
            (context->skipValidation() ||
1261
             ValidateGetShaderivRobustANGLE(context, shaderPacked, pname, bufSize, length, params));
1262
        if (isCallValid)
1263
        {
1264
            context->getShaderivRobust(shaderPacked, pname, bufSize, length, params);
1265
        }
1266
        ANGLE_CAPTURE(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize,
1267
                      length, params);
1268
    }
1269
    else
1270
    {}
1271
}
1272

1273
void GL_APIENTRY GL_GetTexParameterfvRobustANGLE(GLenum target,
1274
                                                 GLenum pname,
1275
                                                 GLsizei bufSize,
1276
                                                 GLsizei *length,
1277
                                                 GLfloat *params)
1278
{
1279
    Context *context = GetValidGlobalContext();
1280
    EVENT(context, GLGetTexParameterfvRobustANGLE,
1281
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1282
          ", params = 0x%016" PRIxPTR "",
1283
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1284
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1285
          (uintptr_t)params);
1286

1287
    if (context)
1288
    {
1289
        TextureType targetPacked                              = PackParam<TextureType>(target);
1290
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1291
        bool isCallValid                                      = (context->skipValidation() ||
1292
                            ValidateGetTexParameterfvRobustANGLE(context, targetPacked, pname,
1293
                                                                 bufSize, length, params));
1294
        if (isCallValid)
1295
        {
1296
            context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
1297
        }
1298
        ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname,
1299
                      bufSize, length, params);
1300
    }
1301
    else
1302
    {
1303
        GenerateContextLostErrorOnCurrentGlobalContext();
1304
    }
1305
}
1306

1307
void GL_APIENTRY GL_GetTexParameterivRobustANGLE(GLenum target,
1308
                                                 GLenum pname,
1309
                                                 GLsizei bufSize,
1310
                                                 GLsizei *length,
1311
                                                 GLint *params)
1312
{
1313
    Context *context = GetValidGlobalContext();
1314
    EVENT(context, GLGetTexParameterivRobustANGLE,
1315
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1316
          ", params = 0x%016" PRIxPTR "",
1317
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1318
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1319
          (uintptr_t)params);
1320

1321
    if (context)
1322
    {
1323
        TextureType targetPacked                              = PackParam<TextureType>(target);
1324
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1325
        bool isCallValid                                      = (context->skipValidation() ||
1326
                            ValidateGetTexParameterivRobustANGLE(context, targetPacked, pname,
1327
                                                                 bufSize, length, params));
1328
        if (isCallValid)
1329
        {
1330
            context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
1331
        }
1332
        ANGLE_CAPTURE(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
1333
                      bufSize, length, params);
1334
    }
1335
    else
1336
    {
1337
        GenerateContextLostErrorOnCurrentGlobalContext();
1338
    }
1339
}
1340

1341
void GL_APIENTRY GL_GetUniformfvRobustANGLE(GLuint program,
1342
                                            GLint location,
1343
                                            GLsizei bufSize,
1344
                                            GLsizei *length,
1345
                                            GLfloat *params)
1346
{
1347
    Context *context = GetValidGlobalContext();
1348
    EVENT(context, GLGetUniformfvRobustANGLE,
1349
          "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
1350
          ", params = 0x%016" PRIxPTR "",
1351
          CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1352

1353
    if (context)
1354
    {
1355
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
1356
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1357
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1358
        bool isCallValid                                      = (context->skipValidation() ||
1359
                            ValidateGetUniformfvRobustANGLE(context, programPacked, locationPacked,
1360
                                                            bufSize, length, params));
1361
        if (isCallValid)
1362
        {
1363
            context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
1364
        }
1365
        ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
1366
                      bufSize, length, params);
1367
    }
1368
    else
1369
    {
1370
        GenerateContextLostErrorOnCurrentGlobalContext();
1371
    }
1372
}
1373

1374
void GL_APIENTRY GL_GetUniformivRobustANGLE(GLuint program,
1375
                                            GLint location,
1376
                                            GLsizei bufSize,
1377
                                            GLsizei *length,
1378
                                            GLint *params)
1379
{
1380
    Context *context = GetValidGlobalContext();
1381
    EVENT(context, GLGetUniformivRobustANGLE,
1382
          "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
1383
          ", params = 0x%016" PRIxPTR "",
1384
          CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1385

1386
    if (context)
1387
    {
1388
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
1389
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1390
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1391
        bool isCallValid                                      = (context->skipValidation() ||
1392
                            ValidateGetUniformivRobustANGLE(context, programPacked, locationPacked,
1393
                                                            bufSize, length, params));
1394
        if (isCallValid)
1395
        {
1396
            context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
1397
        }
1398
        ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
1399
                      bufSize, length, params);
1400
    }
1401
    else
1402
    {
1403
        GenerateContextLostErrorOnCurrentGlobalContext();
1404
    }
1405
}
1406

1407
void GL_APIENTRY GL_GetVertexAttribfvRobustANGLE(GLuint index,
1408
                                                 GLenum pname,
1409
                                                 GLsizei bufSize,
1410
                                                 GLsizei *length,
1411
                                                 GLfloat *params)
1412
{
1413
    Context *context = GetValidGlobalContext();
1414
    EVENT(context, GLGetVertexAttribfvRobustANGLE,
1415
          "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1416
          ", params = 0x%016" PRIxPTR "",
1417
          CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1418
          (uintptr_t)length, (uintptr_t)params);
1419

1420
    if (context)
1421
    {
1422
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1423
        bool isCallValid =
1424
            (context->skipValidation() ||
1425
             ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, length, params));
1426
        if (isCallValid)
1427
        {
1428
            context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
1429
        }
1430
        ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize,
1431
                      length, params);
1432
    }
1433
    else
1434
    {
1435
        GenerateContextLostErrorOnCurrentGlobalContext();
1436
    }
1437
}
1438

1439
void GL_APIENTRY GL_GetVertexAttribivRobustANGLE(GLuint index,
1440
                                                 GLenum pname,
1441
                                                 GLsizei bufSize,
1442
                                                 GLsizei *length,
1443
                                                 GLint *params)
1444
{
1445
    Context *context = GetValidGlobalContext();
1446
    EVENT(context, GLGetVertexAttribivRobustANGLE,
1447
          "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1448
          ", params = 0x%016" PRIxPTR "",
1449
          CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1450
          (uintptr_t)length, (uintptr_t)params);
1451

1452
    if (context)
1453
    {
1454
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1455
        bool isCallValid =
1456
            (context->skipValidation() ||
1457
             ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, length, params));
1458
        if (isCallValid)
1459
        {
1460
            context->getVertexAttribivRobust(index, pname, bufSize, length, params);
1461
        }
1462
        ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize,
1463
                      length, params);
1464
    }
1465
    else
1466
    {
1467
        GenerateContextLostErrorOnCurrentGlobalContext();
1468
    }
1469
}
1470

1471
void GL_APIENTRY GL_GetVertexAttribPointervRobustANGLE(GLuint index,
1472
                                                       GLenum pname,
1473
                                                       GLsizei bufSize,
1474
                                                       GLsizei *length,
1475
                                                       void **pointer)
1476
{
1477
    Context *context = GetValidGlobalContext();
1478
    EVENT(context, GLGetVertexAttribPointervRobustANGLE,
1479
          "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1480
          ", pointer = 0x%016" PRIxPTR "",
1481
          CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1482
          (uintptr_t)length, (uintptr_t)pointer);
1483

1484
    if (context)
1485
    {
1486
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1487
        bool isCallValid =
1488
            (context->skipValidation() || ValidateGetVertexAttribPointervRobustANGLE(
1489
                                              context, index, pname, bufSize, length, pointer));
1490
        if (isCallValid)
1491
        {
1492
            context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
1493
        }
1494
        ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname,
1495
                      bufSize, length, pointer);
1496
    }
1497
    else
1498
    {
1499
        GenerateContextLostErrorOnCurrentGlobalContext();
1500
    }
1501
}
1502

1503
void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x,
1504
                                          GLint y,
1505
                                          GLsizei width,
1506
                                          GLsizei height,
1507
                                          GLenum format,
1508
                                          GLenum type,
1509
                                          GLsizei bufSize,
1510
                                          GLsizei *length,
1511
                                          GLsizei *columns,
1512
                                          GLsizei *rows,
1513
                                          void *pixels)
1514
{
1515
    Context *context = GetValidGlobalContext();
1516
    EVENT(context, GLReadPixelsRobustANGLE,
1517
          "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
1518
          "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR
1519
          ", pixels = 0x%016" PRIxPTR "",
1520
          CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
1521
          GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
1522
          (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)pixels);
1523

1524
    if (context)
1525
    {
1526
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1527
        bool isCallValid =
1528
            (context->skipValidation() ||
1529
             ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
1530
                                           length, columns, rows, pixels));
1531
        if (isCallValid)
1532
        {
1533
            context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
1534
                                      rows, pixels);
1535
        }
1536
        ANGLE_CAPTURE(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
1537
                      type, bufSize, length, columns, rows, pixels);
1538
    }
1539
    else
1540
    {
1541
        GenerateContextLostErrorOnCurrentGlobalContext();
1542
    }
1543
}
1544

1545
void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target,
1546
                                          GLint level,
1547
                                          GLint internalformat,
1548
                                          GLsizei width,
1549
                                          GLsizei height,
1550
                                          GLint border,
1551
                                          GLenum format,
1552
                                          GLenum type,
1553
                                          GLsizei bufSize,
1554
                                          const void *pixels)
1555
{
1556
    Context *context = GetValidGlobalContext();
1557
    EVENT(context, GLTexImage2DRobustANGLE,
1558
          "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
1559
          "border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "",
1560
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
1561
          width, height, border, GLenumToString(GLenumGroup::DefaultGroup, format),
1562
          GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1563

1564
    if (context)
1565
    {
1566
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1567
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1568
        bool isCallValid =
1569
            (context->skipValidation() ||
1570
             ValidateTexImage2DRobustANGLE(context, targetPacked, level, internalformat, width,
1571
                                           height, border, format, type, bufSize, pixels));
1572
        if (isCallValid)
1573
        {
1574
            context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
1575
                                      format, type, bufSize, pixels);
1576
        }
1577
        ANGLE_CAPTURE(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1578
                      internalformat, width, height, border, format, type, bufSize, pixels);
1579
    }
1580
    else
1581
    {
1582
        GenerateContextLostErrorOnCurrentGlobalContext();
1583
    }
1584
}
1585

1586
void GL_APIENTRY GL_TexParameterfvRobustANGLE(GLenum target,
1587
                                              GLenum pname,
1588
                                              GLsizei bufSize,
1589
                                              const GLfloat *params)
1590
{
1591
    Context *context = GetValidGlobalContext();
1592
    EVENT(context, GLTexParameterfvRobustANGLE,
1593
          "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
1594
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1595
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
1596

1597
    if (context)
1598
    {
1599
        TextureType targetPacked                              = PackParam<TextureType>(target);
1600
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1601
        bool isCallValid =
1602
            (context->skipValidation() ||
1603
             ValidateTexParameterfvRobustANGLE(context, targetPacked, pname, bufSize, params));
1604
        if (isCallValid)
1605
        {
1606
            context->texParameterfvRobust(targetPacked, pname, bufSize, params);
1607
        }
1608
        ANGLE_CAPTURE(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
1609
                      params);
1610
    }
1611
    else
1612
    {
1613
        GenerateContextLostErrorOnCurrentGlobalContext();
1614
    }
1615
}
1616

1617
void GL_APIENTRY GL_TexParameterivRobustANGLE(GLenum target,
1618
                                              GLenum pname,
1619
                                              GLsizei bufSize,
1620
                                              const GLint *params)
1621
{
1622
    Context *context = GetValidGlobalContext();
1623
    EVENT(context, GLTexParameterivRobustANGLE,
1624
          "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
1625
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1626
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
1627

1628
    if (context)
1629
    {
1630
        TextureType targetPacked                              = PackParam<TextureType>(target);
1631
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1632
        bool isCallValid =
1633
            (context->skipValidation() ||
1634
             ValidateTexParameterivRobustANGLE(context, targetPacked, pname, bufSize, params));
1635
        if (isCallValid)
1636
        {
1637
            context->texParameterivRobust(targetPacked, pname, bufSize, params);
1638
        }
1639
        ANGLE_CAPTURE(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
1640
                      params);
1641
    }
1642
    else
1643
    {
1644
        GenerateContextLostErrorOnCurrentGlobalContext();
1645
    }
1646
}
1647

1648
void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target,
1649
                                             GLint level,
1650
                                             GLint xoffset,
1651
                                             GLint yoffset,
1652
                                             GLsizei width,
1653
                                             GLsizei height,
1654
                                             GLenum format,
1655
                                             GLenum type,
1656
                                             GLsizei bufSize,
1657
                                             const void *pixels)
1658
{
1659
    Context *context = GetValidGlobalContext();
1660
    EVENT(context, GLTexSubImage2DRobustANGLE,
1661
          "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
1662
          "%d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "",
1663
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1664
          width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
1665
          GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1666

1667
    if (context)
1668
    {
1669
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1670
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1671
        bool isCallValid =
1672
            (context->skipValidation() ||
1673
             ValidateTexSubImage2DRobustANGLE(context, targetPacked, level, xoffset, yoffset, width,
1674
                                              height, format, type, bufSize, pixels));
1675
        if (isCallValid)
1676
        {
1677
            context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
1678
                                         format, type, bufSize, pixels);
1679
        }
1680
        ANGLE_CAPTURE(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
1681
                      yoffset, width, height, format, type, bufSize, pixels);
1682
    }
1683
    else
1684
    {
1685
        GenerateContextLostErrorOnCurrentGlobalContext();
1686
    }
1687
}
1688

1689
void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target,
1690
                                          GLint level,
1691
                                          GLint internalformat,
1692
                                          GLsizei width,
1693
                                          GLsizei height,
1694
                                          GLsizei depth,
1695
                                          GLint border,
1696
                                          GLenum format,
1697
                                          GLenum type,
1698
                                          GLsizei bufSize,
1699
                                          const void *pixels)
1700
{
1701
    Context *context = GetValidGlobalContext();
1702
    EVENT(context, GLTexImage3DRobustANGLE,
1703
          "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
1704
          "depth = %d, border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR
1705
          "",
1706
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
1707
          width, height, depth, border, GLenumToString(GLenumGroup::DefaultGroup, format),
1708
          GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1709

1710
    if (context)
1711
    {
1712
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1713
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1714
        bool isCallValid =
1715
            (context->skipValidation() ||
1716
             ValidateTexImage3DRobustANGLE(context, targetPacked, level, internalformat, width,
1717
                                           height, depth, border, format, type, bufSize, pixels));
1718
        if (isCallValid)
1719
        {
1720
            context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
1721
                                      border, format, type, bufSize, pixels);
1722
        }
1723
        ANGLE_CAPTURE(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
1724
                      internalformat, width, height, depth, border, format, type, bufSize, pixels);
1725
    }
1726
    else
1727
    {
1728
        GenerateContextLostErrorOnCurrentGlobalContext();
1729
    }
1730
}
1731

1732
void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target,
1733
                                             GLint level,
1734
                                             GLint xoffset,
1735
                                             GLint yoffset,
1736
                                             GLint zoffset,
1737
                                             GLsizei width,
1738
                                             GLsizei height,
1739
                                             GLsizei depth,
1740
                                             GLenum format,
1741
                                             GLenum type,
1742
                                             GLsizei bufSize,
1743
                                             const void *pixels)
1744
{
1745
    Context *context = GetValidGlobalContext();
1746
    EVENT(
1747
        context, GLTexSubImage3DRobustANGLE,
1748
        "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width = "
1749
        "%d, height = %d, depth = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR
1750
        "",
1751
        CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1752
        zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
1753
        GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1754

1755
    if (context)
1756
    {
1757
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1758
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1759
        bool isCallValid                                      = (context->skipValidation() ||
1760
                            ValidateTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset,
1761
                                                             yoffset, zoffset, width, height, depth,
1762
                                                             format, type, bufSize, pixels));
1763
        if (isCallValid)
1764
        {
1765
            context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
1766
                                         height, depth, format, type, bufSize, pixels);
1767
        }
1768
        ANGLE_CAPTURE(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
1769
                      yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
1770
    }
1771
    else
1772
    {
1773
        GenerateContextLostErrorOnCurrentGlobalContext();
1774
    }
1775
}
1776

1777
void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target,
1778
                                                    GLint level,
1779
                                                    GLenum internalformat,
1780
                                                    GLsizei width,
1781
                                                    GLsizei height,
1782
                                                    GLint border,
1783
                                                    GLsizei imageSize,
1784
                                                    GLsizei dataSize,
1785
                                                    const GLvoid *data)
1786
{
1787
    Context *context = GetValidGlobalContext();
1788
    EVENT(context, GLCompressedTexImage2DRobustANGLE,
1789
          "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
1790
          "border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
1791
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
1792
          GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, border,
1793
          imageSize, dataSize, (uintptr_t)data);
1794

1795
    if (context)
1796
    {
1797
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1798
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1799
        bool isCallValid =
1800
            (context->skipValidation() || ValidateCompressedTexImage2DRobustANGLE(
1801
                                              context, targetPacked, level, internalformat, width,
1802
                                              height, border, imageSize, dataSize, data));
1803
        if (isCallValid)
1804
        {
1805
            context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
1806
                                                border, imageSize, dataSize, data);
1807
        }
1808
        ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1809
                      internalformat, width, height, border, imageSize, dataSize, data);
1810
    }
1811
    else
1812
    {
1813
        GenerateContextLostErrorOnCurrentGlobalContext();
1814
    }
1815
}
1816

1817
void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target,
1818
                                                       GLint level,
1819
                                                       GLsizei xoffset,
1820
                                                       GLsizei yoffset,
1821
                                                       GLsizei width,
1822
                                                       GLsizei height,
1823
                                                       GLenum format,
1824
                                                       GLsizei imageSize,
1825
                                                       GLsizei dataSize,
1826
                                                       const GLvoid *data)
1827
{
1828
    Context *context = GetValidGlobalContext();
1829
    EVENT(context, GLCompressedTexSubImage2DRobustANGLE,
1830
          "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
1831
          "%d, format = %s, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
1832
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1833
          width, height, GLenumToString(GLenumGroup::DefaultGroup, format), imageSize, dataSize,
1834
          (uintptr_t)data);
1835

1836
    if (context)
1837
    {
1838
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1839
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1840
        bool isCallValid =
1841
            (context->skipValidation() || ValidateCompressedTexSubImage2DRobustANGLE(
1842
                                              context, targetPacked, level, xoffset, yoffset, width,
1843
                                              height, format, imageSize, dataSize, data));
1844
        if (isCallValid)
1845
        {
1846
            context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
1847
                                                   height, format, imageSize, dataSize, data);
1848
        }
1849
        ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1850
                      xoffset, yoffset, width, height, format, imageSize, dataSize, data);
1851
    }
1852
    else
1853
    {
1854
        GenerateContextLostErrorOnCurrentGlobalContext();
1855
    }
1856
}
1857

1858
void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target,
1859
                                                    GLint level,
1860
                                                    GLenum internalformat,
1861
                                                    GLsizei width,
1862
                                                    GLsizei height,
1863
                                                    GLsizei depth,
1864
                                                    GLint border,
1865
                                                    GLsizei imageSize,
1866
                                                    GLsizei dataSize,
1867
                                                    const GLvoid *data)
1868
{
1869
    Context *context = GetValidGlobalContext();
1870
    EVENT(context, GLCompressedTexImage3DRobustANGLE,
1871
          "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
1872
          "depth = %d, border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
1873
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
1874
          GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, depth, border,
1875
          imageSize, dataSize, (uintptr_t)data);
1876

1877
    if (context)
1878
    {
1879
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1880
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1881
        bool isCallValid =
1882
            (context->skipValidation() || ValidateCompressedTexImage3DRobustANGLE(
1883
                                              context, targetPacked, level, internalformat, width,
1884
                                              height, depth, border, imageSize, dataSize, data));
1885
        if (isCallValid)
1886
        {
1887
            context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
1888
                                                depth, border, imageSize, dataSize, data);
1889
        }
1890
        ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
1891
                      internalformat, width, height, depth, border, imageSize, dataSize, data);
1892
    }
1893
    else
1894
    {
1895
        GenerateContextLostErrorOnCurrentGlobalContext();
1896
    }
1897
}
1898

1899
void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target,
1900
                                                       GLint level,
1901
                                                       GLint xoffset,
1902
                                                       GLint yoffset,
1903
                                                       GLint zoffset,
1904
                                                       GLsizei width,
1905
                                                       GLsizei height,
1906
                                                       GLsizei depth,
1907
                                                       GLenum format,
1908
                                                       GLsizei imageSize,
1909
                                                       GLsizei dataSize,
1910
                                                       const GLvoid *data)
1911
{
1912
    Context *context = GetValidGlobalContext();
1913
    EVENT(context, GLCompressedTexSubImage3DRobustANGLE,
1914
          "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
1915
          "= %d, height = %d, depth = %d, format = %s, imageSize = %d, dataSize = %d, data = "
1916
          "0x%016" PRIxPTR "",
1917
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1918
          zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
1919
          imageSize, dataSize, (uintptr_t)data);
1920

1921
    if (context)
1922
    {
1923
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
1924
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1925
        bool isCallValid                                      = (context->skipValidation() ||
1926
                            ValidateCompressedTexSubImage3DRobustANGLE(
1927
                                context, targetPacked, level, xoffset, yoffset, zoffset, width,
1928
                                height, depth, format, imageSize, dataSize, data));
1929
        if (isCallValid)
1930
        {
1931
            context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
1932
                                                   width, height, depth, format, imageSize,
1933
                                                   dataSize, data);
1934
        }
1935
        ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level,
1936
                      xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
1937
                      data);
1938
    }
1939
    else
1940
    {
1941
        GenerateContextLostErrorOnCurrentGlobalContext();
1942
    }
1943
}
1944

1945
void GL_APIENTRY GL_GetQueryivRobustANGLE(GLenum target,
1946
                                          GLenum pname,
1947
                                          GLsizei bufSize,
1948
                                          GLsizei *length,
1949
                                          GLint *params)
1950
{
1951
    Context *context = GetValidGlobalContext();
1952
    EVENT(context, GLGetQueryivRobustANGLE,
1953
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1954
          ", params = 0x%016" PRIxPTR "",
1955
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1956
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1957
          (uintptr_t)params);
1958

1959
    if (context)
1960
    {
1961
        QueryType targetPacked                                = PackParam<QueryType>(target);
1962
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1963
        bool isCallValid =
1964
            (context->skipValidation() ||
1965
             ValidateGetQueryivRobustANGLE(context, targetPacked, pname, bufSize, length, params));
1966
        if (isCallValid)
1967
        {
1968
            context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
1969
        }
1970
        ANGLE_CAPTURE(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
1971
                      length, params);
1972
    }
1973
    else
1974
    {
1975
        GenerateContextLostErrorOnCurrentGlobalContext();
1976
    }
1977
}
1978

1979
void GL_APIENTRY GL_GetQueryObjectuivRobustANGLE(GLuint id,
1980
                                                 GLenum pname,
1981
                                                 GLsizei bufSize,
1982
                                                 GLsizei *length,
1983
                                                 GLuint *params)
1984
{
1985
    Context *context = GetValidGlobalContext();
1986
    EVENT(context, GLGetQueryObjectuivRobustANGLE,
1987
          "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1988
          ", params = 0x%016" PRIxPTR "",
1989
          CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1990
          (uintptr_t)length, (uintptr_t)params);
1991

1992
    if (context)
1993
    {
1994
        QueryID idPacked                                      = PackParam<QueryID>(id);
1995
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1996
        bool isCallValid =
1997
            (context->skipValidation() || ValidateGetQueryObjectuivRobustANGLE(
1998
                                              context, idPacked, pname, bufSize, length, params));
1999
        if (isCallValid)
2000
        {
2001
            context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params);
2002
        }
2003
        ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
2004
                      length, params);
2005
    }
2006
    else
2007
    {
2008
        GenerateContextLostErrorOnCurrentGlobalContext();
2009
    }
2010
}
2011

2012
void GL_APIENTRY GL_GetBufferPointervRobustANGLE(GLenum target,
2013
                                                 GLenum pname,
2014
                                                 GLsizei bufSize,
2015
                                                 GLsizei *length,
2016
                                                 void **params)
2017
{
2018
    Context *context = GetValidGlobalContext();
2019
    EVENT(context, GLGetBufferPointervRobustANGLE,
2020
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2021
          ", params = 0x%016" PRIxPTR "",
2022
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2023
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2024
          (uintptr_t)params);
2025

2026
    if (context)
2027
    {
2028
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
2029
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2030
        bool isCallValid                                      = (context->skipValidation() ||
2031
                            ValidateGetBufferPointervRobustANGLE(context, targetPacked, pname,
2032
                                                                 bufSize, length, params));
2033
        if (isCallValid)
2034
        {
2035
            context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
2036
        }
2037
        ANGLE_CAPTURE(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname,
2038
                      bufSize, length, params);
2039
    }
2040
    else
2041
    {
2042
        GenerateContextLostErrorOnCurrentGlobalContext();
2043
    }
2044
}
2045

2046
void GL_APIENTRY GL_GetIntegeri_vRobustANGLE(GLenum target,
2047
                                             GLuint index,
2048
                                             GLsizei bufSize,
2049
                                             GLsizei *length,
2050
                                             GLint *data)
2051
{
2052
    Context *context = GetValidGlobalContext();
2053
    EVENT(context, GLGetIntegeri_vRobustANGLE,
2054
          "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2055
          ", data = 0x%016" PRIxPTR "",
2056
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2057
          (uintptr_t)length, (uintptr_t)data);
2058

2059
    if (context)
2060
    {
2061
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2062
        bool isCallValid =
2063
            (context->skipValidation() ||
2064
             ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, length, data));
2065
        if (isCallValid)
2066
        {
2067
            context->getIntegeri_vRobust(target, index, bufSize, length, data);
2068
        }
2069
        ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize,
2070
                      length, data);
2071
    }
2072
    else
2073
    {
2074
        GenerateContextLostErrorOnCurrentGlobalContext();
2075
    }
2076
}
2077

2078
void GL_APIENTRY GL_GetInternalformativRobustANGLE(GLenum target,
2079
                                                   GLenum internalformat,
2080
                                                   GLenum pname,
2081
                                                   GLsizei bufSize,
2082
                                                   GLsizei *length,
2083
                                                   GLint *params)
2084
{
2085
    Context *context = GetValidGlobalContext();
2086
    EVENT(context, GLGetInternalformativRobustANGLE,
2087
          "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, length = "
2088
          "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2089
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2090
          GLenumToString(GLenumGroup::DefaultGroup, internalformat),
2091
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2092
          (uintptr_t)params);
2093

2094
    if (context)
2095
    {
2096
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2097
        bool isCallValid                                      = (context->skipValidation() ||
2098
                            ValidateGetInternalformativRobustANGLE(context, target, internalformat,
2099
                                                                   pname, bufSize, length, params));
2100
        if (isCallValid)
2101
        {
2102
            context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
2103
                                               params);
2104
        }
2105
        ANGLE_CAPTURE(GetInternalformativRobustANGLE, isCallValid, context, target, internalformat,
2106
                      pname, bufSize, length, params);
2107
    }
2108
    else
2109
    {
2110
        GenerateContextLostErrorOnCurrentGlobalContext();
2111
    }
2112
}
2113

2114
void GL_APIENTRY GL_GetVertexAttribIivRobustANGLE(GLuint index,
2115
                                                  GLenum pname,
2116
                                                  GLsizei bufSize,
2117
                                                  GLsizei *length,
2118
                                                  GLint *params)
2119
{
2120
    Context *context = GetValidGlobalContext();
2121
    EVENT(context, GLGetVertexAttribIivRobustANGLE,
2122
          "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2123
          ", params = 0x%016" PRIxPTR "",
2124
          CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2125
          (uintptr_t)length, (uintptr_t)params);
2126

2127
    if (context)
2128
    {
2129
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2130
        bool isCallValid =
2131
            (context->skipValidation() ||
2132
             ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, length, params));
2133
        if (isCallValid)
2134
        {
2135
            context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
2136
        }
2137
        ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize,
2138
                      length, params);
2139
    }
2140
    else
2141
    {
2142
        GenerateContextLostErrorOnCurrentGlobalContext();
2143
    }
2144
}
2145

2146
void GL_APIENTRY GL_GetVertexAttribIuivRobustANGLE(GLuint index,
2147
                                                   GLenum pname,
2148
                                                   GLsizei bufSize,
2149
                                                   GLsizei *length,
2150
                                                   GLuint *params)
2151
{
2152
    Context *context = GetValidGlobalContext();
2153
    EVENT(context, GLGetVertexAttribIuivRobustANGLE,
2154
          "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2155
          ", params = 0x%016" PRIxPTR "",
2156
          CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2157
          (uintptr_t)length, (uintptr_t)params);
2158

2159
    if (context)
2160
    {
2161
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2162
        bool isCallValid =
2163
            (context->skipValidation() || ValidateGetVertexAttribIuivRobustANGLE(
2164
                                              context, index, pname, bufSize, length, params));
2165
        if (isCallValid)
2166
        {
2167
            context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
2168
        }
2169
        ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname, bufSize,
2170
                      length, params);
2171
    }
2172
    else
2173
    {
2174
        GenerateContextLostErrorOnCurrentGlobalContext();
2175
    }
2176
}
2177

2178
void GL_APIENTRY GL_GetUniformuivRobustANGLE(GLuint program,
2179
                                             GLint location,
2180
                                             GLsizei bufSize,
2181
                                             GLsizei *length,
2182
                                             GLuint *params)
2183
{
2184
    Context *context = GetValidGlobalContext();
2185
    EVENT(context, GLGetUniformuivRobustANGLE,
2186
          "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
2187
          ", params = 0x%016" PRIxPTR "",
2188
          CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2189

2190
    if (context)
2191
    {
2192
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
2193
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2194
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2195
        bool isCallValid                                      = (context->skipValidation() ||
2196
                            ValidateGetUniformuivRobustANGLE(context, programPacked, locationPacked,
2197
                                                             bufSize, length, params));
2198
        if (isCallValid)
2199
        {
2200
            context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
2201
        }
2202
        ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, locationPacked,
2203
                      bufSize, length, params);
2204
    }
2205
    else
2206
    {
2207
        GenerateContextLostErrorOnCurrentGlobalContext();
2208
    }
2209
}
2210

2211
void GL_APIENTRY GL_GetActiveUniformBlockivRobustANGLE(GLuint program,
2212
                                                       GLuint uniformBlockIndex,
2213
                                                       GLenum pname,
2214
                                                       GLsizei bufSize,
2215
                                                       GLsizei *length,
2216
                                                       GLint *params)
2217
{
2218
    Context *context = GetValidGlobalContext();
2219
    EVENT(context, GLGetActiveUniformBlockivRobustANGLE,
2220
          "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, bufSize = %d, length = "
2221
          "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2222
          CID(context), program, uniformBlockIndex,
2223
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2224
          (uintptr_t)params);
2225

2226
    if (context)
2227
    {
2228
        ShaderProgramID programPacked             = PackParam<ShaderProgramID>(program);
2229
        UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex);
2230
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2231
        bool isCallValid =
2232
            (context->skipValidation() ||
2233
             ValidateGetActiveUniformBlockivRobustANGLE(
2234
                 context, programPacked, uniformBlockIndexPacked, pname, bufSize, length, params));
2235
        if (isCallValid)
2236
        {
2237
            context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndexPacked, pname,
2238
                                                   bufSize, length, params);
2239
        }
2240
        ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked,
2241
                      uniformBlockIndexPacked, pname, bufSize, length, params);
2242
    }
2243
    else
2244
    {
2245
        GenerateContextLostErrorOnCurrentGlobalContext();
2246
    }
2247
}
2248

2249
void GL_APIENTRY GL_GetInteger64vRobustANGLE(GLenum pname,
2250
                                             GLsizei bufSize,
2251
                                             GLsizei *length,
2252
                                             GLint64 *data)
2253
{
2254
    Context *context = GetValidGlobalContext();
2255
    EVENT(context, GLGetInteger64vRobustANGLE,
2256
          "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2257
          ", data = 0x%016" PRIxPTR "",
2258
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2259
          (uintptr_t)length, (uintptr_t)data);
2260

2261
    if (context)
2262
    {
2263
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2264
        bool isCallValid =
2265
            (context->skipValidation() ||
2266
             ValidateGetInteger64vRobustANGLE(context, pname, bufSize, length, data));
2267
        if (isCallValid)
2268
        {
2269
            context->getInteger64vRobust(pname, bufSize, length, data);
2270
        }
2271
        ANGLE_CAPTURE(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length, data);
2272
    }
2273
    else
2274
    {
2275
        GenerateContextLostErrorOnCurrentGlobalContext();
2276
    }
2277
}
2278

2279
void GL_APIENTRY GL_GetInteger64i_vRobustANGLE(GLenum target,
2280
                                               GLuint index,
2281
                                               GLsizei bufSize,
2282
                                               GLsizei *length,
2283
                                               GLint64 *data)
2284
{
2285
    Context *context = GetValidGlobalContext();
2286
    EVENT(context, GLGetInteger64i_vRobustANGLE,
2287
          "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2288
          ", data = 0x%016" PRIxPTR "",
2289
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2290
          (uintptr_t)length, (uintptr_t)data);
2291

2292
    if (context)
2293
    {
2294
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2295
        bool isCallValid =
2296
            (context->skipValidation() ||
2297
             ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, length, data));
2298
        if (isCallValid)
2299
        {
2300
            context->getInteger64i_vRobust(target, index, bufSize, length, data);
2301
        }
2302
        ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize,
2303
                      length, data);
2304
    }
2305
    else
2306
    {
2307
        GenerateContextLostErrorOnCurrentGlobalContext();
2308
    }
2309
}
2310

2311
void GL_APIENTRY GL_GetBufferParameteri64vRobustANGLE(GLenum target,
2312
                                                      GLenum pname,
2313
                                                      GLsizei bufSize,
2314
                                                      GLsizei *length,
2315
                                                      GLint64 *params)
2316
{
2317
    Context *context = GetValidGlobalContext();
2318
    EVENT(context, GLGetBufferParameteri64vRobustANGLE,
2319
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2320
          ", params = 0x%016" PRIxPTR "",
2321
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2322
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2323
          (uintptr_t)params);
2324

2325
    if (context)
2326
    {
2327
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
2328
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2329
        bool isCallValid                                      = (context->skipValidation() ||
2330
                            ValidateGetBufferParameteri64vRobustANGLE(context, targetPacked, pname,
2331
                                                                      bufSize, length, params));
2332
        if (isCallValid)
2333
        {
2334
            context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
2335
        }
2336
        ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked, pname,
2337
                      bufSize, length, params);
2338
    }
2339
    else
2340
    {
2341
        GenerateContextLostErrorOnCurrentGlobalContext();
2342
    }
2343
}
2344

2345
void GL_APIENTRY GL_SamplerParameterivRobustANGLE(GLuint sampler,
2346
                                                  GLuint pname,
2347
                                                  GLsizei bufSize,
2348
                                                  const GLint *param)
2349
{
2350
    Context *context = GetValidGlobalContext();
2351
    EVENT(context, GLSamplerParameterivRobustANGLE,
2352
          "context = %d, sampler = %u, pname = %u, bufSize = %d, param = 0x%016" PRIxPTR "",
2353
          CID(context), sampler, pname, bufSize, (uintptr_t)param);
2354

2355
    if (context)
2356
    {
2357
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
2358
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2359
        bool isCallValid =
2360
            (context->skipValidation() ||
2361
             ValidateSamplerParameterivRobustANGLE(context, samplerPacked, pname, bufSize, param));
2362
        if (isCallValid)
2363
        {
2364
            context->samplerParameterivRobust(samplerPacked, pname, bufSize, param);
2365
        }
2366
        ANGLE_CAPTURE(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
2367
                      bufSize, param);
2368
    }
2369
    else
2370
    {
2371
        GenerateContextLostErrorOnCurrentGlobalContext();
2372
    }
2373
}
2374

2375
void GL_APIENTRY GL_SamplerParameterfvRobustANGLE(GLuint sampler,
2376
                                                  GLenum pname,
2377
                                                  GLsizei bufSize,
2378
                                                  const GLfloat *param)
2379
{
2380
    Context *context = GetValidGlobalContext();
2381
    EVENT(context, GLSamplerParameterfvRobustANGLE,
2382
          "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
2383
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2384
          (uintptr_t)param);
2385

2386
    if (context)
2387
    {
2388
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
2389
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2390
        bool isCallValid =
2391
            (context->skipValidation() ||
2392
             ValidateSamplerParameterfvRobustANGLE(context, samplerPacked, pname, bufSize, param));
2393
        if (isCallValid)
2394
        {
2395
            context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param);
2396
        }
2397
        ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
2398
                      bufSize, param);
2399
    }
2400
    else
2401
    {
2402
        GenerateContextLostErrorOnCurrentGlobalContext();
2403
    }
2404
}
2405

2406
void GL_APIENTRY GL_GetSamplerParameterivRobustANGLE(GLuint sampler,
2407
                                                     GLenum pname,
2408
                                                     GLsizei bufSize,
2409
                                                     GLsizei *length,
2410
                                                     GLint *params)
2411
{
2412
    Context *context = GetValidGlobalContext();
2413
    EVENT(context, GLGetSamplerParameterivRobustANGLE,
2414
          "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2415
          ", params = 0x%016" PRIxPTR "",
2416
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2417
          (uintptr_t)length, (uintptr_t)params);
2418

2419
    if (context)
2420
    {
2421
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
2422
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2423
        bool isCallValid                                      = (context->skipValidation() ||
2424
                            ValidateGetSamplerParameterivRobustANGLE(context, samplerPacked, pname,
2425
                                                                     bufSize, length, params));
2426
        if (isCallValid)
2427
        {
2428
            context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params);
2429
        }
2430
        ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
2431
                      bufSize, length, params);
2432
    }
2433
    else
2434
    {
2435
        GenerateContextLostErrorOnCurrentGlobalContext();
2436
    }
2437
}
2438

2439
void GL_APIENTRY GL_GetSamplerParameterfvRobustANGLE(GLuint sampler,
2440
                                                     GLenum pname,
2441
                                                     GLsizei bufSize,
2442
                                                     GLsizei *length,
2443
                                                     GLfloat *params)
2444
{
2445
    Context *context = GetValidGlobalContext();
2446
    EVENT(context, GLGetSamplerParameterfvRobustANGLE,
2447
          "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2448
          ", params = 0x%016" PRIxPTR "",
2449
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2450
          (uintptr_t)length, (uintptr_t)params);
2451

2452
    if (context)
2453
    {
2454
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
2455
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2456
        bool isCallValid                                      = (context->skipValidation() ||
2457
                            ValidateGetSamplerParameterfvRobustANGLE(context, samplerPacked, pname,
2458
                                                                     bufSize, length, params));
2459
        if (isCallValid)
2460
        {
2461
            context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params);
2462
        }
2463
        ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
2464
                      bufSize, length, params);
2465
    }
2466
    else
2467
    {
2468
        GenerateContextLostErrorOnCurrentGlobalContext();
2469
    }
2470
}
2471

2472
void GL_APIENTRY GL_GetFramebufferParameterivRobustANGLE(GLenum target,
2473
                                                         GLenum pname,
2474
                                                         GLsizei bufSize,
2475
                                                         GLsizei *length,
2476
                                                         GLint *params)
2477
{
2478
    Context *context = GetValidGlobalContext();
2479
    EVENT(context, GLGetFramebufferParameterivRobustANGLE,
2480
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2481
          ", params = 0x%016" PRIxPTR "",
2482
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2483
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2484
          (uintptr_t)params);
2485

2486
    if (context)
2487
    {
2488
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2489
        bool isCallValid =
2490
            (context->skipValidation() || ValidateGetFramebufferParameterivRobustANGLE(
2491
                                              context, target, pname, bufSize, length, params));
2492
        if (isCallValid)
2493
        {
2494
            context->getFramebufferParameterivRobust(target, pname, bufSize, length, params);
2495
        }
2496
        ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname,
2497
                      bufSize, length, params);
2498
    }
2499
    else
2500
    {
2501
        GenerateContextLostErrorOnCurrentGlobalContext();
2502
    }
2503
}
2504

2505
void GL_APIENTRY GL_GetProgramInterfaceivRobustANGLE(GLuint program,
2506
                                                     GLenum programInterface,
2507
                                                     GLenum pname,
2508
                                                     GLsizei bufSize,
2509
                                                     GLsizei *length,
2510
                                                     GLint *params)
2511
{
2512
    Context *context = GetValidGlobalContext();
2513
    EVENT(context, GLGetProgramInterfaceivRobustANGLE,
2514
          "context = %d, program = %u, programInterface = %s, pname = %s, bufSize = %d, length = "
2515
          "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2516
          CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, programInterface),
2517
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2518
          (uintptr_t)params);
2519

2520
    if (context)
2521
    {
2522
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
2523
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2524
        bool isCallValid =
2525
            (context->skipValidation() ||
2526
             ValidateGetProgramInterfaceivRobustANGLE(context, programPacked, programInterface,
2527
                                                      pname, bufSize, length, params));
2528
        if (isCallValid)
2529
        {
2530
            context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize,
2531
                                                 length, params);
2532
        }
2533
        ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked,
2534
                      programInterface, pname, bufSize, length, params);
2535
    }
2536
    else
2537
    {
2538
        GenerateContextLostErrorOnCurrentGlobalContext();
2539
    }
2540
}
2541

2542
void GL_APIENTRY GL_GetBooleani_vRobustANGLE(GLenum target,
2543
                                             GLuint index,
2544
                                             GLsizei bufSize,
2545
                                             GLsizei *length,
2546
                                             GLboolean *data)
2547
{
2548
    Context *context = GetValidGlobalContext();
2549
    EVENT(context, GLGetBooleani_vRobustANGLE,
2550
          "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2551
          ", data = 0x%016" PRIxPTR "",
2552
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2553
          (uintptr_t)length, (uintptr_t)data);
2554

2555
    if (context)
2556
    {
2557
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2558
        bool isCallValid =
2559
            (context->skipValidation() ||
2560
             ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, length, data));
2561
        if (isCallValid)
2562
        {
2563
            context->getBooleani_vRobust(target, index, bufSize, length, data);
2564
        }
2565
        ANGLE_CAPTURE(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize,
2566
                      length, data);
2567
    }
2568
    else
2569
    {
2570
        GenerateContextLostErrorOnCurrentGlobalContext();
2571
    }
2572
}
2573

2574
void GL_APIENTRY GL_GetMultisamplefvRobustANGLE(GLenum pname,
2575
                                                GLuint index,
2576
                                                GLsizei bufSize,
2577
                                                GLsizei *length,
2578
                                                GLfloat *val)
2579
{
2580
    Context *context = GetValidGlobalContext();
2581
    EVENT(context, GLGetMultisamplefvRobustANGLE,
2582
          "context = %d, pname = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2583
          ", val = 0x%016" PRIxPTR "",
2584
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, bufSize,
2585
          (uintptr_t)length, (uintptr_t)val);
2586

2587
    if (context)
2588
    {
2589
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2590
        bool isCallValid =
2591
            (context->skipValidation() ||
2592
             ValidateGetMultisamplefvRobustANGLE(context, pname, index, bufSize, length, val));
2593
        if (isCallValid)
2594
        {
2595
            context->getMultisamplefvRobust(pname, index, bufSize, length, val);
2596
        }
2597
        ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize,
2598
                      length, val);
2599
    }
2600
    else
2601
    {
2602
        GenerateContextLostErrorOnCurrentGlobalContext();
2603
    }
2604
}
2605

2606
void GL_APIENTRY GL_GetTexLevelParameterivRobustANGLE(GLenum target,
2607
                                                      GLint level,
2608
                                                      GLenum pname,
2609
                                                      GLsizei bufSize,
2610
                                                      GLsizei *length,
2611
                                                      GLint *params)
2612
{
2613
    Context *context = GetValidGlobalContext();
2614
    EVENT(context, GLGetTexLevelParameterivRobustANGLE,
2615
          "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2616
          ", params = 0x%016" PRIxPTR "",
2617
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2618
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2619
          (uintptr_t)params);
2620

2621
    if (context)
2622
    {
2623
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
2624
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2625
        bool isCallValid                                      = (context->skipValidation() ||
2626
                            ValidateGetTexLevelParameterivRobustANGLE(
2627
                                context, targetPacked, level, pname, bufSize, length, params));
2628
        if (isCallValid)
2629
        {
2630
            context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
2631
                                                  params);
2632
        }
2633
        ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked, level,
2634
                      pname, bufSize, length, params);
2635
    }
2636
    else
2637
    {
2638
        GenerateContextLostErrorOnCurrentGlobalContext();
2639
    }
2640
}
2641

2642
void GL_APIENTRY GL_GetTexLevelParameterfvRobustANGLE(GLenum target,
2643
                                                      GLint level,
2644
                                                      GLenum pname,
2645
                                                      GLsizei bufSize,
2646
                                                      GLsizei *length,
2647
                                                      GLfloat *params)
2648
{
2649
    Context *context = GetValidGlobalContext();
2650
    EVENT(context, GLGetTexLevelParameterfvRobustANGLE,
2651
          "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2652
          ", params = 0x%016" PRIxPTR "",
2653
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2654
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2655
          (uintptr_t)params);
2656

2657
    if (context)
2658
    {
2659
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
2660
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2661
        bool isCallValid                                      = (context->skipValidation() ||
2662
                            ValidateGetTexLevelParameterfvRobustANGLE(
2663
                                context, targetPacked, level, pname, bufSize, length, params));
2664
        if (isCallValid)
2665
        {
2666
            context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
2667
                                                  params);
2668
        }
2669
        ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked, level,
2670
                      pname, bufSize, length, params);
2671
    }
2672
    else
2673
    {
2674
        GenerateContextLostErrorOnCurrentGlobalContext();
2675
    }
2676
}
2677

2678
void GL_APIENTRY GL_GetPointervRobustANGLERobustANGLE(GLenum pname,
2679
                                                      GLsizei bufSize,
2680
                                                      GLsizei *length,
2681
                                                      void **params)
2682
{
2683
    Context *context = GetValidGlobalContext();
2684
    EVENT(context, GLGetPointervRobustANGLERobustANGLE,
2685
          "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2686
          ", params = 0x%016" PRIxPTR "",
2687
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2688
          (uintptr_t)length, (uintptr_t)params);
2689

2690
    if (context)
2691
    {
2692
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2693
        bool isCallValid =
2694
            (context->skipValidation() ||
2695
             ValidateGetPointervRobustANGLERobustANGLE(context, pname, bufSize, length, params));
2696
        if (isCallValid)
2697
        {
2698
            context->getPointervRobustANGLERobust(pname, bufSize, length, params);
2699
        }
2700
        ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize,
2701
                      length, params);
2702
    }
2703
    else
2704
    {
2705
        GenerateContextLostErrorOnCurrentGlobalContext();
2706
    }
2707
}
2708

2709
void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x,
2710
                                           GLint y,
2711
                                           GLsizei width,
2712
                                           GLsizei height,
2713
                                           GLenum format,
2714
                                           GLenum type,
2715
                                           GLsizei bufSize,
2716
                                           GLsizei *length,
2717
                                           GLsizei *columns,
2718
                                           GLsizei *rows,
2719
                                           void *data)
2720
{
2721
    Context *context = GetValidGlobalContext();
2722
    EVENT(context, GLReadnPixelsRobustANGLE,
2723
          "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
2724
          "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR
2725
          ", data = 0x%016" PRIxPTR "",
2726
          CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
2727
          GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
2728
          (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)data);
2729

2730
    if (context)
2731
    {
2732
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2733
        bool isCallValid =
2734
            (context->skipValidation() ||
2735
             ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
2736
                                            length, columns, rows, data));
2737
        if (isCallValid)
2738
        {
2739
            context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
2740
                                       rows, data);
2741
        }
2742
        ANGLE_CAPTURE(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
2743
                      type, bufSize, length, columns, rows, data);
2744
    }
2745
    else
2746
    {
2747
        GenerateContextLostErrorOnCurrentGlobalContext();
2748
    }
2749
}
2750

2751
void GL_APIENTRY GL_GetnUniformfvRobustANGLE(GLuint program,
2752
                                             GLint location,
2753
                                             GLsizei bufSize,
2754
                                             GLsizei *length,
2755
                                             GLfloat *params)
2756
{
2757
    Context *context = GetValidGlobalContext();
2758
    EVENT(context, GLGetnUniformfvRobustANGLE,
2759
          "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
2760
          ", params = 0x%016" PRIxPTR "",
2761
          CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2762

2763
    if (context)
2764
    {
2765
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
2766
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2767
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2768
        bool isCallValid                                      = (context->skipValidation() ||
2769
                            ValidateGetnUniformfvRobustANGLE(context, programPacked, locationPacked,
2770
                                                             bufSize, length, params));
2771
        if (isCallValid)
2772
        {
2773
            context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
2774
        }
2775
        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
2776
                      bufSize, length, params);
2777
    }
2778
    else
2779
    {
2780
        GenerateContextLostErrorOnCurrentGlobalContext();
2781
    }
2782
}
2783

2784
void GL_APIENTRY GL_GetnUniformivRobustANGLE(GLuint program,
2785
                                             GLint location,
2786
                                             GLsizei bufSize,
2787
                                             GLsizei *length,
2788
                                             GLint *params)
2789
{
2790
    Context *context = GetValidGlobalContext();
2791
    EVENT(context, GLGetnUniformivRobustANGLE,
2792
          "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
2793
          ", params = 0x%016" PRIxPTR "",
2794
          CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2795

2796
    if (context)
2797
    {
2798
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
2799
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2800
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2801
        bool isCallValid                                      = (context->skipValidation() ||
2802
                            ValidateGetnUniformivRobustANGLE(context, programPacked, locationPacked,
2803
                                                             bufSize, length, params));
2804
        if (isCallValid)
2805
        {
2806
            context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
2807
        }
2808
        ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
2809
                      bufSize, length, params);
2810
    }
2811
    else
2812
    {
2813
        GenerateContextLostErrorOnCurrentGlobalContext();
2814
    }
2815
}
2816

2817
void GL_APIENTRY GL_GetnUniformuivRobustANGLE(GLuint program,
2818
                                              GLint location,
2819
                                              GLsizei bufSize,
2820
                                              GLsizei *length,
2821
                                              GLuint *params)
2822
{
2823
    Context *context = GetValidGlobalContext();
2824
    EVENT(context, GLGetnUniformuivRobustANGLE,
2825
          "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
2826
          ", params = 0x%016" PRIxPTR "",
2827
          CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2828

2829
    if (context)
2830
    {
2831
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
2832
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2833
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2834
        bool isCallValid                                      = (context->skipValidation() ||
2835
                            ValidateGetnUniformuivRobustANGLE(
2836
                                context, programPacked, locationPacked, bufSize, length, params));
2837
        if (isCallValid)
2838
        {
2839
            context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
2840
        }
2841
        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
2842
                      locationPacked, bufSize, length, params);
2843
    }
2844
    else
2845
    {
2846
        GenerateContextLostErrorOnCurrentGlobalContext();
2847
    }
2848
}
2849

2850
void GL_APIENTRY GL_TexParameterIivRobustANGLE(GLenum target,
2851
                                               GLenum pname,
2852
                                               GLsizei bufSize,
2853
                                               const GLint *params)
2854
{
2855
    Context *context = GetValidGlobalContext();
2856
    EVENT(context, GLTexParameterIivRobustANGLE,
2857
          "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
2858
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2859
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
2860

2861
    if (context)
2862
    {
2863
        TextureType targetPacked                              = PackParam<TextureType>(target);
2864
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2865
        bool isCallValid =
2866
            (context->skipValidation() ||
2867
             ValidateTexParameterIivRobustANGLE(context, targetPacked, pname, bufSize, params));
2868
        if (isCallValid)
2869
        {
2870
            context->texParameterIivRobust(targetPacked, pname, bufSize, params);
2871
        }
2872
        ANGLE_CAPTURE(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
2873
                      bufSize, params);
2874
    }
2875
    else
2876
    {
2877
        GenerateContextLostErrorOnCurrentGlobalContext();
2878
    }
2879
}
2880

2881
void GL_APIENTRY GL_TexParameterIuivRobustANGLE(GLenum target,
2882
                                                GLenum pname,
2883
                                                GLsizei bufSize,
2884
                                                const GLuint *params)
2885
{
2886
    Context *context = GetValidGlobalContext();
2887
    EVENT(context, GLTexParameterIuivRobustANGLE,
2888
          "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
2889
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2890
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
2891

2892
    if (context)
2893
    {
2894
        TextureType targetPacked                              = PackParam<TextureType>(target);
2895
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2896
        bool isCallValid =
2897
            (context->skipValidation() ||
2898
             ValidateTexParameterIuivRobustANGLE(context, targetPacked, pname, bufSize, params));
2899
        if (isCallValid)
2900
        {
2901
            context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
2902
        }
2903
        ANGLE_CAPTURE(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
2904
                      bufSize, params);
2905
    }
2906
    else
2907
    {
2908
        GenerateContextLostErrorOnCurrentGlobalContext();
2909
    }
2910
}
2911

2912
void GL_APIENTRY GL_GetTexParameterIivRobustANGLE(GLenum target,
2913
                                                  GLenum pname,
2914
                                                  GLsizei bufSize,
2915
                                                  GLsizei *length,
2916
                                                  GLint *params)
2917
{
2918
    Context *context = GetValidGlobalContext();
2919
    EVENT(context, GLGetTexParameterIivRobustANGLE,
2920
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2921
          ", params = 0x%016" PRIxPTR "",
2922
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2923
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2924
          (uintptr_t)params);
2925

2926
    if (context)
2927
    {
2928
        TextureType targetPacked                              = PackParam<TextureType>(target);
2929
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2930
        bool isCallValid                                      = (context->skipValidation() ||
2931
                            ValidateGetTexParameterIivRobustANGLE(context, targetPacked, pname,
2932
                                                                  bufSize, length, params));
2933
        if (isCallValid)
2934
        {
2935
            context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
2936
        }
2937
        ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
2938
                      bufSize, length, params);
2939
    }
2940
    else
2941
    {
2942
        GenerateContextLostErrorOnCurrentGlobalContext();
2943
    }
2944
}
2945

2946
void GL_APIENTRY GL_GetTexParameterIuivRobustANGLE(GLenum target,
2947
                                                   GLenum pname,
2948
                                                   GLsizei bufSize,
2949
                                                   GLsizei *length,
2950
                                                   GLuint *params)
2951
{
2952
    Context *context = GetValidGlobalContext();
2953
    EVENT(context, GLGetTexParameterIuivRobustANGLE,
2954
          "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2955
          ", params = 0x%016" PRIxPTR "",
2956
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2957
          GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2958
          (uintptr_t)params);
2959

2960
    if (context)
2961
    {
2962
        TextureType targetPacked                              = PackParam<TextureType>(target);
2963
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2964
        bool isCallValid                                      = (context->skipValidation() ||
2965
                            ValidateGetTexParameterIuivRobustANGLE(context, targetPacked, pname,
2966
                                                                   bufSize, length, params));
2967
        if (isCallValid)
2968
        {
2969
            context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
2970
        }
2971
        ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
2972
                      bufSize, length, params);
2973
    }
2974
    else
2975
    {
2976
        GenerateContextLostErrorOnCurrentGlobalContext();
2977
    }
2978
}
2979

2980
void GL_APIENTRY GL_SamplerParameterIivRobustANGLE(GLuint sampler,
2981
                                                   GLenum pname,
2982
                                                   GLsizei bufSize,
2983
                                                   const GLint *param)
2984
{
2985
    Context *context = GetValidGlobalContext();
2986
    EVENT(context, GLSamplerParameterIivRobustANGLE,
2987
          "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
2988
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2989
          (uintptr_t)param);
2990

2991
    if (context)
2992
    {
2993
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
2994
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2995
        bool isCallValid =
2996
            (context->skipValidation() ||
2997
             ValidateSamplerParameterIivRobustANGLE(context, samplerPacked, pname, bufSize, param));
2998
        if (isCallValid)
2999
        {
3000
            context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param);
3001
        }
3002
        ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
3003
                      bufSize, param);
3004
    }
3005
    else
3006
    {
3007
        GenerateContextLostErrorOnCurrentGlobalContext();
3008
    }
3009
}
3010

3011
void GL_APIENTRY GL_SamplerParameterIuivRobustANGLE(GLuint sampler,
3012
                                                    GLenum pname,
3013
                                                    GLsizei bufSize,
3014
                                                    const GLuint *param)
3015
{
3016
    Context *context = GetValidGlobalContext();
3017
    EVENT(context, GLSamplerParameterIuivRobustANGLE,
3018
          "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
3019
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3020
          (uintptr_t)param);
3021

3022
    if (context)
3023
    {
3024
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
3025
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3026
        bool isCallValid =
3027
            (context->skipValidation() || ValidateSamplerParameterIuivRobustANGLE(
3028
                                              context, samplerPacked, pname, bufSize, param));
3029
        if (isCallValid)
3030
        {
3031
            context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param);
3032
        }
3033
        ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, pname,
3034
                      bufSize, param);
3035
    }
3036
    else
3037
    {
3038
        GenerateContextLostErrorOnCurrentGlobalContext();
3039
    }
3040
}
3041

3042
void GL_APIENTRY GL_GetSamplerParameterIivRobustANGLE(GLuint sampler,
3043
                                                      GLenum pname,
3044
                                                      GLsizei bufSize,
3045
                                                      GLsizei *length,
3046
                                                      GLint *params)
3047
{
3048
    Context *context = GetValidGlobalContext();
3049
    EVENT(context, GLGetSamplerParameterIivRobustANGLE,
3050
          "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3051
          ", params = 0x%016" PRIxPTR "",
3052
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3053
          (uintptr_t)length, (uintptr_t)params);
3054

3055
    if (context)
3056
    {
3057
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
3058
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3059
        bool isCallValid                                      = (context->skipValidation() ||
3060
                            ValidateGetSamplerParameterIivRobustANGLE(context, samplerPacked, pname,
3061
                                                                      bufSize, length, params));
3062
        if (isCallValid)
3063
        {
3064
            context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params);
3065
        }
3066
        ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
3067
                      bufSize, length, params);
3068
    }
3069
    else
3070
    {
3071
        GenerateContextLostErrorOnCurrentGlobalContext();
3072
    }
3073
}
3074

3075
void GL_APIENTRY GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler,
3076
                                                       GLenum pname,
3077
                                                       GLsizei bufSize,
3078
                                                       GLsizei *length,
3079
                                                       GLuint *params)
3080
{
3081
    Context *context = GetValidGlobalContext();
3082
    EVENT(context, GLGetSamplerParameterIuivRobustANGLE,
3083
          "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3084
          ", params = 0x%016" PRIxPTR "",
3085
          CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3086
          (uintptr_t)length, (uintptr_t)params);
3087

3088
    if (context)
3089
    {
3090
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
3091
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3092
        bool isCallValid                                      = (context->skipValidation() ||
3093
                            ValidateGetSamplerParameterIuivRobustANGLE(
3094
                                context, samplerPacked, pname, bufSize, length, params));
3095
        if (isCallValid)
3096
        {
3097
            context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params);
3098
        }
3099
        ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked,
3100
                      pname, bufSize, length, params);
3101
    }
3102
    else
3103
    {
3104
        GenerateContextLostErrorOnCurrentGlobalContext();
3105
    }
3106
}
3107

3108
void GL_APIENTRY GL_GetQueryObjectivRobustANGLE(GLuint id,
3109
                                                GLenum pname,
3110
                                                GLsizei bufSize,
3111
                                                GLsizei *length,
3112
                                                GLint *params)
3113
{
3114
    Context *context = GetGlobalContext();
3115
    EVENT(context, GLGetQueryObjectivRobustANGLE,
3116
          "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3117
          ", params = 0x%016" PRIxPTR "",
3118
          CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3119
          (uintptr_t)length, (uintptr_t)params);
3120

3121
    if (context)
3122
    {
3123
        QueryID idPacked                                      = PackParam<QueryID>(id);
3124
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3125
        bool isCallValid =
3126
            (context->skipValidation() || ValidateGetQueryObjectivRobustANGLE(
3127
                                              context, idPacked, pname, bufSize, length, params));
3128
        if (isCallValid)
3129
        {
3130
            context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params);
3131
        }
3132
        ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
3133
                      length, params);
3134
    }
3135
    else
3136
    {}
3137
}
3138

3139
void GL_APIENTRY GL_GetQueryObjecti64vRobustANGLE(GLuint id,
3140
                                                  GLenum pname,
3141
                                                  GLsizei bufSize,
3142
                                                  GLsizei *length,
3143
                                                  GLint64 *params)
3144
{
3145
    Context *context = GetGlobalContext();
3146
    EVENT(context, GLGetQueryObjecti64vRobustANGLE,
3147
          "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3148
          ", params = 0x%016" PRIxPTR "",
3149
          CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3150
          (uintptr_t)length, (uintptr_t)params);
3151

3152
    if (context)
3153
    {
3154
        QueryID idPacked                                      = PackParam<QueryID>(id);
3155
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3156
        bool isCallValid =
3157
            (context->skipValidation() || ValidateGetQueryObjecti64vRobustANGLE(
3158
                                              context, idPacked, pname, bufSize, length, params));
3159
        if (isCallValid)
3160
        {
3161
            context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params);
3162
        }
3163
        ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
3164
                      length, params);
3165
    }
3166
    else
3167
    {}
3168
}
3169

3170
void GL_APIENTRY GL_GetQueryObjectui64vRobustANGLE(GLuint id,
3171
                                                   GLenum pname,
3172
                                                   GLsizei bufSize,
3173
                                                   GLsizei *length,
3174
                                                   GLuint64 *params)
3175
{
3176
    Context *context = GetValidGlobalContext();
3177
    EVENT(context, GLGetQueryObjectui64vRobustANGLE,
3178
          "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3179
          ", params = 0x%016" PRIxPTR "",
3180
          CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3181
          (uintptr_t)length, (uintptr_t)params);
3182

3183
    if (context)
3184
    {
3185
        QueryID idPacked                                      = PackParam<QueryID>(id);
3186
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3187
        bool isCallValid =
3188
            (context->skipValidation() || ValidateGetQueryObjectui64vRobustANGLE(
3189
                                              context, idPacked, pname, bufSize, length, params));
3190
        if (isCallValid)
3191
        {
3192
            context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params);
3193
        }
3194
        ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname,
3195
                      bufSize, length, params);
3196
    }
3197
    else
3198
    {
3199
        GenerateContextLostErrorOnCurrentGlobalContext();
3200
    }
3201
}
3202

3203
// GL_ANGLE_semaphore_fuchsia
3204
void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore,
3205
                                                     GLenum handleType,
3206
                                                     GLuint handle)
3207
{
3208
    Context *context = GetValidGlobalContext();
3209
    EVENT(context, GLImportSemaphoreZirconHandleANGLE,
3210
          "context = %d, semaphore = %u, handleType = %s, handle = %u", CID(context), semaphore,
3211
          GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle);
3212

3213
    if (context)
3214
    {
3215
        SemaphoreID semaphorePacked                           = PackParam<SemaphoreID>(semaphore);
3216
        HandleType handleTypePacked                           = PackParam<HandleType>(handleType);
3217
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3218
        bool isCallValid =
3219
            (context->skipValidation() || ValidateImportSemaphoreZirconHandleANGLE(
3220
                                              context, semaphorePacked, handleTypePacked, handle));
3221
        if (isCallValid)
3222
        {
3223
            context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle);
3224
        }
3225
        ANGLE_CAPTURE(ImportSemaphoreZirconHandleANGLE, isCallValid, context, semaphorePacked,
3226
                      handleTypePacked, handle);
3227
    }
3228
    else
3229
    {
3230
        GenerateContextLostErrorOnCurrentGlobalContext();
3231
    }
3232
}
3233

3234
// GL_ANGLE_texture_external_update
3235
void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target,
3236
                                            GLint level,
3237
                                            GLint internalformat,
3238
                                            GLsizei width,
3239
                                            GLsizei height,
3240
                                            GLint border,
3241
                                            GLenum format,
3242
                                            GLenum type)
3243
{
3244
    Context *context = GetValidGlobalContext();
3245
    EVENT(context, GLTexImage2DExternalANGLE,
3246
          "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
3247
          "border = %d, format = %s, type = %s",
3248
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
3249
          width, height, border, GLenumToString(GLenumGroup::PixelFormat, format),
3250
          GLenumToString(GLenumGroup::PixelType, type));
3251

3252
    if (context)
3253
    {
3254
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
3255
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3256
        bool isCallValid =
3257
            (context->skipValidation() ||
3258
             ValidateTexImage2DExternalANGLE(context, targetPacked, level, internalformat, width,
3259
                                             height, border, format, type));
3260
        if (isCallValid)
3261
        {
3262
            context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
3263
                                        format, type);
3264
        }
3265
        ANGLE_CAPTURE(TexImage2DExternalANGLE, isCallValid, context, targetPacked, level,
3266
                      internalformat, width, height, border, format, type);
3267
    }
3268
    else
3269
    {
3270
        GenerateContextLostErrorOnCurrentGlobalContext();
3271
    }
3272
}
3273

3274
void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target)
3275
{
3276
    Context *context = GetValidGlobalContext();
3277
    EVENT(context, GLInvalidateTextureANGLE, "context = %d, target = %s", CID(context),
3278
          GLenumToString(GLenumGroup::TextureTarget, target));
3279

3280
    if (context)
3281
    {
3282
        TextureType targetPacked                              = PackParam<TextureType>(target);
3283
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3284
        bool isCallValid =
3285
            (context->skipValidation() || ValidateInvalidateTextureANGLE(context, targetPacked));
3286
        if (isCallValid)
3287
        {
3288
            context->invalidateTexture(targetPacked);
3289
        }
3290
        ANGLE_CAPTURE(InvalidateTextureANGLE, isCallValid, context, targetPacked);
3291
    }
3292
    else
3293
    {
3294
        GenerateContextLostErrorOnCurrentGlobalContext();
3295
    }
3296
}
3297

3298
// GL_ANGLE_texture_multisample
3299
void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target,
3300
                                                 GLsizei samples,
3301
                                                 GLenum internalformat,
3302
                                                 GLsizei width,
3303
                                                 GLsizei height,
3304
                                                 GLboolean fixedsamplelocations)
3305
{
3306
    Context *context = GetValidGlobalContext();
3307
    EVENT(context, GLTexStorage2DMultisampleANGLE,
3308
          "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
3309
          "fixedsamplelocations = %s",
3310
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), samples,
3311
          GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height,
3312
          GLbooleanToString(fixedsamplelocations));
3313

3314
    if (context)
3315
    {
3316
        TextureType targetPacked                              = PackParam<TextureType>(target);
3317
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3318
        bool isCallValid =
3319
            (context->skipValidation() ||
3320
             ValidateTexStorage2DMultisampleANGLE(context, targetPacked, samples, internalformat,
3321
                                                  width, height, fixedsamplelocations));
3322
        if (isCallValid)
3323
        {
3324
            context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
3325
                                             fixedsamplelocations);
3326
        }
3327
        ANGLE_CAPTURE(TexStorage2DMultisampleANGLE, isCallValid, context, targetPacked, samples,
3328
                      internalformat, width, height, fixedsamplelocations);
3329
    }
3330
    else
3331
    {
3332
        GenerateContextLostErrorOnCurrentGlobalContext();
3333
    }
3334
}
3335

3336
void GL_APIENTRY GL_GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
3337
{
3338
    Context *context = GetValidGlobalContext();
3339
    EVENT(context, GLGetMultisamplefvANGLE,
3340
          "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context),
3341
          GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
3342

3343
    if (context)
3344
    {
3345
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3346
        bool isCallValid                                      = (context->skipValidation() ||
3347
                            ValidateGetMultisamplefvANGLE(context, pname, index, val));
3348
        if (isCallValid)
3349
        {
3350
            context->getMultisamplefv(pname, index, val);
3351
        }
3352
        ANGLE_CAPTURE(GetMultisamplefvANGLE, isCallValid, context, pname, index, val);
3353
    }
3354
    else
3355
    {
3356
        GenerateContextLostErrorOnCurrentGlobalContext();
3357
    }
3358
}
3359

3360
void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
3361
{
3362
    Context *context = GetValidGlobalContext();
3363
    EVENT(context, GLSampleMaskiANGLE, "context = %d, maskNumber = %u, mask = %s", CID(context),
3364
          maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
3365

3366
    if (context)
3367
    {
3368
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3369
        bool isCallValid =
3370
            (context->skipValidation() || ValidateSampleMaskiANGLE(context, maskNumber, mask));
3371
        if (isCallValid)
3372
        {
3373
            context->sampleMaski(maskNumber, mask);
3374
        }
3375
        ANGLE_CAPTURE(SampleMaskiANGLE, isCallValid, context, maskNumber, mask);
3376
    }
3377
    else
3378
    {
3379
        GenerateContextLostErrorOnCurrentGlobalContext();
3380
    }
3381
}
3382

3383
// GetTexLevelParameterfvANGLE is already defined.
3384

3385
// GetTexLevelParameterivANGLE is already defined.
3386

3387
// GL_ANGLE_translated_shader_source
3388
void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader,
3389
                                                   GLsizei bufsize,
3390
                                                   GLsizei *length,
3391
                                                   GLchar *source)
3392
{
3393
    Context *context = GetValidGlobalContext();
3394
    EVENT(context, GLGetTranslatedShaderSourceANGLE,
3395
          "context = %d, shader = %u, bufsize = %d, length = 0x%016" PRIxPTR
3396
          ", source = 0x%016" PRIxPTR "",
3397
          CID(context), shader, bufsize, (uintptr_t)length, (uintptr_t)source);
3398

3399
    if (context)
3400
    {
3401
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
3402
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3403
        bool isCallValid =
3404
            (context->skipValidation() || ValidateGetTranslatedShaderSourceANGLE(
3405
                                              context, shaderPacked, bufsize, length, source));
3406
        if (isCallValid)
3407
        {
3408
            context->getTranslatedShaderSource(shaderPacked, bufsize, length, source);
3409
        }
3410
        ANGLE_CAPTURE(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked, bufsize,
3411
                      length, source);
3412
    }
3413
    else
3414
    {
3415
        GenerateContextLostErrorOnCurrentGlobalContext();
3416
    }
3417
}
3418

3419
// GL_CHROMIUM_bind_uniform_location
3420
void GL_APIENTRY GL_BindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
3421
{
3422
    Context *context = GetValidGlobalContext();
3423
    EVENT(context, GLBindUniformLocationCHROMIUM,
3424
          "context = %d, program = %u, location = %d, name = 0x%016" PRIxPTR "", CID(context),
3425
          program, location, (uintptr_t)name);
3426

3427
    if (context)
3428
    {
3429
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
3430
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
3431
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3432
        bool isCallValid =
3433
            (context->skipValidation() ||
3434
             ValidateBindUniformLocationCHROMIUM(context, programPacked, locationPacked, name));
3435
        if (isCallValid)
3436
        {
3437
            context->bindUniformLocation(programPacked, locationPacked, name);
3438
        }
3439
        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
3440
                      locationPacked, name);
3441
    }
3442
    else
3443
    {
3444
        GenerateContextLostErrorOnCurrentGlobalContext();
3445
    }
3446
}
3447

3448
// GL_CHROMIUM_copy_compressed_texture
3449
void GL_APIENTRY GL_CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
3450
{
3451
    Context *context = GetValidGlobalContext();
3452
    EVENT(context, GLCompressedCopyTextureCHROMIUM, "context = %d, sourceId = %u, destId = %u",
3453
          CID(context), sourceId, destId);
3454

3455
    if (context)
3456
    {
3457
        TextureID sourceIdPacked                              = PackParam<TextureID>(sourceId);
3458
        TextureID destIdPacked                                = PackParam<TextureID>(destId);
3459
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3460
        bool isCallValid =
3461
            (context->skipValidation() ||
3462
             ValidateCompressedCopyTextureCHROMIUM(context, sourceIdPacked, destIdPacked));
3463
        if (isCallValid)
3464
        {
3465
            context->compressedCopyTexture(sourceIdPacked, destIdPacked);
3466
        }
3467
        ANGLE_CAPTURE(CompressedCopyTextureCHROMIUM, isCallValid, context, sourceIdPacked,
3468
                      destIdPacked);
3469
    }
3470
    else
3471
    {
3472
        GenerateContextLostErrorOnCurrentGlobalContext();
3473
    }
3474
}
3475

3476
// GL_CHROMIUM_copy_texture
3477
void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId,
3478
                                        GLint sourceLevel,
3479
                                        GLenum destTarget,
3480
                                        GLuint destId,
3481
                                        GLint destLevel,
3482
                                        GLint internalFormat,
3483
                                        GLenum destType,
3484
                                        GLboolean unpackFlipY,
3485
                                        GLboolean unpackPremultiplyAlpha,
3486
                                        GLboolean unpackUnmultiplyAlpha)
3487
{
3488
    Context *context = GetValidGlobalContext();
3489
    EVENT(context, GLCopyTextureCHROMIUM,
3490
          "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
3491
          "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = "
3492
          "%s, unpackUnmultiplyAlpha = %s",
3493
          CID(context), sourceId, sourceLevel,
3494
          GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
3495
          GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
3496
          GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
3497

3498
    if (context)
3499
    {
3500
        TextureID sourceIdPacked       = PackParam<TextureID>(sourceId);
3501
        TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
3502
        TextureID destIdPacked         = PackParam<TextureID>(destId);
3503
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3504
        bool isCallValid                                      = (context->skipValidation() ||
3505
                            ValidateCopyTextureCHROMIUM(
3506
                                context, sourceIdPacked, sourceLevel, destTargetPacked,
3507
                                destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
3508
                                unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
3509
        if (isCallValid)
3510
        {
3511
            context->copyTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
3512
                                 destLevel, internalFormat, destType, unpackFlipY,
3513
                                 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
3514
        }
3515
        ANGLE_CAPTURE(CopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
3516
                      destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
3517
                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
3518
    }
3519
    else
3520
    {
3521
        GenerateContextLostErrorOnCurrentGlobalContext();
3522
    }
3523
}
3524

3525
void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId,
3526
                                           GLint sourceLevel,
3527
                                           GLenum destTarget,
3528
                                           GLuint destId,
3529
                                           GLint destLevel,
3530
                                           GLint xoffset,
3531
                                           GLint yoffset,
3532
                                           GLint x,
3533
                                           GLint y,
3534
                                           GLint width,
3535
                                           GLint height,
3536
                                           GLboolean unpackFlipY,
3537
                                           GLboolean unpackPremultiplyAlpha,
3538
                                           GLboolean unpackUnmultiplyAlpha)
3539
{
3540
    Context *context = GetValidGlobalContext();
3541
    EVENT(context, GLCopySubTextureCHROMIUM,
3542
          "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
3543
          "= %d, xoffset = %d, yoffset = %d, x = %d, y = %d, width = %d, height = %d, unpackFlipY "
3544
          "= %s, unpackPremultiplyAlpha = %s, unpackUnmultiplyAlpha = %s",
3545
          CID(context), sourceId, sourceLevel,
3546
          GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
3547
          yoffset, x, y, width, height, GLbooleanToString(unpackFlipY),
3548
          GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
3549

3550
    if (context)
3551
    {
3552
        TextureID sourceIdPacked       = PackParam<TextureID>(sourceId);
3553
        TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
3554
        TextureID destIdPacked         = PackParam<TextureID>(destId);
3555
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3556
        bool isCallValid                                      = (context->skipValidation() ||
3557
                            ValidateCopySubTextureCHROMIUM(
3558
                                context, sourceIdPacked, sourceLevel, destTargetPacked,
3559
                                destIdPacked, destLevel, xoffset, yoffset, x, y, width, height,
3560
                                unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
3561
        if (isCallValid)
3562
        {
3563
            context->copySubTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
3564
                                    destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
3565
                                    unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
3566
        }
3567
        ANGLE_CAPTURE(CopySubTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
3568
                      destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width,
3569
                      height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
3570
    }
3571
    else
3572
    {
3573
        GenerateContextLostErrorOnCurrentGlobalContext();
3574
    }
3575
}
3576

3577
// GL_CHROMIUM_framebuffer_mixed_samples
3578
void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components)
3579
{
3580
    Context *context = GetValidGlobalContext();
3581
    EVENT(context, GLCoverageModulationCHROMIUM, "context = %d, components = %s", CID(context),
3582
          GLenumToString(GLenumGroup::DefaultGroup, components));
3583

3584
    if (context)
3585
    {
3586
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3587
        bool isCallValid =
3588
            (context->skipValidation() || ValidateCoverageModulationCHROMIUM(context, components));
3589
        if (isCallValid)
3590
        {
3591
            context->coverageModulation(components);
3592
        }
3593
        ANGLE_CAPTURE(CoverageModulationCHROMIUM, isCallValid, context, components);
3594
    }
3595
    else
3596
    {
3597
        GenerateContextLostErrorOnCurrentGlobalContext();
3598
    }
3599
}
3600

3601
// GL_CHROMIUM_lose_context
3602
void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other)
3603
{
3604
    Context *context = GetValidGlobalContext();
3605
    EVENT(context, GLLoseContextCHROMIUM, "context = %d, current = %s, other = %s", CID(context),
3606
          GLenumToString(GLenumGroup::GraphicsResetStatus, current),
3607
          GLenumToString(GLenumGroup::GraphicsResetStatus, other));
3608

3609
    if (context)
3610
    {
3611
        GraphicsResetStatus currentPacked = PackParam<GraphicsResetStatus>(current);
3612
        GraphicsResetStatus otherPacked   = PackParam<GraphicsResetStatus>(other);
3613
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3614
        bool isCallValid                                      = (context->skipValidation() ||
3615
                            ValidateLoseContextCHROMIUM(context, currentPacked, otherPacked));
3616
        if (isCallValid)
3617
        {
3618
            context->loseContext(currentPacked, otherPacked);
3619
        }
3620
        ANGLE_CAPTURE(LoseContextCHROMIUM, isCallValid, context, currentPacked, otherPacked);
3621
    }
3622
    else
3623
    {
3624
        GenerateContextLostErrorOnCurrentGlobalContext();
3625
    }
3626
}
3627

3628
// GL_EXT_EGL_image_array
3629

3630
// GL_EXT_YUV_target
3631

3632
// GL_EXT_blend_func_extended
3633
void GL_APIENTRY GL_BindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
3634
{
3635
    Context *context = GetValidGlobalContext();
3636
    EVENT(context, GLBindFragDataLocationEXT,
3637
          "context = %d, program = %u, color = %u, name = 0x%016" PRIxPTR "", CID(context), program,
3638
          color, (uintptr_t)name);
3639

3640
    if (context)
3641
    {
3642
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
3643
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3644
        bool isCallValid                                      = (context->skipValidation() ||
3645
                            ValidateBindFragDataLocationEXT(context, programPacked, color, name));
3646
        if (isCallValid)
3647
        {
3648
            context->bindFragDataLocation(programPacked, color, name);
3649
        }
3650
        ANGLE_CAPTURE(BindFragDataLocationEXT, isCallValid, context, programPacked, color, name);
3651
    }
3652
    else
3653
    {
3654
        GenerateContextLostErrorOnCurrentGlobalContext();
3655
    }
3656
}
3657

3658
void GL_APIENTRY GL_BindFragDataLocationIndexedEXT(GLuint program,
3659
                                                   GLuint colorNumber,
3660
                                                   GLuint index,
3661
                                                   const GLchar *name)
3662
{
3663
    Context *context = GetValidGlobalContext();
3664
    EVENT(context, GLBindFragDataLocationIndexedEXT,
3665
          "context = %d, program = %u, colorNumber = %u, index = %u, name = 0x%016" PRIxPTR "",
3666
          CID(context), program, colorNumber, index, (uintptr_t)name);
3667

3668
    if (context)
3669
    {
3670
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
3671
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3672
        bool isCallValid =
3673
            (context->skipValidation() || ValidateBindFragDataLocationIndexedEXT(
3674
                                              context, programPacked, colorNumber, index, name));
3675
        if (isCallValid)
3676
        {
3677
            context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
3678
        }
3679
        ANGLE_CAPTURE(BindFragDataLocationIndexedEXT, isCallValid, context, programPacked,
3680
                      colorNumber, index, name);
3681
    }
3682
    else
3683
    {
3684
        GenerateContextLostErrorOnCurrentGlobalContext();
3685
    }
3686
}
3687

3688
GLint GL_APIENTRY GL_GetFragDataIndexEXT(GLuint program, const GLchar *name)
3689
{
3690
    Context *context = GetValidGlobalContext();
3691
    EVENT(context, GLGetFragDataIndexEXT, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
3692
          CID(context), program, (uintptr_t)name);
3693

3694
    GLint returnValue;
3695
    if (context)
3696
    {
3697
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
3698
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3699
        bool isCallValid                                      = (context->skipValidation() ||
3700
                            ValidateGetFragDataIndexEXT(context, programPacked, name));
3701
        if (isCallValid)
3702
        {
3703
            returnValue = context->getFragDataIndex(programPacked, name);
3704
        }
3705
        else
3706
        {
3707
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>();
3708
        }
3709
        ANGLE_CAPTURE(GetFragDataIndexEXT, isCallValid, context, programPacked, name, returnValue);
3710
    }
3711
    else
3712
    {
3713
        GenerateContextLostErrorOnCurrentGlobalContext();
3714
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>();
3715
    }
3716
    return returnValue;
3717
}
3718

3719
GLint GL_APIENTRY GL_GetProgramResourceLocationIndexEXT(GLuint program,
3720
                                                        GLenum programInterface,
3721
                                                        const GLchar *name)
3722
{
3723
    Context *context = GetValidGlobalContext();
3724
    EVENT(context, GLGetProgramResourceLocationIndexEXT,
3725
          "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "",
3726
          CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
3727
          (uintptr_t)name);
3728

3729
    GLint returnValue;
3730
    if (context)
3731
    {
3732
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
3733
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3734
        bool isCallValid =
3735
            (context->skipValidation() || ValidateGetProgramResourceLocationIndexEXT(
3736
                                              context, programPacked, programInterface, name));
3737
        if (isCallValid)
3738
        {
3739
            returnValue =
3740
                context->getProgramResourceLocationIndex(programPacked, programInterface, name);
3741
        }
3742
        else
3743
        {
3744
            returnValue =
3745
                GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
3746
                                      GLint>();
3747
        }
3748
        ANGLE_CAPTURE(GetProgramResourceLocationIndexEXT, isCallValid, context, programPacked,
3749
                      programInterface, name, returnValue);
3750
    }
3751
    else
3752
    {
3753
        GenerateContextLostErrorOnCurrentGlobalContext();
3754
        returnValue =
3755
            GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT, GLint>();
3756
    }
3757
    return returnValue;
3758
}
3759

3760
// GL_EXT_buffer_storage
3761
void GL_APIENTRY GL_BufferStorageEXT(GLenum target,
3762
                                     GLsizeiptr size,
3763
                                     const void *data,
3764
                                     GLbitfield flags)
3765
{
3766
    Context *context = GetValidGlobalContext();
3767
    EVENT(context, GLBufferStorageEXT,
3768
          "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", flags = %s",
3769
          CID(context), GLenumToString(GLenumGroup::BufferStorageTarget, target),
3770
          static_cast<unsigned long long>(size), (uintptr_t)data,
3771
          GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str());
3772

3773
    if (context)
3774
    {
3775
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
3776
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3777
        bool isCallValid                                      = (context->skipValidation() ||
3778
                            ValidateBufferStorageEXT(context, targetPacked, size, data, flags));
3779
        if (isCallValid)
3780
        {
3781
            context->bufferStorage(targetPacked, size, data, flags);
3782
        }
3783
        ANGLE_CAPTURE(BufferStorageEXT, isCallValid, context, targetPacked, size, data, flags);
3784
    }
3785
    else
3786
    {
3787
        GenerateContextLostErrorOnCurrentGlobalContext();
3788
    }
3789
}
3790

3791
// GL_EXT_clip_control
3792
void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth)
3793
{
3794
    Context *context = GetValidGlobalContext();
3795
    EVENT(context, GLClipControlEXT, "context = %d, origin = %s, depth = %s", CID(context),
3796
          GLenumToString(GLenumGroup::DefaultGroup, origin),
3797
          GLenumToString(GLenumGroup::DefaultGroup, depth));
3798

3799
    if (context)
3800
    {
3801
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3802
        bool isCallValid =
3803
            (context->skipValidation() || ValidateClipControlEXT(context, origin, depth));
3804
        if (isCallValid)
3805
        {
3806
            context->clipControl(origin, depth);
3807
        }
3808
        ANGLE_CAPTURE(ClipControlEXT, isCallValid, context, origin, depth);
3809
    }
3810
    else
3811
    {
3812
        GenerateContextLostErrorOnCurrentGlobalContext();
3813
    }
3814
}
3815

3816
// GL_EXT_copy_image
3817
void GL_APIENTRY GL_CopyImageSubDataEXT(GLuint srcName,
3818
                                        GLenum srcTarget,
3819
                                        GLint srcLevel,
3820
                                        GLint srcX,
3821
                                        GLint srcY,
3822
                                        GLint srcZ,
3823
                                        GLuint dstName,
3824
                                        GLenum dstTarget,
3825
                                        GLint dstLevel,
3826
                                        GLint dstX,
3827
                                        GLint dstY,
3828
                                        GLint dstZ,
3829
                                        GLsizei srcWidth,
3830
                                        GLsizei srcHeight,
3831
                                        GLsizei srcDepth)
3832
{
3833
    Context *context = GetValidGlobalContext();
3834
    EVENT(context, GLCopyImageSubDataEXT,
3835
          "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = "
3836
          "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, "
3837
          "srcWidth = %d, srcHeight = %d, srcDepth = %d",
3838
          CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget),
3839
          srcLevel, srcX, srcY, srcZ, dstName,
3840
          GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY,
3841
          dstZ, srcWidth, srcHeight, srcDepth);
3842

3843
    if (context)
3844
    {
3845
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3846
        bool isCallValid =
3847
            (context->skipValidation() ||
3848
             ValidateCopyImageSubDataEXT(context, srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
3849
                                         dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
3850
                                         srcHeight, srcDepth));
3851
        if (isCallValid)
3852
        {
3853
            context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
3854
                                      dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
3855
                                      srcDepth);
3856
        }
3857
        ANGLE_CAPTURE(CopyImageSubDataEXT, isCallValid, context, srcName, srcTarget, srcLevel, srcX,
3858
                      srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
3859
                      srcHeight, srcDepth);
3860
    }
3861
    else
3862
    {
3863
        GenerateContextLostErrorOnCurrentGlobalContext();
3864
    }
3865
}
3866

3867
// GL_EXT_debug_label
3868
void GL_APIENTRY
3869
GL_GetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
3870
{
3871
    Context *context = GetValidGlobalContext();
3872
    EVENT(context, GLGetObjectLabelEXT,
3873
          "context = %d, type = %s, object = %u, bufSize = %d, length = 0x%016" PRIxPTR
3874
          ", label = 0x%016" PRIxPTR "",
3875
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), object, bufSize,
3876
          (uintptr_t)length, (uintptr_t)label);
3877

3878
    if (context)
3879
    {
3880
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3881
        bool isCallValid =
3882
            (context->skipValidation() ||
3883
             ValidateGetObjectLabelEXT(context, type, object, bufSize, length, label));
3884
        if (isCallValid)
3885
        {
3886
            context->getObjectLabel(type, object, bufSize, length, label);
3887
        }
3888
        ANGLE_CAPTURE(GetObjectLabelEXT, isCallValid, context, type, object, bufSize, length,
3889
                      label);
3890
    }
3891
    else
3892
    {
3893
        GenerateContextLostErrorOnCurrentGlobalContext();
3894
    }
3895
}
3896

3897
void GL_APIENTRY GL_LabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label)
3898
{
3899
    Context *context = GetValidGlobalContext();
3900
    EVENT(context, GLLabelObjectEXT,
3901
          "context = %d, type = %s, object = %u, length = %d, label = 0x%016" PRIxPTR "",
3902
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), object, length,
3903
          (uintptr_t)label);
3904

3905
    if (context)
3906
    {
3907
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3908
        bool isCallValid                                      = (context->skipValidation() ||
3909
                            ValidateLabelObjectEXT(context, type, object, length, label));
3910
        if (isCallValid)
3911
        {
3912
            context->labelObject(type, object, length, label);
3913
        }
3914
        ANGLE_CAPTURE(LabelObjectEXT, isCallValid, context, type, object, length, label);
3915
    }
3916
    else
3917
    {
3918
        GenerateContextLostErrorOnCurrentGlobalContext();
3919
    }
3920
}
3921

3922
// GL_EXT_debug_marker
3923
void GL_APIENTRY GL_InsertEventMarkerEXT(GLsizei length, const GLchar *marker)
3924
{
3925
    Context *context = GetValidGlobalContext();
3926
    // Don't run the EVENT() macro on the EXT_debug_marker entry points.
3927
    // It can interfere with the debug events being set by the caller.
3928
    // EVENT(context, GLInsertEventMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR
3929
    // "", CID(context), length, (uintptr_t)marker);
3930

3931
    if (context)
3932
    {
3933
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3934
        bool isCallValid =
3935
            (context->skipValidation() || ValidateInsertEventMarkerEXT(context, length, marker));
3936
        if (isCallValid)
3937
        {
3938
            context->insertEventMarker(length, marker);
3939
        }
3940
        ANGLE_CAPTURE(InsertEventMarkerEXT, isCallValid, context, length, marker);
3941
    }
3942
    else
3943
    {
3944
        GenerateContextLostErrorOnCurrentGlobalContext();
3945
    }
3946
}
3947

3948
void GL_APIENTRY GL_PopGroupMarkerEXT()
3949
{
3950
    Context *context = GetValidGlobalContext();
3951
    // Don't run the EVENT() macro on the EXT_debug_marker entry points.
3952
    // It can interfere with the debug events being set by the caller.
3953
    // EVENT(context, GLPopGroupMarkerEXT, "context = %d", CID(context));
3954

3955
    if (context)
3956
    {
3957
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3958
        bool isCallValid = (context->skipValidation() || ValidatePopGroupMarkerEXT(context));
3959
        if (isCallValid)
3960
        {
3961
            context->popGroupMarker();
3962
        }
3963
        ANGLE_CAPTURE(PopGroupMarkerEXT, isCallValid, context);
3964
    }
3965
    else
3966
    {
3967
        GenerateContextLostErrorOnCurrentGlobalContext();
3968
    }
3969
}
3970

3971
void GL_APIENTRY GL_PushGroupMarkerEXT(GLsizei length, const GLchar *marker)
3972
{
3973
    Context *context = GetValidGlobalContext();
3974
    // Don't run the EVENT() macro on the EXT_debug_marker entry points.
3975
    // It can interfere with the debug events being set by the caller.
3976
    // EVENT(context, GLPushGroupMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR "",
3977
    // CID(context), length, (uintptr_t)marker);
3978

3979
    if (context)
3980
    {
3981
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3982
        bool isCallValid =
3983
            (context->skipValidation() || ValidatePushGroupMarkerEXT(context, length, marker));
3984
        if (isCallValid)
3985
        {
3986
            context->pushGroupMarker(length, marker);
3987
        }
3988
        ANGLE_CAPTURE(PushGroupMarkerEXT, isCallValid, context, length, marker);
3989
    }
3990
    else
3991
    {
3992
        GenerateContextLostErrorOnCurrentGlobalContext();
3993
    }
3994
}
3995

3996
// GL_EXT_discard_framebuffer
3997
void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target,
3998
                                          GLsizei numAttachments,
3999
                                          const GLenum *attachments)
4000
{
4001
    Context *context = GetValidGlobalContext();
4002
    EVENT(context, GLDiscardFramebufferEXT,
4003
          "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "",
4004
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments,
4005
          (uintptr_t)attachments);
4006

4007
    if (context)
4008
    {
4009
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4010
        bool isCallValid =
4011
            (context->skipValidation() ||
4012
             ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments));
4013
        if (isCallValid)
4014
        {
4015
            context->discardFramebuffer(target, numAttachments, attachments);
4016
        }
4017
        ANGLE_CAPTURE(DiscardFramebufferEXT, isCallValid, context, target, numAttachments,
4018
                      attachments);
4019
    }
4020
    else
4021
    {
4022
        GenerateContextLostErrorOnCurrentGlobalContext();
4023
    }
4024
}
4025

4026
// GL_EXT_disjoint_timer_query
4027
void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id)
4028
{
4029
    Context *context = GetValidGlobalContext();
4030
    EVENT(context, GLBeginQueryEXT, "context = %d, target = %s, id = %u", CID(context),
4031
          GLenumToString(GLenumGroup::QueryTarget, target), id);
4032

4033
    if (context)
4034
    {
4035
        QueryType targetPacked                                = PackParam<QueryType>(target);
4036
        QueryID idPacked                                      = PackParam<QueryID>(id);
4037
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4038
        bool isCallValid =
4039
            (context->skipValidation() || ValidateBeginQueryEXT(context, targetPacked, idPacked));
4040
        if (isCallValid)
4041
        {
4042
            context->beginQuery(targetPacked, idPacked);
4043
        }
4044
        ANGLE_CAPTURE(BeginQueryEXT, isCallValid, context, targetPacked, idPacked);
4045
    }
4046
    else
4047
    {
4048
        GenerateContextLostErrorOnCurrentGlobalContext();
4049
    }
4050
}
4051

4052
void GL_APIENTRY GL_DeleteQueriesEXT(GLsizei n, const GLuint *ids)
4053
{
4054
    Context *context = GetValidGlobalContext();
4055
    EVENT(context, GLDeleteQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "",
4056
          CID(context), n, (uintptr_t)ids);
4057

4058
    if (context)
4059
    {
4060
        const QueryID *idsPacked                              = PackParam<const QueryID *>(ids);
4061
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4062
        bool isCallValid =
4063
            (context->skipValidation() || ValidateDeleteQueriesEXT(context, n, idsPacked));
4064
        if (isCallValid)
4065
        {
4066
            context->deleteQueries(n, idsPacked);
4067
        }
4068
        ANGLE_CAPTURE(DeleteQueriesEXT, isCallValid, context, n, idsPacked);
4069
    }
4070
    else
4071
    {
4072
        GenerateContextLostErrorOnCurrentGlobalContext();
4073
    }
4074
}
4075

4076
void GL_APIENTRY GL_EndQueryEXT(GLenum target)
4077
{
4078
    Context *context = GetValidGlobalContext();
4079
    EVENT(context, GLEndQueryEXT, "context = %d, target = %s", CID(context),
4080
          GLenumToString(GLenumGroup::QueryTarget, target));
4081

4082
    if (context)
4083
    {
4084
        QueryType targetPacked                                = PackParam<QueryType>(target);
4085
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4086
        bool isCallValid =
4087
            (context->skipValidation() || ValidateEndQueryEXT(context, targetPacked));
4088
        if (isCallValid)
4089
        {
4090
            context->endQuery(targetPacked);
4091
        }
4092
        ANGLE_CAPTURE(EndQueryEXT, isCallValid, context, targetPacked);
4093
    }
4094
    else
4095
    {
4096
        GenerateContextLostErrorOnCurrentGlobalContext();
4097
    }
4098
}
4099

4100
void GL_APIENTRY GL_GenQueriesEXT(GLsizei n, GLuint *ids)
4101
{
4102
    Context *context = GetValidGlobalContext();
4103
    EVENT(context, GLGenQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context),
4104
          n, (uintptr_t)ids);
4105

4106
    if (context)
4107
    {
4108
        QueryID *idsPacked                                    = PackParam<QueryID *>(ids);
4109
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4110
        bool isCallValid =
4111
            (context->skipValidation() || ValidateGenQueriesEXT(context, n, idsPacked));
4112
        if (isCallValid)
4113
        {
4114
            context->genQueries(n, idsPacked);
4115
        }
4116
        ANGLE_CAPTURE(GenQueriesEXT, isCallValid, context, n, idsPacked);
4117
    }
4118
    else
4119
    {
4120
        GenerateContextLostErrorOnCurrentGlobalContext();
4121
    }
4122
}
4123

4124
void GL_APIENTRY GL_GetInteger64vEXT(GLenum pname, GLint64 *data)
4125
{
4126
    Context *context = GetValidGlobalContext();
4127
    EVENT(context, GLGetInteger64vEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
4128
          CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
4129

4130
    if (context)
4131
    {
4132
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4133
        bool isCallValid =
4134
            (context->skipValidation() || ValidateGetInteger64vEXT(context, pname, data));
4135
        if (isCallValid)
4136
        {
4137
            context->getInteger64v(pname, data);
4138
        }
4139
        ANGLE_CAPTURE(GetInteger64vEXT, isCallValid, context, pname, data);
4140
    }
4141
    else
4142
    {
4143
        GenerateContextLostErrorOnCurrentGlobalContext();
4144
    }
4145
}
4146

4147
void GL_APIENTRY GL_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
4148
{
4149
    Context *context = GetGlobalContext();
4150
    EVENT(context, GLGetQueryObjecti64vEXT,
4151
          "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4152
          GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4153

4154
    if (context)
4155
    {
4156
        QueryID idPacked                                      = PackParam<QueryID>(id);
4157
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4158
        bool isCallValid                                      = (context->skipValidation() ||
4159
                            ValidateGetQueryObjecti64vEXT(context, idPacked, pname, params));
4160
        if (isCallValid)
4161
        {
4162
            context->getQueryObjecti64v(idPacked, pname, params);
4163
        }
4164
        ANGLE_CAPTURE(GetQueryObjecti64vEXT, isCallValid, context, idPacked, pname, params);
4165
    }
4166
    else
4167
    {}
4168
}
4169

4170
void GL_APIENTRY GL_GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
4171
{
4172
    Context *context = GetGlobalContext();
4173
    EVENT(context, GLGetQueryObjectivEXT,
4174
          "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4175
          GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4176

4177
    if (context)
4178
    {
4179
        QueryID idPacked                                      = PackParam<QueryID>(id);
4180
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4181
        bool isCallValid                                      = (context->skipValidation() ||
4182
                            ValidateGetQueryObjectivEXT(context, idPacked, pname, params));
4183
        if (isCallValid)
4184
        {
4185
            context->getQueryObjectiv(idPacked, pname, params);
4186
        }
4187
        ANGLE_CAPTURE(GetQueryObjectivEXT, isCallValid, context, idPacked, pname, params);
4188
    }
4189
    else
4190
    {}
4191
}
4192

4193
void GL_APIENTRY GL_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
4194
{
4195
    Context *context = GetValidGlobalContext();
4196
    EVENT(context, GLGetQueryObjectui64vEXT,
4197
          "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4198
          GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4199

4200
    if (context)
4201
    {
4202
        QueryID idPacked                                      = PackParam<QueryID>(id);
4203
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4204
        bool isCallValid                                      = (context->skipValidation() ||
4205
                            ValidateGetQueryObjectui64vEXT(context, idPacked, pname, params));
4206
        if (isCallValid)
4207
        {
4208
            context->getQueryObjectui64v(idPacked, pname, params);
4209
        }
4210
        ANGLE_CAPTURE(GetQueryObjectui64vEXT, isCallValid, context, idPacked, pname, params);
4211
    }
4212
    else
4213
    {
4214
        GenerateContextLostErrorOnCurrentGlobalContext();
4215
    }
4216
}
4217

4218
void GL_APIENTRY GL_GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
4219
{
4220
    Context *context = GetValidGlobalContext();
4221
    EVENT(context, GLGetQueryObjectuivEXT,
4222
          "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4223
          GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4224

4225
    if (context)
4226
    {
4227
        QueryID idPacked                                      = PackParam<QueryID>(id);
4228
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4229
        bool isCallValid                                      = (context->skipValidation() ||
4230
                            ValidateGetQueryObjectuivEXT(context, idPacked, pname, params));
4231
        if (isCallValid)
4232
        {
4233
            context->getQueryObjectuiv(idPacked, pname, params);
4234
        }
4235
        ANGLE_CAPTURE(GetQueryObjectuivEXT, isCallValid, context, idPacked, pname, params);
4236
    }
4237
    else
4238
    {
4239
        GenerateContextLostErrorOnCurrentGlobalContext();
4240
    }
4241
}
4242

4243
void GL_APIENTRY GL_GetQueryivEXT(GLenum target, GLenum pname, GLint *params)
4244
{
4245
    Context *context = GetValidGlobalContext();
4246
    EVENT(context, GLGetQueryivEXT,
4247
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
4248
          GLenumToString(GLenumGroup::QueryTarget, target),
4249
          GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
4250

4251
    if (context)
4252
    {
4253
        QueryType targetPacked                                = PackParam<QueryType>(target);
4254
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4255
        bool isCallValid                                      = (context->skipValidation() ||
4256
                            ValidateGetQueryivEXT(context, targetPacked, pname, params));
4257
        if (isCallValid)
4258
        {
4259
            context->getQueryiv(targetPacked, pname, params);
4260
        }
4261
        ANGLE_CAPTURE(GetQueryivEXT, isCallValid, context, targetPacked, pname, params);
4262
    }
4263
    else
4264
    {
4265
        GenerateContextLostErrorOnCurrentGlobalContext();
4266
    }
4267
}
4268

4269
GLboolean GL_APIENTRY GL_IsQueryEXT(GLuint id)
4270
{
4271
    Context *context = GetValidGlobalContext();
4272
    EVENT(context, GLIsQueryEXT, "context = %d, id = %u", CID(context), id);
4273

4274
    GLboolean returnValue;
4275
    if (context)
4276
    {
4277
        QueryID idPacked                                      = PackParam<QueryID>(id);
4278
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4279
        bool isCallValid = (context->skipValidation() || ValidateIsQueryEXT(context, idPacked));
4280
        if (isCallValid)
4281
        {
4282
            returnValue = context->isQuery(idPacked);
4283
        }
4284
        else
4285
        {
4286
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>();
4287
        }
4288
        ANGLE_CAPTURE(IsQueryEXT, isCallValid, context, idPacked, returnValue);
4289
    }
4290
    else
4291
    {
4292
        GenerateContextLostErrorOnCurrentGlobalContext();
4293
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>();
4294
    }
4295
    return returnValue;
4296
}
4297

4298
void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target)
4299
{
4300
    Context *context = GetValidGlobalContext();
4301
    EVENT(context, GLQueryCounterEXT, "context = %d, id = %u, target = %s", CID(context), id,
4302
          GLenumToString(GLenumGroup::QueryTarget, target));
4303

4304
    if (context)
4305
    {
4306
        QueryID idPacked                                      = PackParam<QueryID>(id);
4307
        QueryType targetPacked                                = PackParam<QueryType>(target);
4308
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4309
        bool isCallValid =
4310
            (context->skipValidation() || ValidateQueryCounterEXT(context, idPacked, targetPacked));
4311
        if (isCallValid)
4312
        {
4313
            context->queryCounter(idPacked, targetPacked);
4314
        }
4315
        ANGLE_CAPTURE(QueryCounterEXT, isCallValid, context, idPacked, targetPacked);
4316
    }
4317
    else
4318
    {
4319
        GenerateContextLostErrorOnCurrentGlobalContext();
4320
    }
4321
}
4322

4323
// GL_EXT_draw_buffers
4324
void GL_APIENTRY GL_DrawBuffersEXT(GLsizei n, const GLenum *bufs)
4325
{
4326
    Context *context = GetValidGlobalContext();
4327
    EVENT(context, GLDrawBuffersEXT, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context),
4328
          n, (uintptr_t)bufs);
4329

4330
    if (context)
4331
    {
4332
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4333
        bool isCallValid = (context->skipValidation() || ValidateDrawBuffersEXT(context, n, bufs));
4334
        if (isCallValid)
4335
        {
4336
            context->drawBuffers(n, bufs);
4337
        }
4338
        ANGLE_CAPTURE(DrawBuffersEXT, isCallValid, context, n, bufs);
4339
    }
4340
    else
4341
    {
4342
        GenerateContextLostErrorOnCurrentGlobalContext();
4343
    }
4344
}
4345

4346
// GL_EXT_draw_buffers_indexed
4347
void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
4348
{
4349
    Context *context = GetValidGlobalContext();
4350
    EVENT(context, GLBlendEquationSeparateiEXT,
4351
          "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf,
4352
          GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
4353
          GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
4354

4355
    if (context)
4356
    {
4357
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4358
        bool isCallValid                                      = (context->skipValidation() ||
4359
                            ValidateBlendEquationSeparateiEXT(context, buf, modeRGB, modeAlpha));
4360
        if (isCallValid)
4361
        {
4362
            context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
4363
        }
4364
        ANGLE_CAPTURE(BlendEquationSeparateiEXT, isCallValid, context, buf, modeRGB, modeAlpha);
4365
    }
4366
    else
4367
    {
4368
        GenerateContextLostErrorOnCurrentGlobalContext();
4369
    }
4370
}
4371

4372
void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode)
4373
{
4374
    Context *context = GetValidGlobalContext();
4375
    EVENT(context, GLBlendEquationiEXT, "context = %d, buf = %u, mode = %s", CID(context), buf,
4376
          GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
4377

4378
    if (context)
4379
    {
4380
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4381
        bool isCallValid =
4382
            (context->skipValidation() || ValidateBlendEquationiEXT(context, buf, mode));
4383
        if (isCallValid)
4384
        {
4385
            context->blendEquationi(buf, mode);
4386
        }
4387
        ANGLE_CAPTURE(BlendEquationiEXT, isCallValid, context, buf, mode);
4388
    }
4389
    else
4390
    {
4391
        GenerateContextLostErrorOnCurrentGlobalContext();
4392
    }
4393
}
4394

4395
void GL_APIENTRY
4396
GL_BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
4397
{
4398
    Context *context = GetValidGlobalContext();
4399
    EVENT(context, GLBlendFuncSeparateiEXT,
4400
          "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s",
4401
          CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
4402
          GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
4403
          GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
4404
          GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
4405

4406
    if (context)
4407
    {
4408
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4409
        bool isCallValid =
4410
            (context->skipValidation() ||
4411
             ValidateBlendFuncSeparateiEXT(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
4412
        if (isCallValid)
4413
        {
4414
            context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
4415
        }
4416
        ANGLE_CAPTURE(BlendFuncSeparateiEXT, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
4417
                      dstAlpha);
4418
    }
4419
    else
4420
    {
4421
        GenerateContextLostErrorOnCurrentGlobalContext();
4422
    }
4423
}
4424

4425
void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst)
4426
{
4427
    Context *context = GetValidGlobalContext();
4428
    EVENT(context, GLBlendFunciEXT, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf,
4429
          GLenumToString(GLenumGroup::BlendingFactor, src),
4430
          GLenumToString(GLenumGroup::BlendingFactor, dst));
4431

4432
    if (context)
4433
    {
4434
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4435
        bool isCallValid =
4436
            (context->skipValidation() || ValidateBlendFunciEXT(context, buf, src, dst));
4437
        if (isCallValid)
4438
        {
4439
            context->blendFunci(buf, src, dst);
4440
        }
4441
        ANGLE_CAPTURE(BlendFunciEXT, isCallValid, context, buf, src, dst);
4442
    }
4443
    else
4444
    {
4445
        GenerateContextLostErrorOnCurrentGlobalContext();
4446
    }
4447
}
4448

4449
void GL_APIENTRY GL_ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
4450
{
4451
    Context *context = GetValidGlobalContext();
4452
    EVENT(context, GLColorMaskiEXT, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s",
4453
          CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
4454
          GLbooleanToString(a));
4455

4456
    if (context)
4457
    {
4458
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4459
        bool isCallValid =
4460
            (context->skipValidation() || ValidateColorMaskiEXT(context, index, r, g, b, a));
4461
        if (isCallValid)
4462
        {
4463
            context->colorMaski(index, r, g, b, a);
4464
        }
4465
        ANGLE_CAPTURE(ColorMaskiEXT, isCallValid, context, index, r, g, b, a);
4466
    }
4467
    else
4468
    {
4469
        GenerateContextLostErrorOnCurrentGlobalContext();
4470
    }
4471
}
4472

4473
void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index)
4474
{
4475
    Context *context = GetValidGlobalContext();
4476
    EVENT(context, GLDisableiEXT, "context = %d, target = %s, index = %u", CID(context),
4477
          GLenumToString(GLenumGroup::EnableCap, target), index);
4478

4479
    if (context)
4480
    {
4481
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4482
        bool isCallValid =
4483
            (context->skipValidation() || ValidateDisableiEXT(context, target, index));
4484
        if (isCallValid)
4485
        {
4486
            context->disablei(target, index);
4487
        }
4488
        ANGLE_CAPTURE(DisableiEXT, isCallValid, context, target, index);
4489
    }
4490
    else
4491
    {
4492
        GenerateContextLostErrorOnCurrentGlobalContext();
4493
    }
4494
}
4495

4496
void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index)
4497
{
4498
    Context *context = GetValidGlobalContext();
4499
    EVENT(context, GLEnableiEXT, "context = %d, target = %s, index = %u", CID(context),
4500
          GLenumToString(GLenumGroup::EnableCap, target), index);
4501

4502
    if (context)
4503
    {
4504
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4505
        bool isCallValid =
4506
            (context->skipValidation() || ValidateEnableiEXT(context, target, index));
4507
        if (isCallValid)
4508
        {
4509
            context->enablei(target, index);
4510
        }
4511
        ANGLE_CAPTURE(EnableiEXT, isCallValid, context, target, index);
4512
    }
4513
    else
4514
    {
4515
        GenerateContextLostErrorOnCurrentGlobalContext();
4516
    }
4517
}
4518

4519
GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index)
4520
{
4521
    Context *context = GetValidGlobalContext();
4522
    EVENT(context, GLIsEnablediEXT, "context = %d, target = %s, index = %u", CID(context),
4523
          GLenumToString(GLenumGroup::EnableCap, target), index);
4524

4525
    GLboolean returnValue;
4526
    if (context)
4527
    {
4528
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4529
        bool isCallValid =
4530
            (context->skipValidation() || ValidateIsEnablediEXT(context, target, index));
4531
        if (isCallValid)
4532
        {
4533
            returnValue = context->isEnabledi(target, index);
4534
        }
4535
        else
4536
        {
4537
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>();
4538
        }
4539
        ANGLE_CAPTURE(IsEnablediEXT, isCallValid, context, target, index, returnValue);
4540
    }
4541
    else
4542
    {
4543
        GenerateContextLostErrorOnCurrentGlobalContext();
4544
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>();
4545
    }
4546
    return returnValue;
4547
}
4548

4549
// GL_EXT_draw_elements_base_vertex
4550
void GL_APIENTRY GL_DrawElementsBaseVertexEXT(GLenum mode,
4551
                                              GLsizei count,
4552
                                              GLenum type,
4553
                                              const void *indices,
4554
                                              GLint basevertex)
4555
{
4556
    Context *context = GetValidGlobalContext();
4557
    EVENT(context, GLDrawElementsBaseVertexEXT,
4558
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
4559
          ", basevertex = %d",
4560
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
4561
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
4562

4563
    if (context)
4564
    {
4565
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
4566
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
4567
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4568
        bool isCallValid                                      = (context->skipValidation() ||
4569
                            ValidateDrawElementsBaseVertexEXT(context, modePacked, count,
4570
                                                              typePacked, indices, basevertex));
4571
        if (isCallValid)
4572
        {
4573
            context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
4574
        }
4575
        ANGLE_CAPTURE(DrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
4576
                      typePacked, indices, basevertex);
4577
    }
4578
    else
4579
    {
4580
        GenerateContextLostErrorOnCurrentGlobalContext();
4581
    }
4582
}
4583

4584
void GL_APIENTRY GL_DrawElementsInstancedBaseVertexEXT(GLenum mode,
4585
                                                       GLsizei count,
4586
                                                       GLenum type,
4587
                                                       const void *indices,
4588
                                                       GLsizei instancecount,
4589
                                                       GLint basevertex)
4590
{
4591
    Context *context = GetValidGlobalContext();
4592
    EVENT(context, GLDrawElementsInstancedBaseVertexEXT,
4593
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
4594
          ", instancecount = %d, basevertex = %d",
4595
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
4596
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
4597
          basevertex);
4598

4599
    if (context)
4600
    {
4601
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
4602
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
4603
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4604
        bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexEXT(
4605
                                                             context, modePacked, count, typePacked,
4606
                                                             indices, instancecount, basevertex));
4607
        if (isCallValid)
4608
        {
4609
            context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
4610
                                                     instancecount, basevertex);
4611
        }
4612
        ANGLE_CAPTURE(DrawElementsInstancedBaseVertexEXT, isCallValid, context, modePacked, count,
4613
                      typePacked, indices, instancecount, basevertex);
4614
    }
4615
    else
4616
    {
4617
        GenerateContextLostErrorOnCurrentGlobalContext();
4618
    }
4619
}
4620

4621
void GL_APIENTRY GL_DrawRangeElementsBaseVertexEXT(GLenum mode,
4622
                                                   GLuint start,
4623
                                                   GLuint end,
4624
                                                   GLsizei count,
4625
                                                   GLenum type,
4626
                                                   const void *indices,
4627
                                                   GLint basevertex)
4628
{
4629
    Context *context = GetValidGlobalContext();
4630
    EVENT(context, GLDrawRangeElementsBaseVertexEXT,
4631
          "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
4632
          "0x%016" PRIxPTR ", basevertex = %d",
4633
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
4634
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
4635

4636
    if (context)
4637
    {
4638
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
4639
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
4640
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4641
        bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertexEXT(
4642
                                                             context, modePacked, start, end, count,
4643
                                                             typePacked, indices, basevertex));
4644
        if (isCallValid)
4645
        {
4646
            context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
4647
                                                 basevertex);
4648
        }
4649
        ANGLE_CAPTURE(DrawRangeElementsBaseVertexEXT, isCallValid, context, modePacked, start, end,
4650
                      count, typePacked, indices, basevertex);
4651
    }
4652
    else
4653
    {
4654
        GenerateContextLostErrorOnCurrentGlobalContext();
4655
    }
4656
}
4657

4658
void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode,
4659
                                                   const GLsizei *count,
4660
                                                   GLenum type,
4661
                                                   const void *const *indices,
4662
                                                   GLsizei primcount,
4663
                                                   const GLint *basevertex)
4664
{
4665
    Context *context = GetValidGlobalContext();
4666
    EVENT(context, GLMultiDrawElementsBaseVertexEXT,
4667
          "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
4668
          ", primcount = %d, basevertex = 0x%016" PRIxPTR "",
4669
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count,
4670
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount,
4671
          (uintptr_t)basevertex);
4672

4673
    if (context)
4674
    {
4675
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
4676
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
4677
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4678
        bool isCallValid = (context->skipValidation() || ValidateMultiDrawElementsBaseVertexEXT(
4679
                                                             context, modePacked, count, typePacked,
4680
                                                             indices, primcount, basevertex));
4681
        if (isCallValid)
4682
        {
4683
            context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, primcount,
4684
                                                 basevertex);
4685
        }
4686
        ANGLE_CAPTURE(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
4687
                      typePacked, indices, primcount, basevertex);
4688
    }
4689
    else
4690
    {
4691
        GenerateContextLostErrorOnCurrentGlobalContext();
4692
    }
4693
}
4694

4695
// GL_EXT_external_buffer
4696
void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target,
4697
                                             GLintptr offset,
4698
                                             GLsizeiptr size,
4699
                                             GLeglClientBufferEXT clientBuffer,
4700
                                             GLbitfield flags)
4701
{
4702
    Context *context = GetValidGlobalContext();
4703
    EVENT(context, GLBufferStorageExternalEXT,
4704
          "context = %d, target = %s, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR
4705
          ", flags = %s",
4706
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
4707
          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
4708
          (uintptr_t)clientBuffer,
4709
          GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str());
4710

4711
    if (context)
4712
    {
4713
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
4714
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4715
        bool isCallValid                                      = (context->skipValidation() ||
4716
                            ValidateBufferStorageExternalEXT(context, targetPacked, offset, size,
4717
                                                             clientBuffer, flags));
4718
        if (isCallValid)
4719
        {
4720
            context->bufferStorageExternal(targetPacked, offset, size, clientBuffer, flags);
4721
        }
4722
        ANGLE_CAPTURE(BufferStorageExternalEXT, isCallValid, context, targetPacked, offset, size,
4723
                      clientBuffer, flags);
4724
    }
4725
    else
4726
    {
4727
        GenerateContextLostErrorOnCurrentGlobalContext();
4728
    }
4729
}
4730

4731
void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer,
4732
                                                  GLintptr offset,
4733
                                                  GLsizeiptr size,
4734
                                                  GLeglClientBufferEXT clientBuffer,
4735
                                                  GLbitfield flags)
4736
{
4737
    Context *context = GetValidGlobalContext();
4738
    EVENT(context, GLNamedBufferStorageExternalEXT,
4739
          "context = %d, buffer = %u, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR
4740
          ", flags = %s",
4741
          CID(context), buffer, static_cast<unsigned long long>(offset),
4742
          static_cast<unsigned long long>(size), (uintptr_t)clientBuffer,
4743
          GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str());
4744

4745
    if (context)
4746
    {
4747
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4748
        bool isCallValid =
4749
            (context->skipValidation() || ValidateNamedBufferStorageExternalEXT(
4750
                                              context, buffer, offset, size, clientBuffer, flags));
4751
        if (isCallValid)
4752
        {
4753
            context->namedBufferStorageExternal(buffer, offset, size, clientBuffer, flags);
4754
        }
4755
        ANGLE_CAPTURE(NamedBufferStorageExternalEXT, isCallValid, context, buffer, offset, size,
4756
                      clientBuffer, flags);
4757
    }
4758
    else
4759
    {
4760
        GenerateContextLostErrorOnCurrentGlobalContext();
4761
    }
4762
}
4763

4764
// GL_EXT_geometry_shader
4765
void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target,
4766
                                          GLenum attachment,
4767
                                          GLuint texture,
4768
                                          GLint level)
4769
{
4770
    Context *context = GetValidGlobalContext();
4771
    EVENT(context, GLFramebufferTextureEXT,
4772
          "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context),
4773
          GLenumToString(GLenumGroup::FramebufferTarget, target),
4774
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
4775

4776
    if (context)
4777
    {
4778
        TextureID texturePacked                               = PackParam<TextureID>(texture);
4779
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4780
        bool isCallValid =
4781
            (context->skipValidation() ||
4782
             ValidateFramebufferTextureEXT(context, target, attachment, texturePacked, level));
4783
        if (isCallValid)
4784
        {
4785
            context->framebufferTexture(target, attachment, texturePacked, level);
4786
        }
4787
        ANGLE_CAPTURE(FramebufferTextureEXT, isCallValid, context, target, attachment,
4788
                      texturePacked, level);
4789
    }
4790
    else
4791
    {
4792
        GenerateContextLostErrorOnCurrentGlobalContext();
4793
    }
4794
}
4795

4796
// GL_EXT_instanced_arrays
4797
void GL_APIENTRY GL_DrawArraysInstancedEXT(GLenum mode,
4798
                                           GLint start,
4799
                                           GLsizei count,
4800
                                           GLsizei primcount)
4801
{
4802
    Context *context = GetValidGlobalContext();
4803
    EVENT(context, GLDrawArraysInstancedEXT,
4804
          "context = %d, mode = %s, start = %d, count = %d, primcount = %d", CID(context),
4805
          GLenumToString(GLenumGroup::PrimitiveType, mode), start, count, primcount);
4806

4807
    if (context)
4808
    {
4809
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
4810
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4811
        bool isCallValid =
4812
            (context->skipValidation() ||
4813
             ValidateDrawArraysInstancedEXT(context, modePacked, start, count, primcount));
4814
        if (isCallValid)
4815
        {
4816
            context->drawArraysInstanced(modePacked, start, count, primcount);
4817
        }
4818
        ANGLE_CAPTURE(DrawArraysInstancedEXT, isCallValid, context, modePacked, start, count,
4819
                      primcount);
4820
    }
4821
    else
4822
    {
4823
        GenerateContextLostErrorOnCurrentGlobalContext();
4824
    }
4825
}
4826

4827
void GL_APIENTRY GL_DrawElementsInstancedEXT(GLenum mode,
4828
                                             GLsizei count,
4829
                                             GLenum type,
4830
                                             const void *indices,
4831
                                             GLsizei primcount)
4832
{
4833
    Context *context = GetValidGlobalContext();
4834
    EVENT(context, GLDrawElementsInstancedEXT,
4835
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
4836
          ", primcount = %d",
4837
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
4838
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount);
4839

4840
    if (context)
4841
    {
4842
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
4843
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
4844
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4845
        bool isCallValid                                      = (context->skipValidation() ||
4846
                            ValidateDrawElementsInstancedEXT(context, modePacked, count, typePacked,
4847
                                                             indices, primcount));
4848
        if (isCallValid)
4849
        {
4850
            context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
4851
        }
4852
        ANGLE_CAPTURE(DrawElementsInstancedEXT, isCallValid, context, modePacked, count, typePacked,
4853
                      indices, primcount);
4854
    }
4855
    else
4856
    {
4857
        GenerateContextLostErrorOnCurrentGlobalContext();
4858
    }
4859
}
4860

4861
void GL_APIENTRY GL_VertexAttribDivisorEXT(GLuint index, GLuint divisor)
4862
{
4863
    Context *context = GetValidGlobalContext();
4864
    EVENT(context, GLVertexAttribDivisorEXT, "context = %d, index = %u, divisor = %u", CID(context),
4865
          index, divisor);
4866

4867
    if (context)
4868
    {
4869
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4870
        bool isCallValid =
4871
            (context->skipValidation() || ValidateVertexAttribDivisorEXT(context, index, divisor));
4872
        if (isCallValid)
4873
        {
4874
            context->vertexAttribDivisor(index, divisor);
4875
        }
4876
        ANGLE_CAPTURE(VertexAttribDivisorEXT, isCallValid, context, index, divisor);
4877
    }
4878
    else
4879
    {
4880
        GenerateContextLostErrorOnCurrentGlobalContext();
4881
    }
4882
}
4883

4884
// GL_EXT_map_buffer_range
4885
void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
4886
{
4887
    Context *context = GetValidGlobalContext();
4888
    EVENT(context, GLFlushMappedBufferRangeEXT,
4889
          "context = %d, target = %s, offset = %llu, length = %llu", CID(context),
4890
          GLenumToString(GLenumGroup::BufferTargetARB, target),
4891
          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
4892

4893
    if (context)
4894
    {
4895
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
4896
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4897
        bool isCallValid =
4898
            (context->skipValidation() ||
4899
             ValidateFlushMappedBufferRangeEXT(context, targetPacked, offset, length));
4900
        if (isCallValid)
4901
        {
4902
            context->flushMappedBufferRange(targetPacked, offset, length);
4903
        }
4904
        ANGLE_CAPTURE(FlushMappedBufferRangeEXT, isCallValid, context, targetPacked, offset,
4905
                      length);
4906
    }
4907
    else
4908
    {
4909
        GenerateContextLostErrorOnCurrentGlobalContext();
4910
    }
4911
}
4912

4913
void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target,
4914
                                       GLintptr offset,
4915
                                       GLsizeiptr length,
4916
                                       GLbitfield access)
4917
{
4918
    Context *context = GetValidGlobalContext();
4919
    EVENT(context, GLMapBufferRangeEXT,
4920
          "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context),
4921
          GLenumToString(GLenumGroup::BufferTargetARB, target),
4922
          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
4923
          GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
4924

4925
    void *returnValue;
4926
    if (context)
4927
    {
4928
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
4929
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4930
        bool isCallValid =
4931
            (context->skipValidation() ||
4932
             ValidateMapBufferRangeEXT(context, targetPacked, offset, length, access));
4933
        if (isCallValid)
4934
        {
4935
            returnValue = context->mapBufferRange(targetPacked, offset, length, access);
4936
        }
4937
        else
4938
        {
4939
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>();
4940
        }
4941
        ANGLE_CAPTURE(MapBufferRangeEXT, isCallValid, context, targetPacked, offset, length, access,
4942
                      returnValue);
4943
    }
4944
    else
4945
    {
4946
        GenerateContextLostErrorOnCurrentGlobalContext();
4947
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>();
4948
    }
4949
    return returnValue;
4950
}
4951

4952
// GL_EXT_memory_object
4953
void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target,
4954
                                        GLsizeiptr size,
4955
                                        GLuint memory,
4956
                                        GLuint64 offset)
4957
{
4958
    Context *context = GetValidGlobalContext();
4959
    EVENT(context, GLBufferStorageMemEXT,
4960
          "context = %d, target = %s, size = %llu, memory = %u, offset = %llu", CID(context),
4961
          GLenumToString(GLenumGroup::BufferTargetARB, target),
4962
          static_cast<unsigned long long>(size), memory, static_cast<unsigned long long>(offset));
4963

4964
    if (context)
4965
    {
4966
        TextureType targetPacked                              = PackParam<TextureType>(target);
4967
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
4968
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4969
        bool isCallValid =
4970
            (context->skipValidation() ||
4971
             ValidateBufferStorageMemEXT(context, targetPacked, size, memoryPacked, offset));
4972
        if (isCallValid)
4973
        {
4974
            context->bufferStorageMem(targetPacked, size, memoryPacked, offset);
4975
        }
4976
        ANGLE_CAPTURE(BufferStorageMemEXT, isCallValid, context, targetPacked, size, memoryPacked,
4977
                      offset);
4978
    }
4979
    else
4980
    {
4981
        GenerateContextLostErrorOnCurrentGlobalContext();
4982
    }
4983
}
4984

4985
void GL_APIENTRY GL_CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
4986
{
4987
    Context *context = GetValidGlobalContext();
4988
    EVENT(context, GLCreateMemoryObjectsEXT,
4989
          "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n,
4990
          (uintptr_t)memoryObjects);
4991

4992
    if (context)
4993
    {
4994
        MemoryObjectID *memoryObjectsPacked = PackParam<MemoryObjectID *>(memoryObjects);
4995
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4996
        bool isCallValid                                      = (context->skipValidation() ||
4997
                            ValidateCreateMemoryObjectsEXT(context, n, memoryObjectsPacked));
4998
        if (isCallValid)
4999
        {
5000
            context->createMemoryObjects(n, memoryObjectsPacked);
5001
        }
5002
        ANGLE_CAPTURE(CreateMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
5003
    }
5004
    else
5005
    {
5006
        GenerateContextLostErrorOnCurrentGlobalContext();
5007
    }
5008
}
5009

5010
void GL_APIENTRY GL_DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
5011
{
5012
    Context *context = GetValidGlobalContext();
5013
    EVENT(context, GLDeleteMemoryObjectsEXT,
5014
          "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n,
5015
          (uintptr_t)memoryObjects);
5016

5017
    if (context)
5018
    {
5019
        const MemoryObjectID *memoryObjectsPacked =
5020
            PackParam<const MemoryObjectID *>(memoryObjects);
5021
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5022
        bool isCallValid                                      = (context->skipValidation() ||
5023
                            ValidateDeleteMemoryObjectsEXT(context, n, memoryObjectsPacked));
5024
        if (isCallValid)
5025
        {
5026
            context->deleteMemoryObjects(n, memoryObjectsPacked);
5027
        }
5028
        ANGLE_CAPTURE(DeleteMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
5029
    }
5030
    else
5031
    {
5032
        GenerateContextLostErrorOnCurrentGlobalContext();
5033
    }
5034
}
5035

5036
void GL_APIENTRY GL_GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
5037
{
5038
    Context *context = GetValidGlobalContext();
5039
    EVENT(context, GLGetMemoryObjectParameterivEXT,
5040
          "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5041
          memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
5042
          (uintptr_t)params);
5043

5044
    if (context)
5045
    {
5046
        MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
5047
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5048
        bool isCallValid =
5049
            (context->skipValidation() ||
5050
             ValidateGetMemoryObjectParameterivEXT(context, memoryObjectPacked, pname, params));
5051
        if (isCallValid)
5052
        {
5053
            context->getMemoryObjectParameteriv(memoryObjectPacked, pname, params);
5054
        }
5055
        ANGLE_CAPTURE(GetMemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked,
5056
                      pname, params);
5057
    }
5058
    else
5059
    {
5060
        GenerateContextLostErrorOnCurrentGlobalContext();
5061
    }
5062
}
5063

5064
void GL_APIENTRY GL_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
5065
{
5066
    Context *context = GetValidGlobalContext();
5067
    EVENT(context, GLGetUnsignedBytevEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
5068
          CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
5069

5070
    if (context)
5071
    {
5072
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5073
        bool isCallValid =
5074
            (context->skipValidation() || ValidateGetUnsignedBytevEXT(context, pname, data));
5075
        if (isCallValid)
5076
        {
5077
            context->getUnsignedBytev(pname, data);
5078
        }
5079
        ANGLE_CAPTURE(GetUnsignedBytevEXT, isCallValid, context, pname, data);
5080
    }
5081
    else
5082
    {
5083
        GenerateContextLostErrorOnCurrentGlobalContext();
5084
    }
5085
}
5086

5087
void GL_APIENTRY GL_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
5088
{
5089
    Context *context = GetValidGlobalContext();
5090
    EVENT(context, GLGetUnsignedBytei_vEXT,
5091
          "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context),
5092
          GLenumToString(GLenumGroup::DefaultGroup, target), index, (uintptr_t)data);
5093

5094
    if (context)
5095
    {
5096
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5097
        bool isCallValid                                      = (context->skipValidation() ||
5098
                            ValidateGetUnsignedBytei_vEXT(context, target, index, data));
5099
        if (isCallValid)
5100
        {
5101
            context->getUnsignedBytei_v(target, index, data);
5102
        }
5103
        ANGLE_CAPTURE(GetUnsignedBytei_vEXT, isCallValid, context, target, index, data);
5104
    }
5105
    else
5106
    {
5107
        GenerateContextLostErrorOnCurrentGlobalContext();
5108
    }
5109
}
5110

5111
GLboolean GL_APIENTRY GL_IsMemoryObjectEXT(GLuint memoryObject)
5112
{
5113
    Context *context = GetValidGlobalContext();
5114
    EVENT(context, GLIsMemoryObjectEXT, "context = %d, memoryObject = %u", CID(context),
5115
          memoryObject);
5116

5117
    GLboolean returnValue;
5118
    if (context)
5119
    {
5120
        MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
5121
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5122
        bool isCallValid =
5123
            (context->skipValidation() || ValidateIsMemoryObjectEXT(context, memoryObjectPacked));
5124
        if (isCallValid)
5125
        {
5126
            returnValue = context->isMemoryObject(memoryObjectPacked);
5127
        }
5128
        else
5129
        {
5130
            returnValue =
5131
                GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>();
5132
        }
5133
        ANGLE_CAPTURE(IsMemoryObjectEXT, isCallValid, context, memoryObjectPacked, returnValue);
5134
    }
5135
    else
5136
    {
5137
        GenerateContextLostErrorOnCurrentGlobalContext();
5138
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>();
5139
    }
5140
    return returnValue;
5141
}
5142

5143
void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject,
5144
                                               GLenum pname,
5145
                                               const GLint *params)
5146
{
5147
    Context *context = GetValidGlobalContext();
5148
    EVENT(context, GLMemoryObjectParameterivEXT,
5149
          "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5150
          memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
5151
          (uintptr_t)params);
5152

5153
    if (context)
5154
    {
5155
        MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
5156
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5157
        bool isCallValid =
5158
            (context->skipValidation() ||
5159
             ValidateMemoryObjectParameterivEXT(context, memoryObjectPacked, pname, params));
5160
        if (isCallValid)
5161
        {
5162
            context->memoryObjectParameteriv(memoryObjectPacked, pname, params);
5163
        }
5164
        ANGLE_CAPTURE(MemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked, pname,
5165
                      params);
5166
    }
5167
    else
5168
    {
5169
        GenerateContextLostErrorOnCurrentGlobalContext();
5170
    }
5171
}
5172

5173
void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target,
5174
                                       GLsizei levels,
5175
                                       GLenum internalFormat,
5176
                                       GLsizei width,
5177
                                       GLsizei height,
5178
                                       GLuint memory,
5179
                                       GLuint64 offset)
5180
{
5181
    Context *context = GetValidGlobalContext();
5182
    EVENT(context, GLTexStorageMem2DEXT,
5183
          "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
5184
          "memory = %u, offset = %llu",
5185
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
5186
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory,
5187
          static_cast<unsigned long long>(offset));
5188

5189
    if (context)
5190
    {
5191
        TextureType targetPacked                              = PackParam<TextureType>(target);
5192
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
5193
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5194
        bool isCallValid =
5195
            (context->skipValidation() ||
5196
             ValidateTexStorageMem2DEXT(context, targetPacked, levels, internalFormat, width,
5197
                                        height, memoryPacked, offset));
5198
        if (isCallValid)
5199
        {
5200
            context->texStorageMem2D(targetPacked, levels, internalFormat, width, height,
5201
                                     memoryPacked, offset);
5202
        }
5203
        ANGLE_CAPTURE(TexStorageMem2DEXT, isCallValid, context, targetPacked, levels,
5204
                      internalFormat, width, height, memoryPacked, offset);
5205
    }
5206
    else
5207
    {
5208
        GenerateContextLostErrorOnCurrentGlobalContext();
5209
    }
5210
}
5211

5212
void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target,
5213
                                                  GLsizei samples,
5214
                                                  GLenum internalFormat,
5215
                                                  GLsizei width,
5216
                                                  GLsizei height,
5217
                                                  GLboolean fixedSampleLocations,
5218
                                                  GLuint memory,
5219
                                                  GLuint64 offset)
5220
{
5221
    Context *context = GetValidGlobalContext();
5222
    EVENT(context, GLTexStorageMem2DMultisampleEXT,
5223
          "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
5224
          "fixedSampleLocations = %s, memory = %u, offset = %llu",
5225
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
5226
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height,
5227
          GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
5228

5229
    if (context)
5230
    {
5231
        TextureType targetPacked                              = PackParam<TextureType>(target);
5232
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
5233
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5234
        bool isCallValid =
5235
            (context->skipValidation() || ValidateTexStorageMem2DMultisampleEXT(
5236
                                              context, targetPacked, samples, internalFormat, width,
5237
                                              height, fixedSampleLocations, memoryPacked, offset));
5238
        if (isCallValid)
5239
        {
5240
            context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
5241
                                                height, fixedSampleLocations, memoryPacked, offset);
5242
        }
5243
        ANGLE_CAPTURE(TexStorageMem2DMultisampleEXT, isCallValid, context, targetPacked, samples,
5244
                      internalFormat, width, height, fixedSampleLocations, memoryPacked, offset);
5245
    }
5246
    else
5247
    {
5248
        GenerateContextLostErrorOnCurrentGlobalContext();
5249
    }
5250
}
5251

5252
void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target,
5253
                                       GLsizei levels,
5254
                                       GLenum internalFormat,
5255
                                       GLsizei width,
5256
                                       GLsizei height,
5257
                                       GLsizei depth,
5258
                                       GLuint memory,
5259
                                       GLuint64 offset)
5260
{
5261
    Context *context = GetValidGlobalContext();
5262
    EVENT(context, GLTexStorageMem3DEXT,
5263
          "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
5264
          "depth = %d, memory = %u, offset = %llu",
5265
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
5266
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory,
5267
          static_cast<unsigned long long>(offset));
5268

5269
    if (context)
5270
    {
5271
        TextureType targetPacked                              = PackParam<TextureType>(target);
5272
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
5273
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5274
        bool isCallValid =
5275
            (context->skipValidation() ||
5276
             ValidateTexStorageMem3DEXT(context, targetPacked, levels, internalFormat, width,
5277
                                        height, depth, memoryPacked, offset));
5278
        if (isCallValid)
5279
        {
5280
            context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
5281
                                     memoryPacked, offset);
5282
        }
5283
        ANGLE_CAPTURE(TexStorageMem3DEXT, isCallValid, context, targetPacked, levels,
5284
                      internalFormat, width, height, depth, memoryPacked, offset);
5285
    }
5286
    else
5287
    {
5288
        GenerateContextLostErrorOnCurrentGlobalContext();
5289
    }
5290
}
5291

5292
void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target,
5293
                                                  GLsizei samples,
5294
                                                  GLenum internalFormat,
5295
                                                  GLsizei width,
5296
                                                  GLsizei height,
5297
                                                  GLsizei depth,
5298
                                                  GLboolean fixedSampleLocations,
5299
                                                  GLuint memory,
5300
                                                  GLuint64 offset)
5301
{
5302
    Context *context = GetValidGlobalContext();
5303
    EVENT(context, GLTexStorageMem3DMultisampleEXT,
5304
          "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
5305
          "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu",
5306
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
5307
          GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth,
5308
          GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
5309

5310
    if (context)
5311
    {
5312
        TextureType targetPacked                              = PackParam<TextureType>(target);
5313
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
5314
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5315
        bool isCallValid                                      = (context->skipValidation() ||
5316
                            ValidateTexStorageMem3DMultisampleEXT(
5317
                                context, targetPacked, samples, internalFormat, width, height,
5318
                                depth, fixedSampleLocations, memoryPacked, offset));
5319
        if (isCallValid)
5320
        {
5321
            context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
5322
                                                height, depth, fixedSampleLocations, memoryPacked,
5323
                                                offset);
5324
        }
5325
        ANGLE_CAPTURE(TexStorageMem3DMultisampleEXT, isCallValid, context, targetPacked, samples,
5326
                      internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
5327
                      offset);
5328
    }
5329
    else
5330
    {
5331
        GenerateContextLostErrorOnCurrentGlobalContext();
5332
    }
5333
}
5334

5335
// GL_EXT_memory_object_fd
5336
void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
5337
{
5338
    Context *context = GetValidGlobalContext();
5339
    EVENT(context, GLImportMemoryFdEXT,
5340
          "context = %d, memory = %u, size = %llu, handleType = %s, fd = %d", CID(context), memory,
5341
          static_cast<unsigned long long>(size),
5342
          GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
5343

5344
    if (context)
5345
    {
5346
        MemoryObjectID memoryPacked                           = PackParam<MemoryObjectID>(memory);
5347
        HandleType handleTypePacked                           = PackParam<HandleType>(handleType);
5348
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5349
        bool isCallValid =
5350
            (context->skipValidation() ||
5351
             ValidateImportMemoryFdEXT(context, memoryPacked, size, handleTypePacked, fd));
5352
        if (isCallValid)
5353
        {
5354
            context->importMemoryFd(memoryPacked, size, handleTypePacked, fd);
5355
        }
5356
        ANGLE_CAPTURE(ImportMemoryFdEXT, isCallValid, context, memoryPacked, size, handleTypePacked,
5357
                      fd);
5358
    }
5359
    else
5360
    {
5361
        GenerateContextLostErrorOnCurrentGlobalContext();
5362
    }
5363
}
5364

5365
// GL_EXT_multisampled_render_to_texture
5366
void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target,
5367
                                                       GLenum attachment,
5368
                                                       GLenum textarget,
5369
                                                       GLuint texture,
5370
                                                       GLint level,
5371
                                                       GLsizei samples)
5372
{
5373
    Context *context = GetValidGlobalContext();
5374
    EVENT(context, GLFramebufferTexture2DMultisampleEXT,
5375
          "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
5376
          "samples = %d",
5377
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
5378
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
5379
          GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, samples);
5380

5381
    if (context)
5382
    {
5383
        TextureTarget textargetPacked                         = PackParam<TextureTarget>(textarget);
5384
        TextureID texturePacked                               = PackParam<TextureID>(texture);
5385
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5386
        bool isCallValid =
5387
            (context->skipValidation() ||
5388
             ValidateFramebufferTexture2DMultisampleEXT(
5389
                 context, target, attachment, textargetPacked, texturePacked, level, samples));
5390
        if (isCallValid)
5391
        {
5392
            context->framebufferTexture2DMultisample(target, attachment, textargetPacked,
5393
                                                     texturePacked, level, samples);
5394
        }
5395
        ANGLE_CAPTURE(FramebufferTexture2DMultisampleEXT, isCallValid, context, target, attachment,
5396
                      textargetPacked, texturePacked, level, samples);
5397
    }
5398
    else
5399
    {
5400
        GenerateContextLostErrorOnCurrentGlobalContext();
5401
    }
5402
}
5403

5404
void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target,
5405
                                                      GLsizei samples,
5406
                                                      GLenum internalformat,
5407
                                                      GLsizei width,
5408
                                                      GLsizei height)
5409
{
5410
    Context *context = GetValidGlobalContext();
5411
    EVENT(context, GLRenderbufferStorageMultisampleEXT,
5412
          "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
5413
          CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
5414
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
5415

5416
    if (context)
5417
    {
5418
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5419
        bool isCallValid                                      = (context->skipValidation() ||
5420
                            ValidateRenderbufferStorageMultisampleEXT(
5421
                                context, target, samples, internalformat, width, height));
5422
        if (isCallValid)
5423
        {
5424
            context->renderbufferStorageMultisampleEXT(target, samples, internalformat, width,
5425
                                                       height);
5426
        }
5427
        ANGLE_CAPTURE(RenderbufferStorageMultisampleEXT, isCallValid, context, target, samples,
5428
                      internalformat, width, height);
5429
    }
5430
    else
5431
    {
5432
        GenerateContextLostErrorOnCurrentGlobalContext();
5433
    }
5434
}
5435

5436
// GL_EXT_occlusion_query_boolean
5437
// BeginQueryEXT is already defined.
5438

5439
// DeleteQueriesEXT is already defined.
5440

5441
// EndQueryEXT is already defined.
5442

5443
// GenQueriesEXT is already defined.
5444

5445
// GetQueryObjectuivEXT is already defined.
5446

5447
// GetQueryivEXT is already defined.
5448

5449
// IsQueryEXT is already defined.
5450

5451
// GL_EXT_primitive_bounding_box
5452
void GL_APIENTRY GL_PrimitiveBoundingBoxEXT(GLfloat minX,
5453
                                            GLfloat minY,
5454
                                            GLfloat minZ,
5455
                                            GLfloat minW,
5456
                                            GLfloat maxX,
5457
                                            GLfloat maxY,
5458
                                            GLfloat maxZ,
5459
                                            GLfloat maxW)
5460
{
5461
    Context *context = GetValidGlobalContext();
5462
    EVENT(context, GLPrimitiveBoundingBoxEXT,
5463
          "context = %d, minX = %f, minY = %f, minZ = %f, minW = %f, maxX = %f, maxY = %f, maxZ = "
5464
          "%f, maxW = %f",
5465
          CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
5466

5467
    if (context)
5468
    {
5469
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5470
        bool isCallValid                                      = (context->skipValidation() ||
5471
                            ValidatePrimitiveBoundingBoxEXT(context, minX, minY, minZ, minW, maxX,
5472
                                                            maxY, maxZ, maxW));
5473
        if (isCallValid)
5474
        {
5475
            context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
5476
        }
5477
        ANGLE_CAPTURE(PrimitiveBoundingBoxEXT, isCallValid, context, minX, minY, minZ, minW, maxX,
5478
                      maxY, maxZ, maxW);
5479
    }
5480
    else
5481
    {
5482
        GenerateContextLostErrorOnCurrentGlobalContext();
5483
    }
5484
}
5485

5486
// GL_EXT_protected_textures
5487

5488
// GL_EXT_pvrtc_sRGB
5489

5490
// GL_EXT_read_format_bgra
5491

5492
// GL_EXT_robustness
5493
GLenum GL_APIENTRY GL_GetGraphicsResetStatusEXT()
5494
{
5495
    Context *context = GetGlobalContext();
5496
    EVENT(context, GLGetGraphicsResetStatusEXT, "context = %d", CID(context));
5497

5498
    GLenum returnValue;
5499
    if (context)
5500
    {
5501
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5502
        bool isCallValid =
5503
            (context->skipValidation() || ValidateGetGraphicsResetStatusEXT(context));
5504
        if (isCallValid)
5505
        {
5506
            returnValue = context->getGraphicsResetStatus();
5507
        }
5508
        else
5509
        {
5510
            returnValue =
5511
                GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>();
5512
        }
5513
        ANGLE_CAPTURE(GetGraphicsResetStatusEXT, isCallValid, context, returnValue);
5514
    }
5515
    else
5516
    {
5517

5518
        returnValue =
5519
            GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>();
5520
    }
5521
    return returnValue;
5522
}
5523

5524
void GL_APIENTRY GL_GetnUniformfvEXT(GLuint program,
5525
                                     GLint location,
5526
                                     GLsizei bufSize,
5527
                                     GLfloat *params)
5528
{
5529
    Context *context = GetValidGlobalContext();
5530
    EVENT(context, GLGetnUniformfvEXT,
5531
          "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
5532
          CID(context), program, location, bufSize, (uintptr_t)params);
5533

5534
    if (context)
5535
    {
5536
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
5537
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
5538
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5539
        bool isCallValid =
5540
            (context->skipValidation() ||
5541
             ValidateGetnUniformfvEXT(context, programPacked, locationPacked, bufSize, params));
5542
        if (isCallValid)
5543
        {
5544
            context->getnUniformfv(programPacked, locationPacked, bufSize, params);
5545
        }
5546
        ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
5547
                      bufSize, params);
5548
    }
5549
    else
5550
    {
5551
        GenerateContextLostErrorOnCurrentGlobalContext();
5552
    }
5553
}
5554

5555
void GL_APIENTRY GL_GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
5556
{
5557
    Context *context = GetValidGlobalContext();
5558
    EVENT(context, GLGetnUniformivEXT,
5559
          "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
5560
          CID(context), program, location, bufSize, (uintptr_t)params);
5561

5562
    if (context)
5563
    {
5564
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
5565
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
5566
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5567
        bool isCallValid =
5568
            (context->skipValidation() ||
5569
             ValidateGetnUniformivEXT(context, programPacked, locationPacked, bufSize, params));
5570
        if (isCallValid)
5571
        {
5572
            context->getnUniformiv(programPacked, locationPacked, bufSize, params);
5573
        }
5574
        ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
5575
                      bufSize, params);
5576
    }
5577
    else
5578
    {
5579
        GenerateContextLostErrorOnCurrentGlobalContext();
5580
    }
5581
}
5582

5583
void GL_APIENTRY GL_ReadnPixelsEXT(GLint x,
5584
                                   GLint y,
5585
                                   GLsizei width,
5586
                                   GLsizei height,
5587
                                   GLenum format,
5588
                                   GLenum type,
5589
                                   GLsizei bufSize,
5590
                                   void *data)
5591
{
5592
    Context *context = GetValidGlobalContext();
5593
    EVENT(context, GLReadnPixelsEXT,
5594
          "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
5595
          "= %d, data = 0x%016" PRIxPTR "",
5596
          CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
5597
          GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data);
5598

5599
    if (context)
5600
    {
5601
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5602
        bool isCallValid =
5603
            (context->skipValidation() ||
5604
             ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data));
5605
        if (isCallValid)
5606
        {
5607
            context->readnPixels(x, y, width, height, format, type, bufSize, data);
5608
        }
5609
        ANGLE_CAPTURE(ReadnPixelsEXT, isCallValid, context, x, y, width, height, format, type,
5610
                      bufSize, data);
5611
    }
5612
    else
5613
    {
5614
        GenerateContextLostErrorOnCurrentGlobalContext();
5615
    }
5616
}
5617

5618
// GL_EXT_sRGB
5619

5620
// GL_EXT_sRGB_write_control
5621

5622
// GL_EXT_semaphore
5623
void GL_APIENTRY GL_DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
5624
{
5625
    Context *context = GetValidGlobalContext();
5626
    EVENT(context, GLDeleteSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "",
5627
          CID(context), n, (uintptr_t)semaphores);
5628

5629
    if (context)
5630
    {
5631
        const SemaphoreID *semaphoresPacked = PackParam<const SemaphoreID *>(semaphores);
5632
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5633
        bool isCallValid                                      = (context->skipValidation() ||
5634
                            ValidateDeleteSemaphoresEXT(context, n, semaphoresPacked));
5635
        if (isCallValid)
5636
        {
5637
            context->deleteSemaphores(n, semaphoresPacked);
5638
        }
5639
        ANGLE_CAPTURE(DeleteSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
5640
    }
5641
    else
5642
    {
5643
        GenerateContextLostErrorOnCurrentGlobalContext();
5644
    }
5645
}
5646

5647
void GL_APIENTRY GL_GenSemaphoresEXT(GLsizei n, GLuint *semaphores)
5648
{
5649
    Context *context = GetValidGlobalContext();
5650
    EVENT(context, GLGenSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "",
5651
          CID(context), n, (uintptr_t)semaphores);
5652

5653
    if (context)
5654
    {
5655
        SemaphoreID *semaphoresPacked = PackParam<SemaphoreID *>(semaphores);
5656
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5657
        bool isCallValid =
5658
            (context->skipValidation() || ValidateGenSemaphoresEXT(context, n, semaphoresPacked));
5659
        if (isCallValid)
5660
        {
5661
            context->genSemaphores(n, semaphoresPacked);
5662
        }
5663
        ANGLE_CAPTURE(GenSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
5664
    }
5665
    else
5666
    {
5667
        GenerateContextLostErrorOnCurrentGlobalContext();
5668
    }
5669
}
5670

5671
void GL_APIENTRY GL_GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
5672
{
5673
    Context *context = GetValidGlobalContext();
5674
    EVENT(context, GLGetSemaphoreParameterui64vEXT,
5675
          "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5676
          semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname), (uintptr_t)params);
5677

5678
    if (context)
5679
    {
5680
        SemaphoreID semaphorePacked                           = PackParam<SemaphoreID>(semaphore);
5681
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5682
        bool isCallValid =
5683
            (context->skipValidation() ||
5684
             ValidateGetSemaphoreParameterui64vEXT(context, semaphorePacked, pname, params));
5685
        if (isCallValid)
5686
        {
5687
            context->getSemaphoreParameterui64v(semaphorePacked, pname, params);
5688
        }
5689
        ANGLE_CAPTURE(GetSemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
5690
                      params);
5691
    }
5692
    else
5693
    {
5694
        GenerateContextLostErrorOnCurrentGlobalContext();
5695
    }
5696
}
5697

5698
GLboolean GL_APIENTRY GL_IsSemaphoreEXT(GLuint semaphore)
5699
{
5700
    Context *context = GetValidGlobalContext();
5701
    EVENT(context, GLIsSemaphoreEXT, "context = %d, semaphore = %u", CID(context), semaphore);
5702

5703
    GLboolean returnValue;
5704
    if (context)
5705
    {
5706
        SemaphoreID semaphorePacked                           = PackParam<SemaphoreID>(semaphore);
5707
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5708
        bool isCallValid =
5709
            (context->skipValidation() || ValidateIsSemaphoreEXT(context, semaphorePacked));
5710
        if (isCallValid)
5711
        {
5712
            returnValue = context->isSemaphore(semaphorePacked);
5713
        }
5714
        else
5715
        {
5716
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>();
5717
        }
5718
        ANGLE_CAPTURE(IsSemaphoreEXT, isCallValid, context, semaphorePacked, returnValue);
5719
    }
5720
    else
5721
    {
5722
        GenerateContextLostErrorOnCurrentGlobalContext();
5723
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>();
5724
    }
5725
    return returnValue;
5726
}
5727

5728
void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore,
5729
                                               GLenum pname,
5730
                                               const GLuint64 *params)
5731
{
5732
    Context *context = GetValidGlobalContext();
5733
    EVENT(context, GLSemaphoreParameterui64vEXT,
5734
          "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5735
          semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname), (uintptr_t)params);
5736

5737
    if (context)
5738
    {
5739
        SemaphoreID semaphorePacked                           = PackParam<SemaphoreID>(semaphore);
5740
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5741
        bool isCallValid =
5742
            (context->skipValidation() ||
5743
             ValidateSemaphoreParameterui64vEXT(context, semaphorePacked, pname, params));
5744
        if (isCallValid)
5745
        {
5746
            context->semaphoreParameterui64v(semaphorePacked, pname, params);
5747
        }
5748
        ANGLE_CAPTURE(SemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
5749
                      params);
5750
    }
5751
    else
5752
    {
5753
        GenerateContextLostErrorOnCurrentGlobalContext();
5754
    }
5755
}
5756

5757
void GL_APIENTRY GL_SignalSemaphoreEXT(GLuint semaphore,
5758
                                       GLuint numBufferBarriers,
5759
                                       const GLuint *buffers,
5760
                                       GLuint numTextureBarriers,
5761
                                       const GLuint *textures,
5762
                                       const GLenum *dstLayouts)
5763
{
5764
    Context *context = GetValidGlobalContext();
5765
    EVENT(context, GLSignalSemaphoreEXT,
5766
          "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR
5767
          ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", dstLayouts = 0x%016" PRIxPTR "",
5768
          CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
5769
          (uintptr_t)textures, (uintptr_t)dstLayouts);
5770

5771
    if (context)
5772
    {
5773
        SemaphoreID semaphorePacked     = PackParam<SemaphoreID>(semaphore);
5774
        const BufferID *buffersPacked   = PackParam<const BufferID *>(buffers);
5775
        const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
5776
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5777
        bool isCallValid =
5778
            (context->skipValidation() ||
5779
             ValidateSignalSemaphoreEXT(context, semaphorePacked, numBufferBarriers, buffersPacked,
5780
                                        numTextureBarriers, texturesPacked, dstLayouts));
5781
        if (isCallValid)
5782
        {
5783
            context->signalSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
5784
                                     numTextureBarriers, texturesPacked, dstLayouts);
5785
        }
5786
        ANGLE_CAPTURE(SignalSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
5787
                      buffersPacked, numTextureBarriers, texturesPacked, dstLayouts);
5788
    }
5789
    else
5790
    {
5791
        GenerateContextLostErrorOnCurrentGlobalContext();
5792
    }
5793
}
5794

5795
void GL_APIENTRY GL_WaitSemaphoreEXT(GLuint semaphore,
5796
                                     GLuint numBufferBarriers,
5797
                                     const GLuint *buffers,
5798
                                     GLuint numTextureBarriers,
5799
                                     const GLuint *textures,
5800
                                     const GLenum *srcLayouts)
5801
{
5802
    Context *context = GetValidGlobalContext();
5803
    EVENT(context, GLWaitSemaphoreEXT,
5804
          "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR
5805
          ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", srcLayouts = 0x%016" PRIxPTR "",
5806
          CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
5807
          (uintptr_t)textures, (uintptr_t)srcLayouts);
5808

5809
    if (context)
5810
    {
5811
        SemaphoreID semaphorePacked     = PackParam<SemaphoreID>(semaphore);
5812
        const BufferID *buffersPacked   = PackParam<const BufferID *>(buffers);
5813
        const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
5814
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5815
        bool isCallValid =
5816
            (context->skipValidation() ||
5817
             ValidateWaitSemaphoreEXT(context, semaphorePacked, numBufferBarriers, buffersPacked,
5818
                                      numTextureBarriers, texturesPacked, srcLayouts));
5819
        if (isCallValid)
5820
        {
5821
            context->waitSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
5822
                                   numTextureBarriers, texturesPacked, srcLayouts);
5823
        }
5824
        ANGLE_CAPTURE(WaitSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
5825
                      buffersPacked, numTextureBarriers, texturesPacked, srcLayouts);
5826
    }
5827
    else
5828
    {
5829
        GenerateContextLostErrorOnCurrentGlobalContext();
5830
    }
5831
}
5832

5833
// GetUnsignedBytei_vEXT is already defined.
5834

5835
// GetUnsignedBytevEXT is already defined.
5836

5837
// GL_EXT_semaphore_fd
5838
void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
5839
{
5840
    Context *context = GetValidGlobalContext();
5841
    EVENT(context, GLImportSemaphoreFdEXT, "context = %d, semaphore = %u, handleType = %s, fd = %d",
5842
          CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
5843

5844
    if (context)
5845
    {
5846
        SemaphoreID semaphorePacked                           = PackParam<SemaphoreID>(semaphore);
5847
        HandleType handleTypePacked                           = PackParam<HandleType>(handleType);
5848
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5849
        bool isCallValid =
5850
            (context->skipValidation() ||
5851
             ValidateImportSemaphoreFdEXT(context, semaphorePacked, handleTypePacked, fd));
5852
        if (isCallValid)
5853
        {
5854
            context->importSemaphoreFd(semaphorePacked, handleTypePacked, fd);
5855
        }
5856
        ANGLE_CAPTURE(ImportSemaphoreFdEXT, isCallValid, context, semaphorePacked, handleTypePacked,
5857
                      fd);
5858
    }
5859
    else
5860
    {
5861
        GenerateContextLostErrorOnCurrentGlobalContext();
5862
    }
5863
}
5864

5865
// GL_EXT_separate_shader_objects
5866
void GL_APIENTRY GL_ActiveShaderProgramEXT(GLuint pipeline, GLuint program)
5867
{
5868
    Context *context = GetValidGlobalContext();
5869
    EVENT(context, GLActiveShaderProgramEXT, "context = %d, pipeline = %u, program = %u",
5870
          CID(context), pipeline, program);
5871

5872
    if (context)
5873
    {
5874
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
5875
        ShaderProgramID programPacked    = PackParam<ShaderProgramID>(program);
5876
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5877
        bool isCallValid                                      = (context->skipValidation() ||
5878
                            ValidateActiveShaderProgramEXT(context, pipelinePacked, programPacked));
5879
        if (isCallValid)
5880
        {
5881
            context->activeShaderProgram(pipelinePacked, programPacked);
5882
        }
5883
        ANGLE_CAPTURE(ActiveShaderProgramEXT, isCallValid, context, pipelinePacked, programPacked);
5884
    }
5885
    else
5886
    {
5887
        GenerateContextLostErrorOnCurrentGlobalContext();
5888
    }
5889
}
5890

5891
void GL_APIENTRY GL_BindProgramPipelineEXT(GLuint pipeline)
5892
{
5893
    Context *context = GetValidGlobalContext();
5894
    EVENT(context, GLBindProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline);
5895

5896
    if (context)
5897
    {
5898
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
5899
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5900
        bool isCallValid =
5901
            (context->skipValidation() || ValidateBindProgramPipelineEXT(context, pipelinePacked));
5902
        if (isCallValid)
5903
        {
5904
            context->bindProgramPipeline(pipelinePacked);
5905
        }
5906
        ANGLE_CAPTURE(BindProgramPipelineEXT, isCallValid, context, pipelinePacked);
5907
    }
5908
    else
5909
    {
5910
        GenerateContextLostErrorOnCurrentGlobalContext();
5911
    }
5912
}
5913

5914
GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings)
5915
{
5916
    Context *context = GetValidGlobalContext();
5917
    EVENT(context, GLCreateShaderProgramvEXT,
5918
          "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context),
5919
          GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings);
5920

5921
    GLuint returnValue;
5922
    if (context)
5923
    {
5924
        ShaderType typePacked                                 = PackParam<ShaderType>(type);
5925
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5926
        bool isCallValid                                      = (context->skipValidation() ||
5927
                            ValidateCreateShaderProgramvEXT(context, typePacked, count, strings));
5928
        if (isCallValid)
5929
        {
5930
            returnValue = context->createShaderProgramv(typePacked, count, strings);
5931
        }
5932
        else
5933
        {
5934
            returnValue =
5935
                GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>();
5936
        }
5937
        ANGLE_CAPTURE(CreateShaderProgramvEXT, isCallValid, context, typePacked, count, strings,
5938
                      returnValue);
5939
    }
5940
    else
5941
    {
5942
        GenerateContextLostErrorOnCurrentGlobalContext();
5943
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>();
5944
    }
5945
    return returnValue;
5946
}
5947

5948
void GL_APIENTRY GL_DeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
5949
{
5950
    Context *context = GetValidGlobalContext();
5951
    EVENT(context, GLDeleteProgramPipelinesEXT,
5952
          "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", CID(context), n,
5953
          (uintptr_t)pipelines);
5954

5955
    if (context)
5956
    {
5957
        const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines);
5958
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5959
        bool isCallValid                                      = (context->skipValidation() ||
5960
                            ValidateDeleteProgramPipelinesEXT(context, n, pipelinesPacked));
5961
        if (isCallValid)
5962
        {
5963
            context->deleteProgramPipelines(n, pipelinesPacked);
5964
        }
5965
        ANGLE_CAPTURE(DeleteProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked);
5966
    }
5967
    else
5968
    {
5969
        GenerateContextLostErrorOnCurrentGlobalContext();
5970
    }
5971
}
5972

5973
void GL_APIENTRY GL_GenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
5974
{
5975
    Context *context = GetValidGlobalContext();
5976
    EVENT(context, GLGenProgramPipelinesEXT, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "",
5977
          CID(context), n, (uintptr_t)pipelines);
5978

5979
    if (context)
5980
    {
5981
        ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines);
5982
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5983
        bool isCallValid                                      = (context->skipValidation() ||
5984
                            ValidateGenProgramPipelinesEXT(context, n, pipelinesPacked));
5985
        if (isCallValid)
5986
        {
5987
            context->genProgramPipelines(n, pipelinesPacked);
5988
        }
5989
        ANGLE_CAPTURE(GenProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked);
5990
    }
5991
    else
5992
    {
5993
        GenerateContextLostErrorOnCurrentGlobalContext();
5994
    }
5995
}
5996

5997
void GL_APIENTRY GL_GetProgramPipelineInfoLogEXT(GLuint pipeline,
5998
                                                 GLsizei bufSize,
5999
                                                 GLsizei *length,
6000
                                                 GLchar *infoLog)
6001
{
6002
    Context *context = GetValidGlobalContext();
6003
    EVENT(context, GLGetProgramPipelineInfoLogEXT,
6004
          "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR
6005
          ", infoLog = 0x%016" PRIxPTR "",
6006
          CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
6007

6008
    if (context)
6009
    {
6010
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6011
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6012
        bool isCallValid =
6013
            (context->skipValidation() || ValidateGetProgramPipelineInfoLogEXT(
6014
                                              context, pipelinePacked, bufSize, length, infoLog));
6015
        if (isCallValid)
6016
        {
6017
            context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog);
6018
        }
6019
        ANGLE_CAPTURE(GetProgramPipelineInfoLogEXT, isCallValid, context, pipelinePacked, bufSize,
6020
                      length, infoLog);
6021
    }
6022
    else
6023
    {
6024
        GenerateContextLostErrorOnCurrentGlobalContext();
6025
    }
6026
}
6027

6028
void GL_APIENTRY GL_GetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params)
6029
{
6030
    Context *context = GetValidGlobalContext();
6031
    EVENT(context, GLGetProgramPipelineivEXT,
6032
          "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
6033
          pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname), (uintptr_t)params);
6034

6035
    if (context)
6036
    {
6037
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6038
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6039
        bool isCallValid =
6040
            (context->skipValidation() ||
6041
             ValidateGetProgramPipelineivEXT(context, pipelinePacked, pname, params));
6042
        if (isCallValid)
6043
        {
6044
            context->getProgramPipelineiv(pipelinePacked, pname, params);
6045
        }
6046
        ANGLE_CAPTURE(GetProgramPipelineivEXT, isCallValid, context, pipelinePacked, pname, params);
6047
    }
6048
    else
6049
    {
6050
        GenerateContextLostErrorOnCurrentGlobalContext();
6051
    }
6052
}
6053

6054
GLboolean GL_APIENTRY GL_IsProgramPipelineEXT(GLuint pipeline)
6055
{
6056
    Context *context = GetValidGlobalContext();
6057
    EVENT(context, GLIsProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline);
6058

6059
    GLboolean returnValue;
6060
    if (context)
6061
    {
6062
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6063
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6064
        bool isCallValid =
6065
            (context->skipValidation() || ValidateIsProgramPipelineEXT(context, pipelinePacked));
6066
        if (isCallValid)
6067
        {
6068
            returnValue = context->isProgramPipeline(pipelinePacked);
6069
        }
6070
        else
6071
        {
6072
            returnValue =
6073
                GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>();
6074
        }
6075
        ANGLE_CAPTURE(IsProgramPipelineEXT, isCallValid, context, pipelinePacked, returnValue);
6076
    }
6077
    else
6078
    {
6079
        GenerateContextLostErrorOnCurrentGlobalContext();
6080
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>();
6081
    }
6082
    return returnValue;
6083
}
6084

6085
void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
6086
{
6087
    Context *context = GetValidGlobalContext();
6088
    EVENT(context, GLProgramParameteriEXT, "context = %d, program = %u, pname = %s, value = %d",
6089
          CID(context), program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value);
6090

6091
    if (context)
6092
    {
6093
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
6094
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6095
        bool isCallValid                                      = (context->skipValidation() ||
6096
                            ValidateProgramParameteriEXT(context, programPacked, pname, value));
6097
        if (isCallValid)
6098
        {
6099
            context->programParameteri(programPacked, pname, value);
6100
        }
6101
        ANGLE_CAPTURE(ProgramParameteriEXT, isCallValid, context, programPacked, pname, value);
6102
    }
6103
    else
6104
    {
6105
        GenerateContextLostErrorOnCurrentGlobalContext();
6106
    }
6107
}
6108

6109
void GL_APIENTRY GL_ProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)
6110
{
6111
    Context *context = GetValidGlobalContext();
6112
    EVENT(context, GLProgramUniform1fEXT, "context = %d, program = %u, location = %d, v0 = %f",
6113
          CID(context), program, location, v0);
6114

6115
    if (context)
6116
    {
6117
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6118
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6119
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6120
        bool isCallValid =
6121
            (context->skipValidation() ||
6122
             ValidateProgramUniform1fEXT(context, programPacked, locationPacked, v0));
6123
        if (isCallValid)
6124
        {
6125
            context->programUniform1f(programPacked, locationPacked, v0);
6126
        }
6127
        ANGLE_CAPTURE(ProgramUniform1fEXT, isCallValid, context, programPacked, locationPacked, v0);
6128
    }
6129
    else
6130
    {
6131
        GenerateContextLostErrorOnCurrentGlobalContext();
6132
    }
6133
}
6134

6135
void GL_APIENTRY GL_ProgramUniform1fvEXT(GLuint program,
6136
                                         GLint location,
6137
                                         GLsizei count,
6138
                                         const GLfloat *value)
6139
{
6140
    Context *context = GetValidGlobalContext();
6141
    EVENT(context, GLProgramUniform1fvEXT,
6142
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6143
          CID(context), program, location, count, (uintptr_t)value);
6144

6145
    if (context)
6146
    {
6147
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6148
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6149
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6150
        bool isCallValid =
6151
            (context->skipValidation() ||
6152
             ValidateProgramUniform1fvEXT(context, programPacked, locationPacked, count, value));
6153
        if (isCallValid)
6154
        {
6155
            context->programUniform1fv(programPacked, locationPacked, count, value);
6156
        }
6157
        ANGLE_CAPTURE(ProgramUniform1fvEXT, isCallValid, context, programPacked, locationPacked,
6158
                      count, value);
6159
    }
6160
    else
6161
    {
6162
        GenerateContextLostErrorOnCurrentGlobalContext();
6163
    }
6164
}
6165

6166
void GL_APIENTRY GL_ProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
6167
{
6168
    Context *context = GetValidGlobalContext();
6169
    EVENT(context, GLProgramUniform1iEXT, "context = %d, program = %u, location = %d, v0 = %d",
6170
          CID(context), program, location, v0);
6171

6172
    if (context)
6173
    {
6174
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6175
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6176
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6177
        bool isCallValid =
6178
            (context->skipValidation() ||
6179
             ValidateProgramUniform1iEXT(context, programPacked, locationPacked, v0));
6180
        if (isCallValid)
6181
        {
6182
            context->programUniform1i(programPacked, locationPacked, v0);
6183
        }
6184
        ANGLE_CAPTURE(ProgramUniform1iEXT, isCallValid, context, programPacked, locationPacked, v0);
6185
    }
6186
    else
6187
    {
6188
        GenerateContextLostErrorOnCurrentGlobalContext();
6189
    }
6190
}
6191

6192
void GL_APIENTRY GL_ProgramUniform1ivEXT(GLuint program,
6193
                                         GLint location,
6194
                                         GLsizei count,
6195
                                         const GLint *value)
6196
{
6197
    Context *context = GetValidGlobalContext();
6198
    EVENT(context, GLProgramUniform1ivEXT,
6199
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6200
          CID(context), program, location, count, (uintptr_t)value);
6201

6202
    if (context)
6203
    {
6204
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6205
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6206
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6207
        bool isCallValid =
6208
            (context->skipValidation() ||
6209
             ValidateProgramUniform1ivEXT(context, programPacked, locationPacked, count, value));
6210
        if (isCallValid)
6211
        {
6212
            context->programUniform1iv(programPacked, locationPacked, count, value);
6213
        }
6214
        ANGLE_CAPTURE(ProgramUniform1ivEXT, isCallValid, context, programPacked, locationPacked,
6215
                      count, value);
6216
    }
6217
    else
6218
    {
6219
        GenerateContextLostErrorOnCurrentGlobalContext();
6220
    }
6221
}
6222

6223
void GL_APIENTRY GL_ProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
6224
{
6225
    Context *context = GetValidGlobalContext();
6226
    EVENT(context, GLProgramUniform1uiEXT, "context = %d, program = %u, location = %d, v0 = %u",
6227
          CID(context), program, location, v0);
6228

6229
    if (context)
6230
    {
6231
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6232
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6233
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6234
        bool isCallValid =
6235
            (context->skipValidation() ||
6236
             ValidateProgramUniform1uiEXT(context, programPacked, locationPacked, v0));
6237
        if (isCallValid)
6238
        {
6239
            context->programUniform1ui(programPacked, locationPacked, v0);
6240
        }
6241
        ANGLE_CAPTURE(ProgramUniform1uiEXT, isCallValid, context, programPacked, locationPacked,
6242
                      v0);
6243
    }
6244
    else
6245
    {
6246
        GenerateContextLostErrorOnCurrentGlobalContext();
6247
    }
6248
}
6249

6250
void GL_APIENTRY GL_ProgramUniform1uivEXT(GLuint program,
6251
                                          GLint location,
6252
                                          GLsizei count,
6253
                                          const GLuint *value)
6254
{
6255
    Context *context = GetValidGlobalContext();
6256
    EVENT(context, GLProgramUniform1uivEXT,
6257
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6258
          CID(context), program, location, count, (uintptr_t)value);
6259

6260
    if (context)
6261
    {
6262
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6263
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6264
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6265
        bool isCallValid =
6266
            (context->skipValidation() ||
6267
             ValidateProgramUniform1uivEXT(context, programPacked, locationPacked, count, value));
6268
        if (isCallValid)
6269
        {
6270
            context->programUniform1uiv(programPacked, locationPacked, count, value);
6271
        }
6272
        ANGLE_CAPTURE(ProgramUniform1uivEXT, isCallValid, context, programPacked, locationPacked,
6273
                      count, value);
6274
    }
6275
    else
6276
    {
6277
        GenerateContextLostErrorOnCurrentGlobalContext();
6278
    }
6279
}
6280

6281
void GL_APIENTRY GL_ProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)
6282
{
6283
    Context *context = GetValidGlobalContext();
6284
    EVENT(context, GLProgramUniform2fEXT,
6285
          "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program,
6286
          location, v0, v1);
6287

6288
    if (context)
6289
    {
6290
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6291
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6292
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6293
        bool isCallValid =
6294
            (context->skipValidation() ||
6295
             ValidateProgramUniform2fEXT(context, programPacked, locationPacked, v0, v1));
6296
        if (isCallValid)
6297
        {
6298
            context->programUniform2f(programPacked, locationPacked, v0, v1);
6299
        }
6300
        ANGLE_CAPTURE(ProgramUniform2fEXT, isCallValid, context, programPacked, locationPacked, v0,
6301
                      v1);
6302
    }
6303
    else
6304
    {
6305
        GenerateContextLostErrorOnCurrentGlobalContext();
6306
    }
6307
}
6308

6309
void GL_APIENTRY GL_ProgramUniform2fvEXT(GLuint program,
6310
                                         GLint location,
6311
                                         GLsizei count,
6312
                                         const GLfloat *value)
6313
{
6314
    Context *context = GetValidGlobalContext();
6315
    EVENT(context, GLProgramUniform2fvEXT,
6316
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6317
          CID(context), program, location, count, (uintptr_t)value);
6318

6319
    if (context)
6320
    {
6321
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6322
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6323
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6324
        bool isCallValid =
6325
            (context->skipValidation() ||
6326
             ValidateProgramUniform2fvEXT(context, programPacked, locationPacked, count, value));
6327
        if (isCallValid)
6328
        {
6329
            context->programUniform2fv(programPacked, locationPacked, count, value);
6330
        }
6331
        ANGLE_CAPTURE(ProgramUniform2fvEXT, isCallValid, context, programPacked, locationPacked,
6332
                      count, value);
6333
    }
6334
    else
6335
    {
6336
        GenerateContextLostErrorOnCurrentGlobalContext();
6337
    }
6338
}
6339

6340
void GL_APIENTRY GL_ProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)
6341
{
6342
    Context *context = GetValidGlobalContext();
6343
    EVENT(context, GLProgramUniform2iEXT,
6344
          "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program,
6345
          location, v0, v1);
6346

6347
    if (context)
6348
    {
6349
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6350
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6351
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6352
        bool isCallValid =
6353
            (context->skipValidation() ||
6354
             ValidateProgramUniform2iEXT(context, programPacked, locationPacked, v0, v1));
6355
        if (isCallValid)
6356
        {
6357
            context->programUniform2i(programPacked, locationPacked, v0, v1);
6358
        }
6359
        ANGLE_CAPTURE(ProgramUniform2iEXT, isCallValid, context, programPacked, locationPacked, v0,
6360
                      v1);
6361
    }
6362
    else
6363
    {
6364
        GenerateContextLostErrorOnCurrentGlobalContext();
6365
    }
6366
}
6367

6368
void GL_APIENTRY GL_ProgramUniform2ivEXT(GLuint program,
6369
                                         GLint location,
6370
                                         GLsizei count,
6371
                                         const GLint *value)
6372
{
6373
    Context *context = GetValidGlobalContext();
6374
    EVENT(context, GLProgramUniform2ivEXT,
6375
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6376
          CID(context), program, location, count, (uintptr_t)value);
6377

6378
    if (context)
6379
    {
6380
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6381
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6382
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6383
        bool isCallValid =
6384
            (context->skipValidation() ||
6385
             ValidateProgramUniform2ivEXT(context, programPacked, locationPacked, count, value));
6386
        if (isCallValid)
6387
        {
6388
            context->programUniform2iv(programPacked, locationPacked, count, value);
6389
        }
6390
        ANGLE_CAPTURE(ProgramUniform2ivEXT, isCallValid, context, programPacked, locationPacked,
6391
                      count, value);
6392
    }
6393
    else
6394
    {
6395
        GenerateContextLostErrorOnCurrentGlobalContext();
6396
    }
6397
}
6398

6399
void GL_APIENTRY GL_ProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1)
6400
{
6401
    Context *context = GetValidGlobalContext();
6402
    EVENT(context, GLProgramUniform2uiEXT,
6403
          "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program,
6404
          location, v0, v1);
6405

6406
    if (context)
6407
    {
6408
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6409
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6410
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6411
        bool isCallValid =
6412
            (context->skipValidation() ||
6413
             ValidateProgramUniform2uiEXT(context, programPacked, locationPacked, v0, v1));
6414
        if (isCallValid)
6415
        {
6416
            context->programUniform2ui(programPacked, locationPacked, v0, v1);
6417
        }
6418
        ANGLE_CAPTURE(ProgramUniform2uiEXT, isCallValid, context, programPacked, locationPacked, v0,
6419
                      v1);
6420
    }
6421
    else
6422
    {
6423
        GenerateContextLostErrorOnCurrentGlobalContext();
6424
    }
6425
}
6426

6427
void GL_APIENTRY GL_ProgramUniform2uivEXT(GLuint program,
6428
                                          GLint location,
6429
                                          GLsizei count,
6430
                                          const GLuint *value)
6431
{
6432
    Context *context = GetValidGlobalContext();
6433
    EVENT(context, GLProgramUniform2uivEXT,
6434
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6435
          CID(context), program, location, count, (uintptr_t)value);
6436

6437
    if (context)
6438
    {
6439
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6440
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6441
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6442
        bool isCallValid =
6443
            (context->skipValidation() ||
6444
             ValidateProgramUniform2uivEXT(context, programPacked, locationPacked, count, value));
6445
        if (isCallValid)
6446
        {
6447
            context->programUniform2uiv(programPacked, locationPacked, count, value);
6448
        }
6449
        ANGLE_CAPTURE(ProgramUniform2uivEXT, isCallValid, context, programPacked, locationPacked,
6450
                      count, value);
6451
    }
6452
    else
6453
    {
6454
        GenerateContextLostErrorOnCurrentGlobalContext();
6455
    }
6456
}
6457

6458
void GL_APIENTRY
6459
GL_ProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
6460
{
6461
    Context *context = GetValidGlobalContext();
6462
    EVENT(context, GLProgramUniform3fEXT,
6463
          "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context),
6464
          program, location, v0, v1, v2);
6465

6466
    if (context)
6467
    {
6468
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6469
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6470
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6471
        bool isCallValid =
6472
            (context->skipValidation() ||
6473
             ValidateProgramUniform3fEXT(context, programPacked, locationPacked, v0, v1, v2));
6474
        if (isCallValid)
6475
        {
6476
            context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
6477
        }
6478
        ANGLE_CAPTURE(ProgramUniform3fEXT, isCallValid, context, programPacked, locationPacked, v0,
6479
                      v1, v2);
6480
    }
6481
    else
6482
    {
6483
        GenerateContextLostErrorOnCurrentGlobalContext();
6484
    }
6485
}
6486

6487
void GL_APIENTRY GL_ProgramUniform3fvEXT(GLuint program,
6488
                                         GLint location,
6489
                                         GLsizei count,
6490
                                         const GLfloat *value)
6491
{
6492
    Context *context = GetValidGlobalContext();
6493
    EVENT(context, GLProgramUniform3fvEXT,
6494
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6495
          CID(context), program, location, count, (uintptr_t)value);
6496

6497
    if (context)
6498
    {
6499
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6500
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6501
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6502
        bool isCallValid =
6503
            (context->skipValidation() ||
6504
             ValidateProgramUniform3fvEXT(context, programPacked, locationPacked, count, value));
6505
        if (isCallValid)
6506
        {
6507
            context->programUniform3fv(programPacked, locationPacked, count, value);
6508
        }
6509
        ANGLE_CAPTURE(ProgramUniform3fvEXT, isCallValid, context, programPacked, locationPacked,
6510
                      count, value);
6511
    }
6512
    else
6513
    {
6514
        GenerateContextLostErrorOnCurrentGlobalContext();
6515
    }
6516
}
6517

6518
void GL_APIENTRY
6519
GL_ProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
6520
{
6521
    Context *context = GetValidGlobalContext();
6522
    EVENT(context, GLProgramUniform3iEXT,
6523
          "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context),
6524
          program, location, v0, v1, v2);
6525

6526
    if (context)
6527
    {
6528
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6529
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6530
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6531
        bool isCallValid =
6532
            (context->skipValidation() ||
6533
             ValidateProgramUniform3iEXT(context, programPacked, locationPacked, v0, v1, v2));
6534
        if (isCallValid)
6535
        {
6536
            context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
6537
        }
6538
        ANGLE_CAPTURE(ProgramUniform3iEXT, isCallValid, context, programPacked, locationPacked, v0,
6539
                      v1, v2);
6540
    }
6541
    else
6542
    {
6543
        GenerateContextLostErrorOnCurrentGlobalContext();
6544
    }
6545
}
6546

6547
void GL_APIENTRY GL_ProgramUniform3ivEXT(GLuint program,
6548
                                         GLint location,
6549
                                         GLsizei count,
6550
                                         const GLint *value)
6551
{
6552
    Context *context = GetValidGlobalContext();
6553
    EVENT(context, GLProgramUniform3ivEXT,
6554
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6555
          CID(context), program, location, count, (uintptr_t)value);
6556

6557
    if (context)
6558
    {
6559
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6560
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6561
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6562
        bool isCallValid =
6563
            (context->skipValidation() ||
6564
             ValidateProgramUniform3ivEXT(context, programPacked, locationPacked, count, value));
6565
        if (isCallValid)
6566
        {
6567
            context->programUniform3iv(programPacked, locationPacked, count, value);
6568
        }
6569
        ANGLE_CAPTURE(ProgramUniform3ivEXT, isCallValid, context, programPacked, locationPacked,
6570
                      count, value);
6571
    }
6572
    else
6573
    {
6574
        GenerateContextLostErrorOnCurrentGlobalContext();
6575
    }
6576
}
6577

6578
void GL_APIENTRY
6579
GL_ProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
6580
{
6581
    Context *context = GetValidGlobalContext();
6582
    EVENT(context, GLProgramUniform3uiEXT,
6583
          "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context),
6584
          program, location, v0, v1, v2);
6585

6586
    if (context)
6587
    {
6588
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6589
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6590
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6591
        bool isCallValid =
6592
            (context->skipValidation() ||
6593
             ValidateProgramUniform3uiEXT(context, programPacked, locationPacked, v0, v1, v2));
6594
        if (isCallValid)
6595
        {
6596
            context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
6597
        }
6598
        ANGLE_CAPTURE(ProgramUniform3uiEXT, isCallValid, context, programPacked, locationPacked, v0,
6599
                      v1, v2);
6600
    }
6601
    else
6602
    {
6603
        GenerateContextLostErrorOnCurrentGlobalContext();
6604
    }
6605
}
6606

6607
void GL_APIENTRY GL_ProgramUniform3uivEXT(GLuint program,
6608
                                          GLint location,
6609
                                          GLsizei count,
6610
                                          const GLuint *value)
6611
{
6612
    Context *context = GetValidGlobalContext();
6613
    EVENT(context, GLProgramUniform3uivEXT,
6614
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6615
          CID(context), program, location, count, (uintptr_t)value);
6616

6617
    if (context)
6618
    {
6619
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6620
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6621
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6622
        bool isCallValid =
6623
            (context->skipValidation() ||
6624
             ValidateProgramUniform3uivEXT(context, programPacked, locationPacked, count, value));
6625
        if (isCallValid)
6626
        {
6627
            context->programUniform3uiv(programPacked, locationPacked, count, value);
6628
        }
6629
        ANGLE_CAPTURE(ProgramUniform3uivEXT, isCallValid, context, programPacked, locationPacked,
6630
                      count, value);
6631
    }
6632
    else
6633
    {
6634
        GenerateContextLostErrorOnCurrentGlobalContext();
6635
    }
6636
}
6637

6638
void GL_APIENTRY GL_ProgramUniform4fEXT(GLuint program,
6639
                                        GLint location,
6640
                                        GLfloat v0,
6641
                                        GLfloat v1,
6642
                                        GLfloat v2,
6643
                                        GLfloat v3)
6644
{
6645
    Context *context = GetValidGlobalContext();
6646
    EVENT(context, GLProgramUniform4fEXT,
6647
          "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
6648
          CID(context), program, location, v0, v1, v2, v3);
6649

6650
    if (context)
6651
    {
6652
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6653
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6654
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6655
        bool isCallValid =
6656
            (context->skipValidation() ||
6657
             ValidateProgramUniform4fEXT(context, programPacked, locationPacked, v0, v1, v2, v3));
6658
        if (isCallValid)
6659
        {
6660
            context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
6661
        }
6662
        ANGLE_CAPTURE(ProgramUniform4fEXT, isCallValid, context, programPacked, locationPacked, v0,
6663
                      v1, v2, v3);
6664
    }
6665
    else
6666
    {
6667
        GenerateContextLostErrorOnCurrentGlobalContext();
6668
    }
6669
}
6670

6671
void GL_APIENTRY GL_ProgramUniform4fvEXT(GLuint program,
6672
                                         GLint location,
6673
                                         GLsizei count,
6674
                                         const GLfloat *value)
6675
{
6676
    Context *context = GetValidGlobalContext();
6677
    EVENT(context, GLProgramUniform4fvEXT,
6678
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6679
          CID(context), program, location, count, (uintptr_t)value);
6680

6681
    if (context)
6682
    {
6683
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6684
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6685
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6686
        bool isCallValid =
6687
            (context->skipValidation() ||
6688
             ValidateProgramUniform4fvEXT(context, programPacked, locationPacked, count, value));
6689
        if (isCallValid)
6690
        {
6691
            context->programUniform4fv(programPacked, locationPacked, count, value);
6692
        }
6693
        ANGLE_CAPTURE(ProgramUniform4fvEXT, isCallValid, context, programPacked, locationPacked,
6694
                      count, value);
6695
    }
6696
    else
6697
    {
6698
        GenerateContextLostErrorOnCurrentGlobalContext();
6699
    }
6700
}
6701

6702
void GL_APIENTRY
6703
GL_ProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
6704
{
6705
    Context *context = GetValidGlobalContext();
6706
    EVENT(context, GLProgramUniform4iEXT,
6707
          "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
6708
          CID(context), program, location, v0, v1, v2, v3);
6709

6710
    if (context)
6711
    {
6712
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6713
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6714
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6715
        bool isCallValid =
6716
            (context->skipValidation() ||
6717
             ValidateProgramUniform4iEXT(context, programPacked, locationPacked, v0, v1, v2, v3));
6718
        if (isCallValid)
6719
        {
6720
            context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
6721
        }
6722
        ANGLE_CAPTURE(ProgramUniform4iEXT, isCallValid, context, programPacked, locationPacked, v0,
6723
                      v1, v2, v3);
6724
    }
6725
    else
6726
    {
6727
        GenerateContextLostErrorOnCurrentGlobalContext();
6728
    }
6729
}
6730

6731
void GL_APIENTRY GL_ProgramUniform4ivEXT(GLuint program,
6732
                                         GLint location,
6733
                                         GLsizei count,
6734
                                         const GLint *value)
6735
{
6736
    Context *context = GetValidGlobalContext();
6737
    EVENT(context, GLProgramUniform4ivEXT,
6738
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6739
          CID(context), program, location, count, (uintptr_t)value);
6740

6741
    if (context)
6742
    {
6743
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6744
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6745
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6746
        bool isCallValid =
6747
            (context->skipValidation() ||
6748
             ValidateProgramUniform4ivEXT(context, programPacked, locationPacked, count, value));
6749
        if (isCallValid)
6750
        {
6751
            context->programUniform4iv(programPacked, locationPacked, count, value);
6752
        }
6753
        ANGLE_CAPTURE(ProgramUniform4ivEXT, isCallValid, context, programPacked, locationPacked,
6754
                      count, value);
6755
    }
6756
    else
6757
    {
6758
        GenerateContextLostErrorOnCurrentGlobalContext();
6759
    }
6760
}
6761

6762
void GL_APIENTRY
6763
GL_ProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
6764
{
6765
    Context *context = GetValidGlobalContext();
6766
    EVENT(context, GLProgramUniform4uiEXT,
6767
          "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u",
6768
          CID(context), program, location, v0, v1, v2, v3);
6769

6770
    if (context)
6771
    {
6772
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6773
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6774
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6775
        bool isCallValid =
6776
            (context->skipValidation() ||
6777
             ValidateProgramUniform4uiEXT(context, programPacked, locationPacked, v0, v1, v2, v3));
6778
        if (isCallValid)
6779
        {
6780
            context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
6781
        }
6782
        ANGLE_CAPTURE(ProgramUniform4uiEXT, isCallValid, context, programPacked, locationPacked, v0,
6783
                      v1, v2, v3);
6784
    }
6785
    else
6786
    {
6787
        GenerateContextLostErrorOnCurrentGlobalContext();
6788
    }
6789
}
6790

6791
void GL_APIENTRY GL_ProgramUniform4uivEXT(GLuint program,
6792
                                          GLint location,
6793
                                          GLsizei count,
6794
                                          const GLuint *value)
6795
{
6796
    Context *context = GetValidGlobalContext();
6797
    EVENT(context, GLProgramUniform4uivEXT,
6798
          "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6799
          CID(context), program, location, count, (uintptr_t)value);
6800

6801
    if (context)
6802
    {
6803
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6804
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6805
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6806
        bool isCallValid =
6807
            (context->skipValidation() ||
6808
             ValidateProgramUniform4uivEXT(context, programPacked, locationPacked, count, value));
6809
        if (isCallValid)
6810
        {
6811
            context->programUniform4uiv(programPacked, locationPacked, count, value);
6812
        }
6813
        ANGLE_CAPTURE(ProgramUniform4uivEXT, isCallValid, context, programPacked, locationPacked,
6814
                      count, value);
6815
    }
6816
    else
6817
    {
6818
        GenerateContextLostErrorOnCurrentGlobalContext();
6819
    }
6820
}
6821

6822
void GL_APIENTRY GL_ProgramUniformMatrix2fvEXT(GLuint program,
6823
                                               GLint location,
6824
                                               GLsizei count,
6825
                                               GLboolean transpose,
6826
                                               const GLfloat *value)
6827
{
6828
    Context *context = GetValidGlobalContext();
6829
    EVENT(context, GLProgramUniformMatrix2fvEXT,
6830
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
6831
          "0x%016" PRIxPTR "",
6832
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
6833

6834
    if (context)
6835
    {
6836
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6837
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6838
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6839
        bool isCallValid                                      = (context->skipValidation() ||
6840
                            ValidateProgramUniformMatrix2fvEXT(
6841
                                context, programPacked, locationPacked, count, transpose, value));
6842
        if (isCallValid)
6843
        {
6844
            context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
6845
                                             value);
6846
        }
6847
        ANGLE_CAPTURE(ProgramUniformMatrix2fvEXT, isCallValid, context, programPacked,
6848
                      locationPacked, count, transpose, value);
6849
    }
6850
    else
6851
    {
6852
        GenerateContextLostErrorOnCurrentGlobalContext();
6853
    }
6854
}
6855

6856
void GL_APIENTRY GL_ProgramUniformMatrix2x3fvEXT(GLuint program,
6857
                                                 GLint location,
6858
                                                 GLsizei count,
6859
                                                 GLboolean transpose,
6860
                                                 const GLfloat *value)
6861
{
6862
    Context *context = GetValidGlobalContext();
6863
    EVENT(context, GLProgramUniformMatrix2x3fvEXT,
6864
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
6865
          "0x%016" PRIxPTR "",
6866
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
6867

6868
    if (context)
6869
    {
6870
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6871
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6872
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6873
        bool isCallValid                                      = (context->skipValidation() ||
6874
                            ValidateProgramUniformMatrix2x3fvEXT(
6875
                                context, programPacked, locationPacked, count, transpose, value));
6876
        if (isCallValid)
6877
        {
6878
            context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
6879
                                               value);
6880
        }
6881
        ANGLE_CAPTURE(ProgramUniformMatrix2x3fvEXT, isCallValid, context, programPacked,
6882
                      locationPacked, count, transpose, value);
6883
    }
6884
    else
6885
    {
6886
        GenerateContextLostErrorOnCurrentGlobalContext();
6887
    }
6888
}
6889

6890
void GL_APIENTRY GL_ProgramUniformMatrix2x4fvEXT(GLuint program,
6891
                                                 GLint location,
6892
                                                 GLsizei count,
6893
                                                 GLboolean transpose,
6894
                                                 const GLfloat *value)
6895
{
6896
    Context *context = GetValidGlobalContext();
6897
    EVENT(context, GLProgramUniformMatrix2x4fvEXT,
6898
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
6899
          "0x%016" PRIxPTR "",
6900
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
6901

6902
    if (context)
6903
    {
6904
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6905
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6906
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6907
        bool isCallValid                                      = (context->skipValidation() ||
6908
                            ValidateProgramUniformMatrix2x4fvEXT(
6909
                                context, programPacked, locationPacked, count, transpose, value));
6910
        if (isCallValid)
6911
        {
6912
            context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
6913
                                               value);
6914
        }
6915
        ANGLE_CAPTURE(ProgramUniformMatrix2x4fvEXT, isCallValid, context, programPacked,
6916
                      locationPacked, count, transpose, value);
6917
    }
6918
    else
6919
    {
6920
        GenerateContextLostErrorOnCurrentGlobalContext();
6921
    }
6922
}
6923

6924
void GL_APIENTRY GL_ProgramUniformMatrix3fvEXT(GLuint program,
6925
                                               GLint location,
6926
                                               GLsizei count,
6927
                                               GLboolean transpose,
6928
                                               const GLfloat *value)
6929
{
6930
    Context *context = GetValidGlobalContext();
6931
    EVENT(context, GLProgramUniformMatrix3fvEXT,
6932
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
6933
          "0x%016" PRIxPTR "",
6934
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
6935

6936
    if (context)
6937
    {
6938
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6939
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6940
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6941
        bool isCallValid                                      = (context->skipValidation() ||
6942
                            ValidateProgramUniformMatrix3fvEXT(
6943
                                context, programPacked, locationPacked, count, transpose, value));
6944
        if (isCallValid)
6945
        {
6946
            context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
6947
                                             value);
6948
        }
6949
        ANGLE_CAPTURE(ProgramUniformMatrix3fvEXT, isCallValid, context, programPacked,
6950
                      locationPacked, count, transpose, value);
6951
    }
6952
    else
6953
    {
6954
        GenerateContextLostErrorOnCurrentGlobalContext();
6955
    }
6956
}
6957

6958
void GL_APIENTRY GL_ProgramUniformMatrix3x2fvEXT(GLuint program,
6959
                                                 GLint location,
6960
                                                 GLsizei count,
6961
                                                 GLboolean transpose,
6962
                                                 const GLfloat *value)
6963
{
6964
    Context *context = GetValidGlobalContext();
6965
    EVENT(context, GLProgramUniformMatrix3x2fvEXT,
6966
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
6967
          "0x%016" PRIxPTR "",
6968
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
6969

6970
    if (context)
6971
    {
6972
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
6973
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
6974
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6975
        bool isCallValid                                      = (context->skipValidation() ||
6976
                            ValidateProgramUniformMatrix3x2fvEXT(
6977
                                context, programPacked, locationPacked, count, transpose, value));
6978
        if (isCallValid)
6979
        {
6980
            context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
6981
                                               value);
6982
        }
6983
        ANGLE_CAPTURE(ProgramUniformMatrix3x2fvEXT, isCallValid, context, programPacked,
6984
                      locationPacked, count, transpose, value);
6985
    }
6986
    else
6987
    {
6988
        GenerateContextLostErrorOnCurrentGlobalContext();
6989
    }
6990
}
6991

6992
void GL_APIENTRY GL_ProgramUniformMatrix3x4fvEXT(GLuint program,
6993
                                                 GLint location,
6994
                                                 GLsizei count,
6995
                                                 GLboolean transpose,
6996
                                                 const GLfloat *value)
6997
{
6998
    Context *context = GetValidGlobalContext();
6999
    EVENT(context, GLProgramUniformMatrix3x4fvEXT,
7000
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7001
          "0x%016" PRIxPTR "",
7002
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7003

7004
    if (context)
7005
    {
7006
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
7007
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
7008
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7009
        bool isCallValid                                      = (context->skipValidation() ||
7010
                            ValidateProgramUniformMatrix3x4fvEXT(
7011
                                context, programPacked, locationPacked, count, transpose, value));
7012
        if (isCallValid)
7013
        {
7014
            context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
7015
                                               value);
7016
        }
7017
        ANGLE_CAPTURE(ProgramUniformMatrix3x4fvEXT, isCallValid, context, programPacked,
7018
                      locationPacked, count, transpose, value);
7019
    }
7020
    else
7021
    {
7022
        GenerateContextLostErrorOnCurrentGlobalContext();
7023
    }
7024
}
7025

7026
void GL_APIENTRY GL_ProgramUniformMatrix4fvEXT(GLuint program,
7027
                                               GLint location,
7028
                                               GLsizei count,
7029
                                               GLboolean transpose,
7030
                                               const GLfloat *value)
7031
{
7032
    Context *context = GetValidGlobalContext();
7033
    EVENT(context, GLProgramUniformMatrix4fvEXT,
7034
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7035
          "0x%016" PRIxPTR "",
7036
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7037

7038
    if (context)
7039
    {
7040
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
7041
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
7042
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7043
        bool isCallValid                                      = (context->skipValidation() ||
7044
                            ValidateProgramUniformMatrix4fvEXT(
7045
                                context, programPacked, locationPacked, count, transpose, value));
7046
        if (isCallValid)
7047
        {
7048
            context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
7049
                                             value);
7050
        }
7051
        ANGLE_CAPTURE(ProgramUniformMatrix4fvEXT, isCallValid, context, programPacked,
7052
                      locationPacked, count, transpose, value);
7053
    }
7054
    else
7055
    {
7056
        GenerateContextLostErrorOnCurrentGlobalContext();
7057
    }
7058
}
7059

7060
void GL_APIENTRY GL_ProgramUniformMatrix4x2fvEXT(GLuint program,
7061
                                                 GLint location,
7062
                                                 GLsizei count,
7063
                                                 GLboolean transpose,
7064
                                                 const GLfloat *value)
7065
{
7066
    Context *context = GetValidGlobalContext();
7067
    EVENT(context, GLProgramUniformMatrix4x2fvEXT,
7068
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7069
          "0x%016" PRIxPTR "",
7070
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7071

7072
    if (context)
7073
    {
7074
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
7075
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
7076
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7077
        bool isCallValid                                      = (context->skipValidation() ||
7078
                            ValidateProgramUniformMatrix4x2fvEXT(
7079
                                context, programPacked, locationPacked, count, transpose, value));
7080
        if (isCallValid)
7081
        {
7082
            context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
7083
                                               value);
7084
        }
7085
        ANGLE_CAPTURE(ProgramUniformMatrix4x2fvEXT, isCallValid, context, programPacked,
7086
                      locationPacked, count, transpose, value);
7087
    }
7088
    else
7089
    {
7090
        GenerateContextLostErrorOnCurrentGlobalContext();
7091
    }
7092
}
7093

7094
void GL_APIENTRY GL_ProgramUniformMatrix4x3fvEXT(GLuint program,
7095
                                                 GLint location,
7096
                                                 GLsizei count,
7097
                                                 GLboolean transpose,
7098
                                                 const GLfloat *value)
7099
{
7100
    Context *context = GetValidGlobalContext();
7101
    EVENT(context, GLProgramUniformMatrix4x3fvEXT,
7102
          "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7103
          "0x%016" PRIxPTR "",
7104
          CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7105

7106
    if (context)
7107
    {
7108
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
7109
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
7110
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7111
        bool isCallValid                                      = (context->skipValidation() ||
7112
                            ValidateProgramUniformMatrix4x3fvEXT(
7113
                                context, programPacked, locationPacked, count, transpose, value));
7114
        if (isCallValid)
7115
        {
7116
            context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
7117
                                               value);
7118
        }
7119
        ANGLE_CAPTURE(ProgramUniformMatrix4x3fvEXT, isCallValid, context, programPacked,
7120
                      locationPacked, count, transpose, value);
7121
    }
7122
    else
7123
    {
7124
        GenerateContextLostErrorOnCurrentGlobalContext();
7125
    }
7126
}
7127

7128
void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program)
7129
{
7130
    Context *context = GetValidGlobalContext();
7131
    EVENT(context, GLUseProgramStagesEXT, "context = %d, pipeline = %u, stages = %s, program = %u",
7132
          CID(context), pipeline,
7133
          GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program);
7134

7135
    if (context)
7136
    {
7137
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
7138
        ShaderProgramID programPacked    = PackParam<ShaderProgramID>(program);
7139
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7140
        bool isCallValid =
7141
            (context->skipValidation() ||
7142
             ValidateUseProgramStagesEXT(context, pipelinePacked, stages, programPacked));
7143
        if (isCallValid)
7144
        {
7145
            context->useProgramStages(pipelinePacked, stages, programPacked);
7146
        }
7147
        ANGLE_CAPTURE(UseProgramStagesEXT, isCallValid, context, pipelinePacked, stages,
7148
                      programPacked);
7149
    }
7150
    else
7151
    {
7152
        GenerateContextLostErrorOnCurrentGlobalContext();
7153
    }
7154
}
7155

7156
void GL_APIENTRY GL_ValidateProgramPipelineEXT(GLuint pipeline)
7157
{
7158
    Context *context = GetValidGlobalContext();
7159
    EVENT(context, GLValidateProgramPipelineEXT, "context = %d, pipeline = %u", CID(context),
7160
          pipeline);
7161

7162
    if (context)
7163
    {
7164
        ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
7165
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7166
        bool isCallValid                                      = (context->skipValidation() ||
7167
                            ValidateValidateProgramPipelineEXT(context, pipelinePacked));
7168
        if (isCallValid)
7169
        {
7170
            context->validateProgramPipeline(pipelinePacked);
7171
        }
7172
        ANGLE_CAPTURE(ValidateProgramPipelineEXT, isCallValid, context, pipelinePacked);
7173
    }
7174
    else
7175
    {
7176
        GenerateContextLostErrorOnCurrentGlobalContext();
7177
    }
7178
}
7179

7180
// GL_EXT_shader_framebuffer_fetch_non_coherent
7181
void GL_APIENTRY GL_FramebufferFetchBarrierEXT()
7182
{
7183
    Context *context = GetValidGlobalContext();
7184
    EVENT(context, GLFramebufferFetchBarrierEXT, "context = %d", CID(context));
7185

7186
    if (context)
7187
    {
7188
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7189
        bool isCallValid =
7190
            (context->skipValidation() || ValidateFramebufferFetchBarrierEXT(context));
7191
        if (isCallValid)
7192
        {
7193
            context->framebufferFetchBarrier();
7194
        }
7195
        ANGLE_CAPTURE(FramebufferFetchBarrierEXT, isCallValid, context);
7196
    }
7197
    else
7198
    {
7199
        GenerateContextLostErrorOnCurrentGlobalContext();
7200
    }
7201
}
7202

7203
// GL_EXT_shader_io_blocks
7204

7205
// GL_EXT_tessellation_shader
7206
void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value)
7207
{
7208
    Context *context = GetValidGlobalContext();
7209
    EVENT(context, GLPatchParameteriEXT, "context = %d, pname = %s, value = %d", CID(context),
7210
          GLenumToString(GLenumGroup::PatchParameterName, pname), value);
7211

7212
    if (context)
7213
    {
7214
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7215
        bool isCallValid =
7216
            (context->skipValidation() || ValidatePatchParameteriEXT(context, pname, value));
7217
        if (isCallValid)
7218
        {
7219
            context->patchParameteri(pname, value);
7220
        }
7221
        ANGLE_CAPTURE(PatchParameteriEXT, isCallValid, context, pname, value);
7222
    }
7223
    else
7224
    {
7225
        GenerateContextLostErrorOnCurrentGlobalContext();
7226
    }
7227
}
7228

7229
// GL_EXT_texture_border_clamp
7230
void GL_APIENTRY GL_GetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params)
7231
{
7232
    Context *context = GetValidGlobalContext();
7233
    EVENT(context, GLGetSamplerParameterIivEXT,
7234
          "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7235
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
7236

7237
    if (context)
7238
    {
7239
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
7240
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7241
        bool isCallValid =
7242
            (context->skipValidation() ||
7243
             ValidateGetSamplerParameterIivEXT(context, samplerPacked, pname, params));
7244
        if (isCallValid)
7245
        {
7246
            context->getSamplerParameterIiv(samplerPacked, pname, params);
7247
        }
7248
        ANGLE_CAPTURE(GetSamplerParameterIivEXT, isCallValid, context, samplerPacked, pname,
7249
                      params);
7250
    }
7251
    else
7252
    {
7253
        GenerateContextLostErrorOnCurrentGlobalContext();
7254
    }
7255
}
7256

7257
void GL_APIENTRY GL_GetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params)
7258
{
7259
    Context *context = GetValidGlobalContext();
7260
    EVENT(context, GLGetSamplerParameterIuivEXT,
7261
          "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7262
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
7263

7264
    if (context)
7265
    {
7266
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
7267
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7268
        bool isCallValid =
7269
            (context->skipValidation() ||
7270
             ValidateGetSamplerParameterIuivEXT(context, samplerPacked, pname, params));
7271
        if (isCallValid)
7272
        {
7273
            context->getSamplerParameterIuiv(samplerPacked, pname, params);
7274
        }
7275
        ANGLE_CAPTURE(GetSamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname,
7276
                      params);
7277
    }
7278
    else
7279
    {
7280
        GenerateContextLostErrorOnCurrentGlobalContext();
7281
    }
7282
}
7283

7284
void GL_APIENTRY GL_GetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
7285
{
7286
    Context *context = GetValidGlobalContext();
7287
    EVENT(context, GLGetTexParameterIivEXT,
7288
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7289
          GLenumToString(GLenumGroup::TextureTarget, target),
7290
          GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
7291

7292
    if (context)
7293
    {
7294
        TextureType targetPacked                              = PackParam<TextureType>(target);
7295
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7296
        bool isCallValid                                      = (context->skipValidation() ||
7297
                            ValidateGetTexParameterIivEXT(context, targetPacked, pname, params));
7298
        if (isCallValid)
7299
        {
7300
            context->getTexParameterIiv(targetPacked, pname, params);
7301
        }
7302
        ANGLE_CAPTURE(GetTexParameterIivEXT, isCallValid, context, targetPacked, pname, params);
7303
    }
7304
    else
7305
    {
7306
        GenerateContextLostErrorOnCurrentGlobalContext();
7307
    }
7308
}
7309

7310
void GL_APIENTRY GL_GetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
7311
{
7312
    Context *context = GetValidGlobalContext();
7313
    EVENT(context, GLGetTexParameterIuivEXT,
7314
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7315
          GLenumToString(GLenumGroup::TextureTarget, target),
7316
          GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
7317

7318
    if (context)
7319
    {
7320
        TextureType targetPacked                              = PackParam<TextureType>(target);
7321
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7322
        bool isCallValid                                      = (context->skipValidation() ||
7323
                            ValidateGetTexParameterIuivEXT(context, targetPacked, pname, params));
7324
        if (isCallValid)
7325
        {
7326
            context->getTexParameterIuiv(targetPacked, pname, params);
7327
        }
7328
        ANGLE_CAPTURE(GetTexParameterIuivEXT, isCallValid, context, targetPacked, pname, params);
7329
    }
7330
    else
7331
    {
7332
        GenerateContextLostErrorOnCurrentGlobalContext();
7333
    }
7334
}
7335

7336
void GL_APIENTRY GL_SamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param)
7337
{
7338
    Context *context = GetValidGlobalContext();
7339
    EVENT(context, GLSamplerParameterIivEXT,
7340
          "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
7341
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
7342

7343
    if (context)
7344
    {
7345
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
7346
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7347
        bool isCallValid                                      = (context->skipValidation() ||
7348
                            ValidateSamplerParameterIivEXT(context, samplerPacked, pname, param));
7349
        if (isCallValid)
7350
        {
7351
            context->samplerParameterIiv(samplerPacked, pname, param);
7352
        }
7353
        ANGLE_CAPTURE(SamplerParameterIivEXT, isCallValid, context, samplerPacked, pname, param);
7354
    }
7355
    else
7356
    {
7357
        GenerateContextLostErrorOnCurrentGlobalContext();
7358
    }
7359
}
7360

7361
void GL_APIENTRY GL_SamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param)
7362
{
7363
    Context *context = GetValidGlobalContext();
7364
    EVENT(context, GLSamplerParameterIuivEXT,
7365
          "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
7366
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
7367

7368
    if (context)
7369
    {
7370
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
7371
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7372
        bool isCallValid                                      = (context->skipValidation() ||
7373
                            ValidateSamplerParameterIuivEXT(context, samplerPacked, pname, param));
7374
        if (isCallValid)
7375
        {
7376
            context->samplerParameterIuiv(samplerPacked, pname, param);
7377
        }
7378
        ANGLE_CAPTURE(SamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname, param);
7379
    }
7380
    else
7381
    {
7382
        GenerateContextLostErrorOnCurrentGlobalContext();
7383
    }
7384
}
7385

7386
void GL_APIENTRY GL_TexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
7387
{
7388
    Context *context = GetValidGlobalContext();
7389
    EVENT(context, GLTexParameterIivEXT,
7390
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7391
          GLenumToString(GLenumGroup::TextureTarget, target),
7392
          GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
7393

7394
    if (context)
7395
    {
7396
        TextureType targetPacked                              = PackParam<TextureType>(target);
7397
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7398
        bool isCallValid                                      = (context->skipValidation() ||
7399
                            ValidateTexParameterIivEXT(context, targetPacked, pname, params));
7400
        if (isCallValid)
7401
        {
7402
            context->texParameterIiv(targetPacked, pname, params);
7403
        }
7404
        ANGLE_CAPTURE(TexParameterIivEXT, isCallValid, context, targetPacked, pname, params);
7405
    }
7406
    else
7407
    {
7408
        GenerateContextLostErrorOnCurrentGlobalContext();
7409
    }
7410
}
7411

7412
void GL_APIENTRY GL_TexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
7413
{
7414
    Context *context = GetValidGlobalContext();
7415
    EVENT(context, GLTexParameterIuivEXT,
7416
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7417
          GLenumToString(GLenumGroup::TextureTarget, target),
7418
          GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
7419

7420
    if (context)
7421
    {
7422
        TextureType targetPacked                              = PackParam<TextureType>(target);
7423
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7424
        bool isCallValid                                      = (context->skipValidation() ||
7425
                            ValidateTexParameterIuivEXT(context, targetPacked, pname, params));
7426
        if (isCallValid)
7427
        {
7428
            context->texParameterIuiv(targetPacked, pname, params);
7429
        }
7430
        ANGLE_CAPTURE(TexParameterIuivEXT, isCallValid, context, targetPacked, pname, params);
7431
    }
7432
    else
7433
    {
7434
        GenerateContextLostErrorOnCurrentGlobalContext();
7435
    }
7436
}
7437

7438
// GL_EXT_texture_buffer
7439
void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
7440
{
7441
    Context *context = GetValidGlobalContext();
7442
    EVENT(context, GLTexBufferEXT, "context = %d, target = %s, internalformat = %s, buffer = %u",
7443
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
7444
          GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer);
7445

7446
    if (context)
7447
    {
7448
        TextureType targetPacked                              = PackParam<TextureType>(target);
7449
        BufferID bufferPacked                                 = PackParam<BufferID>(buffer);
7450
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7451
        bool isCallValid =
7452
            (context->skipValidation() ||
7453
             ValidateTexBufferEXT(context, targetPacked, internalformat, bufferPacked));
7454
        if (isCallValid)
7455
        {
7456
            context->texBuffer(targetPacked, internalformat, bufferPacked);
7457
        }
7458
        ANGLE_CAPTURE(TexBufferEXT, isCallValid, context, targetPacked, internalformat,
7459
                      bufferPacked);
7460
    }
7461
    else
7462
    {
7463
        GenerateContextLostErrorOnCurrentGlobalContext();
7464
    }
7465
}
7466

7467
void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target,
7468
                                      GLenum internalformat,
7469
                                      GLuint buffer,
7470
                                      GLintptr offset,
7471
                                      GLsizeiptr size)
7472
{
7473
    Context *context = GetValidGlobalContext();
7474
    EVENT(context, GLTexBufferRangeEXT,
7475
          "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu",
7476
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
7477
          GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer,
7478
          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
7479

7480
    if (context)
7481
    {
7482
        TextureType targetPacked                              = PackParam<TextureType>(target);
7483
        BufferID bufferPacked                                 = PackParam<BufferID>(buffer);
7484
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7485
        bool isCallValid                                      = (context->skipValidation() ||
7486
                            ValidateTexBufferRangeEXT(context, targetPacked, internalformat,
7487
                                                      bufferPacked, offset, size));
7488
        if (isCallValid)
7489
        {
7490
            context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size);
7491
        }
7492
        ANGLE_CAPTURE(TexBufferRangeEXT, isCallValid, context, targetPacked, internalformat,
7493
                      bufferPacked, offset, size);
7494
    }
7495
    else
7496
    {
7497
        GenerateContextLostErrorOnCurrentGlobalContext();
7498
    }
7499
}
7500

7501
// GL_EXT_texture_compression_bptc
7502

7503
// GL_EXT_texture_compression_dxt1
7504

7505
// GL_EXT_texture_compression_rgtc
7506

7507
// GL_EXT_texture_compression_s3tc
7508

7509
// GL_EXT_texture_compression_s3tc_srgb
7510

7511
// GL_EXT_texture_cube_map_array
7512

7513
// GL_EXT_texture_filter_anisotropic
7514

7515
// GL_EXT_texture_format_BGRA8888
7516

7517
// GL_EXT_texture_sRGB_R8
7518

7519
// GL_EXT_texture_sRGB_RG8
7520

7521
// GL_EXT_texture_storage
7522
void GL_APIENTRY GL_TexStorage1DEXT(GLenum target,
7523
                                    GLsizei levels,
7524
                                    GLenum internalformat,
7525
                                    GLsizei width)
7526
{
7527
    Context *context = GetValidGlobalContext();
7528
    EVENT(context, GLTexStorage1DEXT,
7529
          "context = %d, target = %s, levels = %d, internalformat = %s, width = %d", CID(context),
7530
          GLenumToString(GLenumGroup::TextureTarget, target), levels,
7531
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width);
7532

7533
    if (context)
7534
    {
7535
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7536
        bool isCallValid =
7537
            (context->skipValidation() ||
7538
             ValidateTexStorage1DEXT(context, target, levels, internalformat, width));
7539
        if (isCallValid)
7540
        {
7541
            context->texStorage1D(target, levels, internalformat, width);
7542
        }
7543
        ANGLE_CAPTURE(TexStorage1DEXT, isCallValid, context, target, levels, internalformat, width);
7544
    }
7545
    else
7546
    {
7547
        GenerateContextLostErrorOnCurrentGlobalContext();
7548
    }
7549
}
7550

7551
void GL_APIENTRY GL_TexStorage2DEXT(GLenum target,
7552
                                    GLsizei levels,
7553
                                    GLenum internalformat,
7554
                                    GLsizei width,
7555
                                    GLsizei height)
7556
{
7557
    Context *context = GetValidGlobalContext();
7558
    EVENT(context, GLTexStorage2DEXT,
7559
          "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d",
7560
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
7561
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
7562

7563
    if (context)
7564
    {
7565
        TextureType targetPacked                              = PackParam<TextureType>(target);
7566
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7567
        bool isCallValid =
7568
            (context->skipValidation() ||
7569
             ValidateTexStorage2DEXT(context, targetPacked, levels, internalformat, width, height));
7570
        if (isCallValid)
7571
        {
7572
            context->texStorage2D(targetPacked, levels, internalformat, width, height);
7573
        }
7574
        ANGLE_CAPTURE(TexStorage2DEXT, isCallValid, context, targetPacked, levels, internalformat,
7575
                      width, height);
7576
    }
7577
    else
7578
    {
7579
        GenerateContextLostErrorOnCurrentGlobalContext();
7580
    }
7581
}
7582

7583
void GL_APIENTRY GL_TexStorage3DEXT(GLenum target,
7584
                                    GLsizei levels,
7585
                                    GLenum internalformat,
7586
                                    GLsizei width,
7587
                                    GLsizei height,
7588
                                    GLsizei depth)
7589
{
7590
    Context *context = GetValidGlobalContext();
7591
    EVENT(context, GLTexStorage3DEXT,
7592
          "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, "
7593
          "depth = %d",
7594
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
7595
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth);
7596

7597
    if (context)
7598
    {
7599
        TextureType targetPacked                              = PackParam<TextureType>(target);
7600
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7601
        bool isCallValid                                      = (context->skipValidation() ||
7602
                            ValidateTexStorage3DEXT(context, targetPacked, levels, internalformat,
7603
                                                    width, height, depth));
7604
        if (isCallValid)
7605
        {
7606
            context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
7607
        }
7608
        ANGLE_CAPTURE(TexStorage3DEXT, isCallValid, context, targetPacked, levels, internalformat,
7609
                      width, height, depth);
7610
    }
7611
    else
7612
    {
7613
        GenerateContextLostErrorOnCurrentGlobalContext();
7614
    }
7615
}
7616

7617
// GL_IMG_texture_compression_pvrtc
7618

7619
// GL_IMG_texture_compression_pvrtc2
7620

7621
// GL_KHR_blend_equation_advanced
7622
void GL_APIENTRY GL_BlendBarrierKHR()
7623
{
7624
    Context *context = GetValidGlobalContext();
7625
    EVENT(context, GLBlendBarrierKHR, "context = %d", CID(context));
7626

7627
    if (context)
7628
    {
7629
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7630
        bool isCallValid = (context->skipValidation() || ValidateBlendBarrierKHR(context));
7631
        if (isCallValid)
7632
        {
7633
            context->blendBarrier();
7634
        }
7635
        ANGLE_CAPTURE(BlendBarrierKHR, isCallValid, context);
7636
    }
7637
    else
7638
    {
7639
        GenerateContextLostErrorOnCurrentGlobalContext();
7640
    }
7641
}
7642

7643
// GL_KHR_debug
7644
void GL_APIENTRY GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
7645
{
7646
    Context *context = GetValidGlobalContext();
7647
    EVENT(context, GLDebugMessageCallbackKHR,
7648
          "context = %d, callback = 0x%016" PRIxPTR ", userParam = 0x%016" PRIxPTR "", CID(context),
7649
          (uintptr_t)callback, (uintptr_t)userParam);
7650

7651
    if (context)
7652
    {
7653
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7654
        bool isCallValid                                      = (context->skipValidation() ||
7655
                            ValidateDebugMessageCallbackKHR(context, callback, userParam));
7656
        if (isCallValid)
7657
        {
7658
            context->debugMessageCallback(callback, userParam);
7659
        }
7660
        ANGLE_CAPTURE(DebugMessageCallbackKHR, isCallValid, context, callback, userParam);
7661
    }
7662
    else
7663
    {
7664
        GenerateContextLostErrorOnCurrentGlobalContext();
7665
    }
7666
}
7667

7668
void GL_APIENTRY GL_DebugMessageControlKHR(GLenum source,
7669
                                           GLenum type,
7670
                                           GLenum severity,
7671
                                           GLsizei count,
7672
                                           const GLuint *ids,
7673
                                           GLboolean enabled)
7674
{
7675
    Context *context = GetValidGlobalContext();
7676
    EVENT(context, GLDebugMessageControlKHR,
7677
          "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR
7678
          ", enabled = %s",
7679
          CID(context), GLenumToString(GLenumGroup::DebugSource, source),
7680
          GLenumToString(GLenumGroup::DebugType, type),
7681
          GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids,
7682
          GLbooleanToString(enabled));
7683

7684
    if (context)
7685
    {
7686
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7687
        bool isCallValid =
7688
            (context->skipValidation() ||
7689
             ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled));
7690
        if (isCallValid)
7691
        {
7692
            context->debugMessageControl(source, type, severity, count, ids, enabled);
7693
        }
7694
        ANGLE_CAPTURE(DebugMessageControlKHR, isCallValid, context, source, type, severity, count,
7695
                      ids, enabled);
7696
    }
7697
    else
7698
    {
7699
        GenerateContextLostErrorOnCurrentGlobalContext();
7700
    }
7701
}
7702

7703
void GL_APIENTRY GL_DebugMessageInsertKHR(GLenum source,
7704
                                          GLenum type,
7705
                                          GLuint id,
7706
                                          GLenum severity,
7707
                                          GLsizei length,
7708
                                          const GLchar *buf)
7709
{
7710
    Context *context = GetValidGlobalContext();
7711
    EVENT(context, GLDebugMessageInsertKHR,
7712
          "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = "
7713
          "0x%016" PRIxPTR "",
7714
          CID(context), GLenumToString(GLenumGroup::DebugSource, source),
7715
          GLenumToString(GLenumGroup::DebugType, type), id,
7716
          GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf);
7717

7718
    if (context)
7719
    {
7720
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7721
        bool isCallValid =
7722
            (context->skipValidation() ||
7723
             ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf));
7724
        if (isCallValid)
7725
        {
7726
            context->debugMessageInsert(source, type, id, severity, length, buf);
7727
        }
7728
        ANGLE_CAPTURE(DebugMessageInsertKHR, isCallValid, context, source, type, id, severity,
7729
                      length, buf);
7730
    }
7731
    else
7732
    {
7733
        GenerateContextLostErrorOnCurrentGlobalContext();
7734
    }
7735
}
7736

7737
GLuint GL_APIENTRY GL_GetDebugMessageLogKHR(GLuint count,
7738
                                            GLsizei bufSize,
7739
                                            GLenum *sources,
7740
                                            GLenum *types,
7741
                                            GLuint *ids,
7742
                                            GLenum *severities,
7743
                                            GLsizei *lengths,
7744
                                            GLchar *messageLog)
7745
{
7746
    Context *context = GetValidGlobalContext();
7747
    EVENT(context, GLGetDebugMessageLogKHR,
7748
          "context = %d, count = %u, bufSize = %d, sources = 0x%016" PRIxPTR
7749
          ", types = 0x%016" PRIxPTR ", ids = 0x%016" PRIxPTR ", severities = 0x%016" PRIxPTR
7750
          ", lengths = 0x%016" PRIxPTR ", messageLog = 0x%016" PRIxPTR "",
7751
          CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
7752
          (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
7753

7754
    GLuint returnValue;
7755
    if (context)
7756
    {
7757
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7758
        bool isCallValid                                      = (context->skipValidation() ||
7759
                            ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types,
7760
                                                          ids, severities, lengths, messageLog));
7761
        if (isCallValid)
7762
        {
7763
            returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
7764
                                                      severities, lengths, messageLog);
7765
        }
7766
        else
7767
        {
7768
            returnValue =
7769
                GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>();
7770
        }
7771
        ANGLE_CAPTURE(GetDebugMessageLogKHR, isCallValid, context, count, bufSize, sources, types,
7772
                      ids, severities, lengths, messageLog, returnValue);
7773
    }
7774
    else
7775
    {
7776
        GenerateContextLostErrorOnCurrentGlobalContext();
7777
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>();
7778
    }
7779
    return returnValue;
7780
}
7781

7782
void GL_APIENTRY GL_GetObjectLabelKHR(GLenum identifier,
7783
                                      GLuint name,
7784
                                      GLsizei bufSize,
7785
                                      GLsizei *length,
7786
                                      GLchar *label)
7787
{
7788
    Context *context = GetValidGlobalContext();
7789
    EVENT(context, GLGetObjectLabelKHR,
7790
          "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR
7791
          ", label = 0x%016" PRIxPTR "",
7792
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize,
7793
          (uintptr_t)length, (uintptr_t)label);
7794

7795
    if (context)
7796
    {
7797
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7798
        bool isCallValid =
7799
            (context->skipValidation() ||
7800
             ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label));
7801
        if (isCallValid)
7802
        {
7803
            context->getObjectLabel(identifier, name, bufSize, length, label);
7804
        }
7805
        ANGLE_CAPTURE(GetObjectLabelKHR, isCallValid, context, identifier, name, bufSize, length,
7806
                      label);
7807
    }
7808
    else
7809
    {
7810
        GenerateContextLostErrorOnCurrentGlobalContext();
7811
    }
7812
}
7813

7814
void GL_APIENTRY GL_GetObjectPtrLabelKHR(const void *ptr,
7815
                                         GLsizei bufSize,
7816
                                         GLsizei *length,
7817
                                         GLchar *label)
7818
{
7819
    Context *context = GetValidGlobalContext();
7820
    EVENT(context, GLGetObjectPtrLabelKHR,
7821
          "context = %d, ptr = 0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR
7822
          ", label = 0x%016" PRIxPTR "",
7823
          CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
7824

7825
    if (context)
7826
    {
7827
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7828
        bool isCallValid                                      = (context->skipValidation() ||
7829
                            ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label));
7830
        if (isCallValid)
7831
        {
7832
            context->getObjectPtrLabel(ptr, bufSize, length, label);
7833
        }
7834
        ANGLE_CAPTURE(GetObjectPtrLabelKHR, isCallValid, context, ptr, bufSize, length, label);
7835
    }
7836
    else
7837
    {
7838
        GenerateContextLostErrorOnCurrentGlobalContext();
7839
    }
7840
}
7841

7842
void GL_APIENTRY GL_GetPointervKHR(GLenum pname, void **params)
7843
{
7844
    Context *context = GetValidGlobalContext();
7845
    EVENT(context, GLGetPointervKHR, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
7846
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
7847

7848
    if (context)
7849
    {
7850
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7851
        bool isCallValid =
7852
            (context->skipValidation() || ValidateGetPointervKHR(context, pname, params));
7853
        if (isCallValid)
7854
        {
7855
            context->getPointerv(pname, params);
7856
        }
7857
        ANGLE_CAPTURE(GetPointervKHR, isCallValid, context, pname, params);
7858
    }
7859
    else
7860
    {
7861
        GenerateContextLostErrorOnCurrentGlobalContext();
7862
    }
7863
}
7864

7865
void GL_APIENTRY GL_ObjectLabelKHR(GLenum identifier,
7866
                                   GLuint name,
7867
                                   GLsizei length,
7868
                                   const GLchar *label)
7869
{
7870
    Context *context = GetValidGlobalContext();
7871
    EVENT(context, GLObjectLabelKHR,
7872
          "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "",
7873
          CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length,
7874
          (uintptr_t)label);
7875

7876
    if (context)
7877
    {
7878
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7879
        bool isCallValid                                      = (context->skipValidation() ||
7880
                            ValidateObjectLabelKHR(context, identifier, name, length, label));
7881
        if (isCallValid)
7882
        {
7883
            context->objectLabel(identifier, name, length, label);
7884
        }
7885
        ANGLE_CAPTURE(ObjectLabelKHR, isCallValid, context, identifier, name, length, label);
7886
    }
7887
    else
7888
    {
7889
        GenerateContextLostErrorOnCurrentGlobalContext();
7890
    }
7891
}
7892

7893
void GL_APIENTRY GL_ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
7894
{
7895
    Context *context = GetValidGlobalContext();
7896
    EVENT(context, GLObjectPtrLabelKHR,
7897
          "context = %d, ptr = 0x%016" PRIxPTR ", length = %d, label = 0x%016" PRIxPTR "",
7898
          CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
7899

7900
    if (context)
7901
    {
7902
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7903
        bool isCallValid =
7904
            (context->skipValidation() || ValidateObjectPtrLabelKHR(context, ptr, length, label));
7905
        if (isCallValid)
7906
        {
7907
            context->objectPtrLabel(ptr, length, label);
7908
        }
7909
        ANGLE_CAPTURE(ObjectPtrLabelKHR, isCallValid, context, ptr, length, label);
7910
    }
7911
    else
7912
    {
7913
        GenerateContextLostErrorOnCurrentGlobalContext();
7914
    }
7915
}
7916

7917
void GL_APIENTRY GL_PopDebugGroupKHR()
7918
{
7919
    Context *context = GetValidGlobalContext();
7920
    EVENT(context, GLPopDebugGroupKHR, "context = %d", CID(context));
7921

7922
    if (context)
7923
    {
7924
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7925
        bool isCallValid = (context->skipValidation() || ValidatePopDebugGroupKHR(context));
7926
        if (isCallValid)
7927
        {
7928
            context->popDebugGroup();
7929
        }
7930
        ANGLE_CAPTURE(PopDebugGroupKHR, isCallValid, context);
7931
    }
7932
    else
7933
    {
7934
        GenerateContextLostErrorOnCurrentGlobalContext();
7935
    }
7936
}
7937

7938
void GL_APIENTRY GL_PushDebugGroupKHR(GLenum source,
7939
                                      GLuint id,
7940
                                      GLsizei length,
7941
                                      const GLchar *message)
7942
{
7943
    Context *context = GetValidGlobalContext();
7944
    EVENT(context, GLPushDebugGroupKHR,
7945
          "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "",
7946
          CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length,
7947
          (uintptr_t)message);
7948

7949
    if (context)
7950
    {
7951
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7952
        bool isCallValid                                      = (context->skipValidation() ||
7953
                            ValidatePushDebugGroupKHR(context, source, id, length, message));
7954
        if (isCallValid)
7955
        {
7956
            context->pushDebugGroup(source, id, length, message);
7957
        }
7958
        ANGLE_CAPTURE(PushDebugGroupKHR, isCallValid, context, source, id, length, message);
7959
    }
7960
    else
7961
    {
7962
        GenerateContextLostErrorOnCurrentGlobalContext();
7963
    }
7964
}
7965

7966
// GL_KHR_parallel_shader_compile
7967
void GL_APIENTRY GL_MaxShaderCompilerThreadsKHR(GLuint count)
7968
{
7969
    Context *context = GetValidGlobalContext();
7970
    EVENT(context, GLMaxShaderCompilerThreadsKHR, "context = %d, count = %u", CID(context), count);
7971

7972
    if (context)
7973
    {
7974
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7975
        bool isCallValid =
7976
            (context->skipValidation() || ValidateMaxShaderCompilerThreadsKHR(context, count));
7977
        if (isCallValid)
7978
        {
7979
            context->maxShaderCompilerThreads(count);
7980
        }
7981
        ANGLE_CAPTURE(MaxShaderCompilerThreadsKHR, isCallValid, context, count);
7982
    }
7983
    else
7984
    {
7985
        GenerateContextLostErrorOnCurrentGlobalContext();
7986
    }
7987
}
7988

7989
// GL_KHR_texture_compression_astc_hdr
7990

7991
// GL_KHR_texture_compression_astc_ldr
7992

7993
// GL_KHR_texture_compression_astc_sliced_3d
7994

7995
// GL_NV_fence
7996
void GL_APIENTRY GL_DeleteFencesNV(GLsizei n, const GLuint *fences)
7997
{
7998
    Context *context = GetValidGlobalContext();
7999
    EVENT(context, GLDeleteFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "",
8000
          CID(context), n, (uintptr_t)fences);
8001

8002
    if (context)
8003
    {
8004
        const FenceNVID *fencesPacked = PackParam<const FenceNVID *>(fences);
8005
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8006
        bool isCallValid =
8007
            (context->skipValidation() || ValidateDeleteFencesNV(context, n, fencesPacked));
8008
        if (isCallValid)
8009
        {
8010
            context->deleteFencesNV(n, fencesPacked);
8011
        }
8012
        ANGLE_CAPTURE(DeleteFencesNV, isCallValid, context, n, fencesPacked);
8013
    }
8014
    else
8015
    {
8016
        GenerateContextLostErrorOnCurrentGlobalContext();
8017
    }
8018
}
8019

8020
void GL_APIENTRY GL_FinishFenceNV(GLuint fence)
8021
{
8022
    Context *context = GetValidGlobalContext();
8023
    EVENT(context, GLFinishFenceNV, "context = %d, fence = %u", CID(context), fence);
8024

8025
    if (context)
8026
    {
8027
        FenceNVID fencePacked                                 = PackParam<FenceNVID>(fence);
8028
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8029
        bool isCallValid =
8030
            (context->skipValidation() || ValidateFinishFenceNV(context, fencePacked));
8031
        if (isCallValid)
8032
        {
8033
            context->finishFenceNV(fencePacked);
8034
        }
8035
        ANGLE_CAPTURE(FinishFenceNV, isCallValid, context, fencePacked);
8036
    }
8037
    else
8038
    {
8039
        GenerateContextLostErrorOnCurrentGlobalContext();
8040
    }
8041
}
8042

8043
void GL_APIENTRY GL_GenFencesNV(GLsizei n, GLuint *fences)
8044
{
8045
    Context *context = GetValidGlobalContext();
8046
    EVENT(context, GLGenFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "", CID(context),
8047
          n, (uintptr_t)fences);
8048

8049
    if (context)
8050
    {
8051
        FenceNVID *fencesPacked                               = PackParam<FenceNVID *>(fences);
8052
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8053
        bool isCallValid =
8054
            (context->skipValidation() || ValidateGenFencesNV(context, n, fencesPacked));
8055
        if (isCallValid)
8056
        {
8057
            context->genFencesNV(n, fencesPacked);
8058
        }
8059
        ANGLE_CAPTURE(GenFencesNV, isCallValid, context, n, fencesPacked);
8060
    }
8061
    else
8062
    {
8063
        GenerateContextLostErrorOnCurrentGlobalContext();
8064
    }
8065
}
8066

8067
void GL_APIENTRY GL_GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
8068
{
8069
    Context *context = GetValidGlobalContext();
8070
    EVENT(context, GLGetFenceivNV,
8071
          "context = %d, fence = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), fence,
8072
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
8073

8074
    if (context)
8075
    {
8076
        FenceNVID fencePacked                                 = PackParam<FenceNVID>(fence);
8077
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8078
        bool isCallValid                                      = (context->skipValidation() ||
8079
                            ValidateGetFenceivNV(context, fencePacked, pname, params));
8080
        if (isCallValid)
8081
        {
8082
            context->getFenceivNV(fencePacked, pname, params);
8083
        }
8084
        ANGLE_CAPTURE(GetFenceivNV, isCallValid, context, fencePacked, pname, params);
8085
    }
8086
    else
8087
    {
8088
        GenerateContextLostErrorOnCurrentGlobalContext();
8089
    }
8090
}
8091

8092
GLboolean GL_APIENTRY GL_IsFenceNV(GLuint fence)
8093
{
8094
    Context *context = GetValidGlobalContext();
8095
    EVENT(context, GLIsFenceNV, "context = %d, fence = %u", CID(context), fence);
8096

8097
    GLboolean returnValue;
8098
    if (context)
8099
    {
8100
        FenceNVID fencePacked                                 = PackParam<FenceNVID>(fence);
8101
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8102
        bool isCallValid = (context->skipValidation() || ValidateIsFenceNV(context, fencePacked));
8103
        if (isCallValid)
8104
        {
8105
            returnValue = context->isFenceNV(fencePacked);
8106
        }
8107
        else
8108
        {
8109
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>();
8110
        }
8111
        ANGLE_CAPTURE(IsFenceNV, isCallValid, context, fencePacked, returnValue);
8112
    }
8113
    else
8114
    {
8115
        GenerateContextLostErrorOnCurrentGlobalContext();
8116
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>();
8117
    }
8118
    return returnValue;
8119
}
8120

8121
void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition)
8122
{
8123
    Context *context = GetValidGlobalContext();
8124
    EVENT(context, GLSetFenceNV, "context = %d, fence = %u, condition = %s", CID(context), fence,
8125
          GLenumToString(GLenumGroup::DefaultGroup, condition));
8126

8127
    if (context)
8128
    {
8129
        FenceNVID fencePacked                                 = PackParam<FenceNVID>(fence);
8130
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8131
        bool isCallValid =
8132
            (context->skipValidation() || ValidateSetFenceNV(context, fencePacked, condition));
8133
        if (isCallValid)
8134
        {
8135
            context->setFenceNV(fencePacked, condition);
8136
        }
8137
        ANGLE_CAPTURE(SetFenceNV, isCallValid, context, fencePacked, condition);
8138
    }
8139
    else
8140
    {
8141
        GenerateContextLostErrorOnCurrentGlobalContext();
8142
    }
8143
}
8144

8145
GLboolean GL_APIENTRY GL_TestFenceNV(GLuint fence)
8146
{
8147
    Context *context = GetValidGlobalContext();
8148
    EVENT(context, GLTestFenceNV, "context = %d, fence = %u", CID(context), fence);
8149

8150
    GLboolean returnValue;
8151
    if (context)
8152
    {
8153
        FenceNVID fencePacked                                 = PackParam<FenceNVID>(fence);
8154
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8155
        bool isCallValid = (context->skipValidation() || ValidateTestFenceNV(context, fencePacked));
8156
        if (isCallValid)
8157
        {
8158
            returnValue = context->testFenceNV(fencePacked);
8159
        }
8160
        else
8161
        {
8162
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>();
8163
        }
8164
        ANGLE_CAPTURE(TestFenceNV, isCallValid, context, fencePacked, returnValue);
8165
    }
8166
    else
8167
    {
8168
        GenerateContextLostErrorOnCurrentGlobalContext();
8169
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>();
8170
    }
8171
    return returnValue;
8172
}
8173

8174
// GL_NV_framebuffer_blit
8175
void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0,
8176
                                      GLint srcY0,
8177
                                      GLint srcX1,
8178
                                      GLint srcY1,
8179
                                      GLint dstX0,
8180
                                      GLint dstY0,
8181
                                      GLint dstX1,
8182
                                      GLint dstY1,
8183
                                      GLbitfield mask,
8184
                                      GLenum filter)
8185
{
8186
    Context *context = GetValidGlobalContext();
8187
    EVENT(context, GLBlitFramebufferNV,
8188
          "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
8189
          "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
8190
          CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
8191
          GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
8192
          GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
8193

8194
    if (context)
8195
    {
8196
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8197
        bool isCallValid                                      = (context->skipValidation() ||
8198
                            ValidateBlitFramebufferNV(context, srcX0, srcY0, srcX1, srcY1, dstX0,
8199
                                                      dstY0, dstX1, dstY1, mask, filter));
8200
        if (isCallValid)
8201
        {
8202
            context->blitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
8203
                                       filter);
8204
        }
8205
        ANGLE_CAPTURE(BlitFramebufferNV, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
8206
                      dstY0, dstX1, dstY1, mask, filter);
8207
    }
8208
    else
8209
    {
8210
        GenerateContextLostErrorOnCurrentGlobalContext();
8211
    }
8212
}
8213

8214
// GL_OES_EGL_image
8215
void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
8216
{
8217
    Context *context = GetValidGlobalContext();
8218
    EVENT(context, GLEGLImageTargetRenderbufferStorageOES,
8219
          "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context),
8220
          GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
8221

8222
    if (context)
8223
    {
8224
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8225
        bool isCallValid                                      = (context->skipValidation() ||
8226
                            ValidateEGLImageTargetRenderbufferStorageOES(context, target, image));
8227
        if (isCallValid)
8228
        {
8229
            context->eGLImageTargetRenderbufferStorage(target, image);
8230
        }
8231
        ANGLE_CAPTURE(EGLImageTargetRenderbufferStorageOES, isCallValid, context, target, image);
8232
    }
8233
    else
8234
    {
8235
        GenerateContextLostErrorOnCurrentGlobalContext();
8236
    }
8237
}
8238

8239
void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
8240
{
8241
    Context *context = GetValidGlobalContext();
8242
    EVENT(context, GLEGLImageTargetTexture2DOES,
8243
          "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context),
8244
          GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
8245

8246
    if (context)
8247
    {
8248
        TextureType targetPacked                              = PackParam<TextureType>(target);
8249
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8250
        bool isCallValid                                      = (context->skipValidation() ||
8251
                            ValidateEGLImageTargetTexture2DOES(context, targetPacked, image));
8252
        if (isCallValid)
8253
        {
8254
            context->eGLImageTargetTexture2D(targetPacked, image);
8255
        }
8256
        ANGLE_CAPTURE(EGLImageTargetTexture2DOES, isCallValid, context, targetPacked, image);
8257
    }
8258
    else
8259
    {
8260
        GenerateContextLostErrorOnCurrentGlobalContext();
8261
    }
8262
}
8263

8264
// GL_OES_compressed_ETC1_RGB8_texture
8265

8266
// GL_OES_copy_image
8267
void GL_APIENTRY GL_CopyImageSubDataOES(GLuint srcName,
8268
                                        GLenum srcTarget,
8269
                                        GLint srcLevel,
8270
                                        GLint srcX,
8271
                                        GLint srcY,
8272
                                        GLint srcZ,
8273
                                        GLuint dstName,
8274
                                        GLenum dstTarget,
8275
                                        GLint dstLevel,
8276
                                        GLint dstX,
8277
                                        GLint dstY,
8278
                                        GLint dstZ,
8279
                                        GLsizei srcWidth,
8280
                                        GLsizei srcHeight,
8281
                                        GLsizei srcDepth)
8282
{
8283
    Context *context = GetValidGlobalContext();
8284
    EVENT(context, GLCopyImageSubDataOES,
8285
          "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = "
8286
          "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, "
8287
          "srcWidth = %d, srcHeight = %d, srcDepth = %d",
8288
          CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget),
8289
          srcLevel, srcX, srcY, srcZ, dstName,
8290
          GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY,
8291
          dstZ, srcWidth, srcHeight, srcDepth);
8292

8293
    if (context)
8294
    {
8295
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8296
        bool isCallValid =
8297
            (context->skipValidation() ||
8298
             ValidateCopyImageSubDataOES(context, srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
8299
                                         dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
8300
                                         srcHeight, srcDepth));
8301
        if (isCallValid)
8302
        {
8303
            context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
8304
                                      dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
8305
                                      srcDepth);
8306
        }
8307
        ANGLE_CAPTURE(CopyImageSubDataOES, isCallValid, context, srcName, srcTarget, srcLevel, srcX,
8308
                      srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
8309
                      srcHeight, srcDepth);
8310
    }
8311
    else
8312
    {
8313
        GenerateContextLostErrorOnCurrentGlobalContext();
8314
    }
8315
}
8316

8317
// GL_OES_depth32
8318

8319
// GL_OES_draw_buffers_indexed
8320
void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
8321
{
8322
    Context *context = GetValidGlobalContext();
8323
    EVENT(context, GLBlendEquationSeparateiOES,
8324
          "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf,
8325
          GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
8326
          GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
8327

8328
    if (context)
8329
    {
8330
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8331
        bool isCallValid                                      = (context->skipValidation() ||
8332
                            ValidateBlendEquationSeparateiOES(context, buf, modeRGB, modeAlpha));
8333
        if (isCallValid)
8334
        {
8335
            context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
8336
        }
8337
        ANGLE_CAPTURE(BlendEquationSeparateiOES, isCallValid, context, buf, modeRGB, modeAlpha);
8338
    }
8339
    else
8340
    {
8341
        GenerateContextLostErrorOnCurrentGlobalContext();
8342
    }
8343
}
8344

8345
void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode)
8346
{
8347
    Context *context = GetValidGlobalContext();
8348
    EVENT(context, GLBlendEquationiOES, "context = %d, buf = %u, mode = %s", CID(context), buf,
8349
          GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
8350

8351
    if (context)
8352
    {
8353
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8354
        bool isCallValid =
8355
            (context->skipValidation() || ValidateBlendEquationiOES(context, buf, mode));
8356
        if (isCallValid)
8357
        {
8358
            context->blendEquationi(buf, mode);
8359
        }
8360
        ANGLE_CAPTURE(BlendEquationiOES, isCallValid, context, buf, mode);
8361
    }
8362
    else
8363
    {
8364
        GenerateContextLostErrorOnCurrentGlobalContext();
8365
    }
8366
}
8367

8368
void GL_APIENTRY
8369
GL_BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
8370
{
8371
    Context *context = GetValidGlobalContext();
8372
    EVENT(context, GLBlendFuncSeparateiOES,
8373
          "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s",
8374
          CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
8375
          GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
8376
          GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
8377
          GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
8378

8379
    if (context)
8380
    {
8381
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8382
        bool isCallValid =
8383
            (context->skipValidation() ||
8384
             ValidateBlendFuncSeparateiOES(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
8385
        if (isCallValid)
8386
        {
8387
            context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
8388
        }
8389
        ANGLE_CAPTURE(BlendFuncSeparateiOES, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
8390
                      dstAlpha);
8391
    }
8392
    else
8393
    {
8394
        GenerateContextLostErrorOnCurrentGlobalContext();
8395
    }
8396
}
8397

8398
void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst)
8399
{
8400
    Context *context = GetValidGlobalContext();
8401
    EVENT(context, GLBlendFunciOES, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf,
8402
          GLenumToString(GLenumGroup::BlendingFactor, src),
8403
          GLenumToString(GLenumGroup::BlendingFactor, dst));
8404

8405
    if (context)
8406
    {
8407
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8408
        bool isCallValid =
8409
            (context->skipValidation() || ValidateBlendFunciOES(context, buf, src, dst));
8410
        if (isCallValid)
8411
        {
8412
            context->blendFunci(buf, src, dst);
8413
        }
8414
        ANGLE_CAPTURE(BlendFunciOES, isCallValid, context, buf, src, dst);
8415
    }
8416
    else
8417
    {
8418
        GenerateContextLostErrorOnCurrentGlobalContext();
8419
    }
8420
}
8421

8422
void GL_APIENTRY GL_ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
8423
{
8424
    Context *context = GetValidGlobalContext();
8425
    EVENT(context, GLColorMaskiOES, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s",
8426
          CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
8427
          GLbooleanToString(a));
8428

8429
    if (context)
8430
    {
8431
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8432
        bool isCallValid =
8433
            (context->skipValidation() || ValidateColorMaskiOES(context, index, r, g, b, a));
8434
        if (isCallValid)
8435
        {
8436
            context->colorMaski(index, r, g, b, a);
8437
        }
8438
        ANGLE_CAPTURE(ColorMaskiOES, isCallValid, context, index, r, g, b, a);
8439
    }
8440
    else
8441
    {
8442
        GenerateContextLostErrorOnCurrentGlobalContext();
8443
    }
8444
}
8445

8446
void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index)
8447
{
8448
    Context *context = GetValidGlobalContext();
8449
    EVENT(context, GLDisableiOES, "context = %d, target = %s, index = %u", CID(context),
8450
          GLenumToString(GLenumGroup::EnableCap, target), index);
8451

8452
    if (context)
8453
    {
8454
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8455
        bool isCallValid =
8456
            (context->skipValidation() || ValidateDisableiOES(context, target, index));
8457
        if (isCallValid)
8458
        {
8459
            context->disablei(target, index);
8460
        }
8461
        ANGLE_CAPTURE(DisableiOES, isCallValid, context, target, index);
8462
    }
8463
    else
8464
    {
8465
        GenerateContextLostErrorOnCurrentGlobalContext();
8466
    }
8467
}
8468

8469
void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index)
8470
{
8471
    Context *context = GetValidGlobalContext();
8472
    EVENT(context, GLEnableiOES, "context = %d, target = %s, index = %u", CID(context),
8473
          GLenumToString(GLenumGroup::EnableCap, target), index);
8474

8475
    if (context)
8476
    {
8477
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8478
        bool isCallValid =
8479
            (context->skipValidation() || ValidateEnableiOES(context, target, index));
8480
        if (isCallValid)
8481
        {
8482
            context->enablei(target, index);
8483
        }
8484
        ANGLE_CAPTURE(EnableiOES, isCallValid, context, target, index);
8485
    }
8486
    else
8487
    {
8488
        GenerateContextLostErrorOnCurrentGlobalContext();
8489
    }
8490
}
8491

8492
GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index)
8493
{
8494
    Context *context = GetValidGlobalContext();
8495
    EVENT(context, GLIsEnablediOES, "context = %d, target = %s, index = %u", CID(context),
8496
          GLenumToString(GLenumGroup::EnableCap, target), index);
8497

8498
    GLboolean returnValue;
8499
    if (context)
8500
    {
8501
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8502
        bool isCallValid =
8503
            (context->skipValidation() || ValidateIsEnablediOES(context, target, index));
8504
        if (isCallValid)
8505
        {
8506
            returnValue = context->isEnabledi(target, index);
8507
        }
8508
        else
8509
        {
8510
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>();
8511
        }
8512
        ANGLE_CAPTURE(IsEnablediOES, isCallValid, context, target, index, returnValue);
8513
    }
8514
    else
8515
    {
8516
        GenerateContextLostErrorOnCurrentGlobalContext();
8517
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>();
8518
    }
8519
    return returnValue;
8520
}
8521

8522
// GL_OES_draw_elements_base_vertex
8523
void GL_APIENTRY GL_DrawElementsBaseVertexOES(GLenum mode,
8524
                                              GLsizei count,
8525
                                              GLenum type,
8526
                                              const void *indices,
8527
                                              GLint basevertex)
8528
{
8529
    Context *context = GetValidGlobalContext();
8530
    EVENT(context, GLDrawElementsBaseVertexOES,
8531
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
8532
          ", basevertex = %d",
8533
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
8534
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
8535

8536
    if (context)
8537
    {
8538
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
8539
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
8540
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8541
        bool isCallValid                                      = (context->skipValidation() ||
8542
                            ValidateDrawElementsBaseVertexOES(context, modePacked, count,
8543
                                                              typePacked, indices, basevertex));
8544
        if (isCallValid)
8545
        {
8546
            context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
8547
        }
8548
        ANGLE_CAPTURE(DrawElementsBaseVertexOES, isCallValid, context, modePacked, count,
8549
                      typePacked, indices, basevertex);
8550
    }
8551
    else
8552
    {
8553
        GenerateContextLostErrorOnCurrentGlobalContext();
8554
    }
8555
}
8556

8557
void GL_APIENTRY GL_DrawElementsInstancedBaseVertexOES(GLenum mode,
8558
                                                       GLsizei count,
8559
                                                       GLenum type,
8560
                                                       const void *indices,
8561
                                                       GLsizei instancecount,
8562
                                                       GLint basevertex)
8563
{
8564
    Context *context = GetValidGlobalContext();
8565
    EVENT(context, GLDrawElementsInstancedBaseVertexOES,
8566
          "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
8567
          ", instancecount = %d, basevertex = %d",
8568
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
8569
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
8570
          basevertex);
8571

8572
    if (context)
8573
    {
8574
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
8575
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
8576
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8577
        bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexOES(
8578
                                                             context, modePacked, count, typePacked,
8579
                                                             indices, instancecount, basevertex));
8580
        if (isCallValid)
8581
        {
8582
            context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
8583
                                                     instancecount, basevertex);
8584
        }
8585
        ANGLE_CAPTURE(DrawElementsInstancedBaseVertexOES, isCallValid, context, modePacked, count,
8586
                      typePacked, indices, instancecount, basevertex);
8587
    }
8588
    else
8589
    {
8590
        GenerateContextLostErrorOnCurrentGlobalContext();
8591
    }
8592
}
8593

8594
void GL_APIENTRY GL_DrawRangeElementsBaseVertexOES(GLenum mode,
8595
                                                   GLuint start,
8596
                                                   GLuint end,
8597
                                                   GLsizei count,
8598
                                                   GLenum type,
8599
                                                   const void *indices,
8600
                                                   GLint basevertex)
8601
{
8602
    Context *context = GetValidGlobalContext();
8603
    EVENT(context, GLDrawRangeElementsBaseVertexOES,
8604
          "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
8605
          "0x%016" PRIxPTR ", basevertex = %d",
8606
          CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
8607
          GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
8608

8609
    if (context)
8610
    {
8611
        PrimitiveMode modePacked                              = PackParam<PrimitiveMode>(mode);
8612
        DrawElementsType typePacked                           = PackParam<DrawElementsType>(type);
8613
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8614
        bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertexOES(
8615
                                                             context, modePacked, start, end, count,
8616
                                                             typePacked, indices, basevertex));
8617
        if (isCallValid)
8618
        {
8619
            context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
8620
                                                 basevertex);
8621
        }
8622
        ANGLE_CAPTURE(DrawRangeElementsBaseVertexOES, isCallValid, context, modePacked, start, end,
8623
                      count, typePacked, indices, basevertex);
8624
    }
8625
    else
8626
    {
8627
        GenerateContextLostErrorOnCurrentGlobalContext();
8628
    }
8629
}
8630

8631
// MultiDrawElementsBaseVertexEXT is already defined.
8632

8633
// GL_OES_draw_texture
8634
void GL_APIENTRY GL_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
8635
{
8636
    Context *context = GetValidGlobalContext();
8637
    EVENT(context, GLDrawTexfOES, "context = %d, x = %f, y = %f, z = %f, width = %f, height = %f",
8638
          CID(context), x, y, z, width, height);
8639

8640
    if (context)
8641
    {
8642
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8643
        bool isCallValid =
8644
            (context->skipValidation() || ValidateDrawTexfOES(context, x, y, z, width, height));
8645
        if (isCallValid)
8646
        {
8647
            context->drawTexf(x, y, z, width, height);
8648
        }
8649
        ANGLE_CAPTURE(DrawTexfOES, isCallValid, context, x, y, z, width, height);
8650
    }
8651
    else
8652
    {
8653
        GenerateContextLostErrorOnCurrentGlobalContext();
8654
    }
8655
}
8656

8657
void GL_APIENTRY GL_DrawTexfvOES(const GLfloat *coords)
8658
{
8659
    Context *context = GetValidGlobalContext();
8660
    EVENT(context, GLDrawTexfvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
8661
          (uintptr_t)coords);
8662

8663
    if (context)
8664
    {
8665
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8666
        bool isCallValid = (context->skipValidation() || ValidateDrawTexfvOES(context, coords));
8667
        if (isCallValid)
8668
        {
8669
            context->drawTexfv(coords);
8670
        }
8671
        ANGLE_CAPTURE(DrawTexfvOES, isCallValid, context, coords);
8672
    }
8673
    else
8674
    {
8675
        GenerateContextLostErrorOnCurrentGlobalContext();
8676
    }
8677
}
8678

8679
void GL_APIENTRY GL_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
8680
{
8681
    Context *context = GetValidGlobalContext();
8682
    EVENT(context, GLDrawTexiOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d",
8683
          CID(context), x, y, z, width, height);
8684

8685
    if (context)
8686
    {
8687
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8688
        bool isCallValid =
8689
            (context->skipValidation() || ValidateDrawTexiOES(context, x, y, z, width, height));
8690
        if (isCallValid)
8691
        {
8692
            context->drawTexi(x, y, z, width, height);
8693
        }
8694
        ANGLE_CAPTURE(DrawTexiOES, isCallValid, context, x, y, z, width, height);
8695
    }
8696
    else
8697
    {
8698
        GenerateContextLostErrorOnCurrentGlobalContext();
8699
    }
8700
}
8701

8702
void GL_APIENTRY GL_DrawTexivOES(const GLint *coords)
8703
{
8704
    Context *context = GetValidGlobalContext();
8705
    EVENT(context, GLDrawTexivOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
8706
          (uintptr_t)coords);
8707

8708
    if (context)
8709
    {
8710
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8711
        bool isCallValid = (context->skipValidation() || ValidateDrawTexivOES(context, coords));
8712
        if (isCallValid)
8713
        {
8714
            context->drawTexiv(coords);
8715
        }
8716
        ANGLE_CAPTURE(DrawTexivOES, isCallValid, context, coords);
8717
    }
8718
    else
8719
    {
8720
        GenerateContextLostErrorOnCurrentGlobalContext();
8721
    }
8722
}
8723

8724
void GL_APIENTRY GL_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
8725
{
8726
    Context *context = GetValidGlobalContext();
8727
    EVENT(context, GLDrawTexsOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d",
8728
          CID(context), x, y, z, width, height);
8729

8730
    if (context)
8731
    {
8732
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8733
        bool isCallValid =
8734
            (context->skipValidation() || ValidateDrawTexsOES(context, x, y, z, width, height));
8735
        if (isCallValid)
8736
        {
8737
            context->drawTexs(x, y, z, width, height);
8738
        }
8739
        ANGLE_CAPTURE(DrawTexsOES, isCallValid, context, x, y, z, width, height);
8740
    }
8741
    else
8742
    {
8743
        GenerateContextLostErrorOnCurrentGlobalContext();
8744
    }
8745
}
8746

8747
void GL_APIENTRY GL_DrawTexsvOES(const GLshort *coords)
8748
{
8749
    Context *context = GetValidGlobalContext();
8750
    EVENT(context, GLDrawTexsvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
8751
          (uintptr_t)coords);
8752

8753
    if (context)
8754
    {
8755
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8756
        bool isCallValid = (context->skipValidation() || ValidateDrawTexsvOES(context, coords));
8757
        if (isCallValid)
8758
        {
8759
            context->drawTexsv(coords);
8760
        }
8761
        ANGLE_CAPTURE(DrawTexsvOES, isCallValid, context, coords);
8762
    }
8763
    else
8764
    {
8765
        GenerateContextLostErrorOnCurrentGlobalContext();
8766
    }
8767
}
8768

8769
void GL_APIENTRY GL_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
8770
{
8771
    Context *context = GetValidGlobalContext();
8772
    EVENT(context, GLDrawTexxOES,
8773
          "context = %d, x = 0x%X, y = 0x%X, z = 0x%X, width = 0x%X, height = 0x%X", CID(context),
8774
          x, y, z, width, height);
8775

8776
    if (context)
8777
    {
8778
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8779
        bool isCallValid =
8780
            (context->skipValidation() || ValidateDrawTexxOES(context, x, y, z, width, height));
8781
        if (isCallValid)
8782
        {
8783
            context->drawTexx(x, y, z, width, height);
8784
        }
8785
        ANGLE_CAPTURE(DrawTexxOES, isCallValid, context, x, y, z, width, height);
8786
    }
8787
    else
8788
    {
8789
        GenerateContextLostErrorOnCurrentGlobalContext();
8790
    }
8791
}
8792

8793
void GL_APIENTRY GL_DrawTexxvOES(const GLfixed *coords)
8794
{
8795
    Context *context = GetValidGlobalContext();
8796
    EVENT(context, GLDrawTexxvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
8797
          (uintptr_t)coords);
8798

8799
    if (context)
8800
    {
8801
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8802
        bool isCallValid = (context->skipValidation() || ValidateDrawTexxvOES(context, coords));
8803
        if (isCallValid)
8804
        {
8805
            context->drawTexxv(coords);
8806
        }
8807
        ANGLE_CAPTURE(DrawTexxvOES, isCallValid, context, coords);
8808
    }
8809
    else
8810
    {
8811
        GenerateContextLostErrorOnCurrentGlobalContext();
8812
    }
8813
}
8814

8815
// GL_OES_framebuffer_object
8816
void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer)
8817
{
8818
    Context *context = GetValidGlobalContext();
8819
    EVENT(context, GLBindFramebufferOES, "context = %d, target = %s, framebuffer = %u",
8820
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer);
8821

8822
    if (context)
8823
    {
8824
        FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
8825
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8826
        bool isCallValid                                      = (context->skipValidation() ||
8827
                            ValidateBindFramebufferOES(context, target, framebufferPacked));
8828
        if (isCallValid)
8829
        {
8830
            context->bindFramebuffer(target, framebufferPacked);
8831
        }
8832
        ANGLE_CAPTURE(BindFramebufferOES, isCallValid, context, target, framebufferPacked);
8833
    }
8834
    else
8835
    {
8836
        GenerateContextLostErrorOnCurrentGlobalContext();
8837
    }
8838
}
8839

8840
void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer)
8841
{
8842
    Context *context = GetValidGlobalContext();
8843
    EVENT(context, GLBindRenderbufferOES, "context = %d, target = %s, renderbuffer = %u",
8844
          CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer);
8845

8846
    if (context)
8847
    {
8848
        RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
8849
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8850
        bool isCallValid                                      = (context->skipValidation() ||
8851
                            ValidateBindRenderbufferOES(context, target, renderbufferPacked));
8852
        if (isCallValid)
8853
        {
8854
            context->bindRenderbuffer(target, renderbufferPacked);
8855
        }
8856
        ANGLE_CAPTURE(BindRenderbufferOES, isCallValid, context, target, renderbufferPacked);
8857
    }
8858
    else
8859
    {
8860
        GenerateContextLostErrorOnCurrentGlobalContext();
8861
    }
8862
}
8863

8864
GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target)
8865
{
8866
    Context *context = GetValidGlobalContext();
8867
    EVENT(context, GLCheckFramebufferStatusOES, "context = %d, target = %s", CID(context),
8868
          GLenumToString(GLenumGroup::FramebufferTarget, target));
8869

8870
    GLenum returnValue;
8871
    if (context)
8872
    {
8873
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8874
        bool isCallValid =
8875
            (context->skipValidation() || ValidateCheckFramebufferStatusOES(context, target));
8876
        if (isCallValid)
8877
        {
8878
            returnValue = context->checkFramebufferStatus(target);
8879
        }
8880
        else
8881
        {
8882
            returnValue =
8883
                GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>();
8884
        }
8885
        ANGLE_CAPTURE(CheckFramebufferStatusOES, isCallValid, context, target, returnValue);
8886
    }
8887
    else
8888
    {
8889
        GenerateContextLostErrorOnCurrentGlobalContext();
8890
        returnValue =
8891
            GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>();
8892
    }
8893
    return returnValue;
8894
}
8895

8896
void GL_APIENTRY GL_DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
8897
{
8898
    Context *context = GetValidGlobalContext();
8899
    EVENT(context, GLDeleteFramebuffersOES,
8900
          "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "", CID(context), n,
8901
          (uintptr_t)framebuffers);
8902

8903
    if (context)
8904
    {
8905
        const FramebufferID *framebuffersPacked = PackParam<const FramebufferID *>(framebuffers);
8906
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8907
        bool isCallValid                                      = (context->skipValidation() ||
8908
                            ValidateDeleteFramebuffersOES(context, n, framebuffersPacked));
8909
        if (isCallValid)
8910
        {
8911
            context->deleteFramebuffers(n, framebuffersPacked);
8912
        }
8913
        ANGLE_CAPTURE(DeleteFramebuffersOES, isCallValid, context, n, framebuffersPacked);
8914
    }
8915
    else
8916
    {
8917
        GenerateContextLostErrorOnCurrentGlobalContext();
8918
    }
8919
}
8920

8921
void GL_APIENTRY GL_DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
8922
{
8923
    Context *context = GetValidGlobalContext();
8924
    EVENT(context, GLDeleteRenderbuffersOES,
8925
          "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "", CID(context), n,
8926
          (uintptr_t)renderbuffers);
8927

8928
    if (context)
8929
    {
8930
        const RenderbufferID *renderbuffersPacked =
8931
            PackParam<const RenderbufferID *>(renderbuffers);
8932
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8933
        bool isCallValid                                      = (context->skipValidation() ||
8934
                            ValidateDeleteRenderbuffersOES(context, n, renderbuffersPacked));
8935
        if (isCallValid)
8936
        {
8937
            context->deleteRenderbuffers(n, renderbuffersPacked);
8938
        }
8939
        ANGLE_CAPTURE(DeleteRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
8940
    }
8941
    else
8942
    {
8943
        GenerateContextLostErrorOnCurrentGlobalContext();
8944
    }
8945
}
8946

8947
void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target,
8948
                                               GLenum attachment,
8949
                                               GLenum renderbuffertarget,
8950
                                               GLuint renderbuffer)
8951
{
8952
    Context *context = GetValidGlobalContext();
8953
    EVENT(context, GLFramebufferRenderbufferOES,
8954
          "context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u",
8955
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
8956
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
8957
          GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer);
8958

8959
    if (context)
8960
    {
8961
        RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
8962
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8963
        bool isCallValid =
8964
            (context->skipValidation() ||
8965
             ValidateFramebufferRenderbufferOES(context, target, attachment, renderbuffertarget,
8966
                                                renderbufferPacked));
8967
        if (isCallValid)
8968
        {
8969
            context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
8970
                                             renderbufferPacked);
8971
        }
8972
        ANGLE_CAPTURE(FramebufferRenderbufferOES, isCallValid, context, target, attachment,
8973
                      renderbuffertarget, renderbufferPacked);
8974
    }
8975
    else
8976
    {
8977
        GenerateContextLostErrorOnCurrentGlobalContext();
8978
    }
8979
}
8980

8981
void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target,
8982
                                            GLenum attachment,
8983
                                            GLenum textarget,
8984
                                            GLuint texture,
8985
                                            GLint level)
8986
{
8987
    Context *context = GetValidGlobalContext();
8988
    EVENT(context, GLFramebufferTexture2DOES,
8989
          "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
8990
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
8991
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
8992
          GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
8993

8994
    if (context)
8995
    {
8996
        TextureTarget textargetPacked                         = PackParam<TextureTarget>(textarget);
8997
        TextureID texturePacked                               = PackParam<TextureID>(texture);
8998
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8999
        bool isCallValid                                      = (context->skipValidation() ||
9000
                            ValidateFramebufferTexture2DOES(context, target, attachment,
9001
                                                            textargetPacked, texturePacked, level));
9002
        if (isCallValid)
9003
        {
9004
            context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
9005
                                          level);
9006
        }
9007
        ANGLE_CAPTURE(FramebufferTexture2DOES, isCallValid, context, target, attachment,
9008
                      textargetPacked, texturePacked, level);
9009
    }
9010
    else
9011
    {
9012
        GenerateContextLostErrorOnCurrentGlobalContext();
9013
    }
9014
}
9015

9016
void GL_APIENTRY GL_GenFramebuffersOES(GLsizei n, GLuint *framebuffers)
9017
{
9018
    Context *context = GetValidGlobalContext();
9019
    EVENT(context, GLGenFramebuffersOES, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
9020
          CID(context), n, (uintptr_t)framebuffers);
9021

9022
    if (context)
9023
    {
9024
        FramebufferID *framebuffersPacked = PackParam<FramebufferID *>(framebuffers);
9025
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9026
        bool isCallValid                                      = (context->skipValidation() ||
9027
                            ValidateGenFramebuffersOES(context, n, framebuffersPacked));
9028
        if (isCallValid)
9029
        {
9030
            context->genFramebuffers(n, framebuffersPacked);
9031
        }
9032
        ANGLE_CAPTURE(GenFramebuffersOES, isCallValid, context, n, framebuffersPacked);
9033
    }
9034
    else
9035
    {
9036
        GenerateContextLostErrorOnCurrentGlobalContext();
9037
    }
9038
}
9039

9040
void GL_APIENTRY GL_GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
9041
{
9042
    Context *context = GetValidGlobalContext();
9043
    EVENT(context, GLGenRenderbuffersOES, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
9044
          CID(context), n, (uintptr_t)renderbuffers);
9045

9046
    if (context)
9047
    {
9048
        RenderbufferID *renderbuffersPacked = PackParam<RenderbufferID *>(renderbuffers);
9049
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9050
        bool isCallValid                                      = (context->skipValidation() ||
9051
                            ValidateGenRenderbuffersOES(context, n, renderbuffersPacked));
9052
        if (isCallValid)
9053
        {
9054
            context->genRenderbuffers(n, renderbuffersPacked);
9055
        }
9056
        ANGLE_CAPTURE(GenRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
9057
    }
9058
    else
9059
    {
9060
        GenerateContextLostErrorOnCurrentGlobalContext();
9061
    }
9062
}
9063

9064
void GL_APIENTRY GL_GenerateMipmapOES(GLenum target)
9065
{
9066
    Context *context = GetValidGlobalContext();
9067
    EVENT(context, GLGenerateMipmapOES, "context = %d, target = %s", CID(context),
9068
          GLenumToString(GLenumGroup::TextureTarget, target));
9069

9070
    if (context)
9071
    {
9072
        TextureType targetPacked                              = PackParam<TextureType>(target);
9073
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9074
        bool isCallValid =
9075
            (context->skipValidation() || ValidateGenerateMipmapOES(context, targetPacked));
9076
        if (isCallValid)
9077
        {
9078
            context->generateMipmap(targetPacked);
9079
        }
9080
        ANGLE_CAPTURE(GenerateMipmapOES, isCallValid, context, targetPacked);
9081
    }
9082
    else
9083
    {
9084
        GenerateContextLostErrorOnCurrentGlobalContext();
9085
    }
9086
}
9087

9088
void GL_APIENTRY GL_GetFramebufferAttachmentParameterivOES(GLenum target,
9089
                                                           GLenum attachment,
9090
                                                           GLenum pname,
9091
                                                           GLint *params)
9092
{
9093
    Context *context = GetValidGlobalContext();
9094
    EVENT(context, GLGetFramebufferAttachmentParameterivOES,
9095
          "context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "",
9096
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
9097
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
9098
          GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
9099
          (uintptr_t)params);
9100

9101
    if (context)
9102
    {
9103
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9104
        bool isCallValid =
9105
            (context->skipValidation() || ValidateGetFramebufferAttachmentParameterivOES(
9106
                                              context, target, attachment, pname, params));
9107
        if (isCallValid)
9108
        {
9109
            context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
9110
        }
9111
        ANGLE_CAPTURE(GetFramebufferAttachmentParameterivOES, isCallValid, context, target,
9112
                      attachment, pname, params);
9113
    }
9114
    else
9115
    {
9116
        GenerateContextLostErrorOnCurrentGlobalContext();
9117
    }
9118
}
9119

9120
void GL_APIENTRY GL_GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
9121
{
9122
    Context *context = GetValidGlobalContext();
9123
    EVENT(context, GLGetRenderbufferParameterivOES,
9124
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9125
          GLenumToString(GLenumGroup::RenderbufferTarget, target),
9126
          GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params);
9127

9128
    if (context)
9129
    {
9130
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9131
        bool isCallValid                                      = (context->skipValidation() ||
9132
                            ValidateGetRenderbufferParameterivOES(context, target, pname, params));
9133
        if (isCallValid)
9134
        {
9135
            context->getRenderbufferParameteriv(target, pname, params);
9136
        }
9137
        ANGLE_CAPTURE(GetRenderbufferParameterivOES, isCallValid, context, target, pname, params);
9138
    }
9139
    else
9140
    {
9141
        GenerateContextLostErrorOnCurrentGlobalContext();
9142
    }
9143
}
9144

9145
GLboolean GL_APIENTRY GL_IsFramebufferOES(GLuint framebuffer)
9146
{
9147
    Context *context = GetValidGlobalContext();
9148
    EVENT(context, GLIsFramebufferOES, "context = %d, framebuffer = %u", CID(context), framebuffer);
9149

9150
    GLboolean returnValue;
9151
    if (context)
9152
    {
9153
        FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
9154
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9155
        bool isCallValid =
9156
            (context->skipValidation() || ValidateIsFramebufferOES(context, framebufferPacked));
9157
        if (isCallValid)
9158
        {
9159
            returnValue = context->isFramebuffer(framebufferPacked);
9160
        }
9161
        else
9162
        {
9163
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>();
9164
        }
9165
        ANGLE_CAPTURE(IsFramebufferOES, isCallValid, context, framebufferPacked, returnValue);
9166
    }
9167
    else
9168
    {
9169
        GenerateContextLostErrorOnCurrentGlobalContext();
9170
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>();
9171
    }
9172
    return returnValue;
9173
}
9174

9175
GLboolean GL_APIENTRY GL_IsRenderbufferOES(GLuint renderbuffer)
9176
{
9177
    Context *context = GetValidGlobalContext();
9178
    EVENT(context, GLIsRenderbufferOES, "context = %d, renderbuffer = %u", CID(context),
9179
          renderbuffer);
9180

9181
    GLboolean returnValue;
9182
    if (context)
9183
    {
9184
        RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
9185
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9186
        bool isCallValid =
9187
            (context->skipValidation() || ValidateIsRenderbufferOES(context, renderbufferPacked));
9188
        if (isCallValid)
9189
        {
9190
            returnValue = context->isRenderbuffer(renderbufferPacked);
9191
        }
9192
        else
9193
        {
9194
            returnValue =
9195
                GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>();
9196
        }
9197
        ANGLE_CAPTURE(IsRenderbufferOES, isCallValid, context, renderbufferPacked, returnValue);
9198
    }
9199
    else
9200
    {
9201
        GenerateContextLostErrorOnCurrentGlobalContext();
9202
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>();
9203
    }
9204
    return returnValue;
9205
}
9206

9207
void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target,
9208
                                           GLenum internalformat,
9209
                                           GLsizei width,
9210
                                           GLsizei height)
9211
{
9212
    Context *context = GetValidGlobalContext();
9213
    EVENT(context, GLRenderbufferStorageOES,
9214
          "context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context),
9215
          GLenumToString(GLenumGroup::RenderbufferTarget, target),
9216
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
9217

9218
    if (context)
9219
    {
9220
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9221
        bool isCallValid =
9222
            (context->skipValidation() ||
9223
             ValidateRenderbufferStorageOES(context, target, internalformat, width, height));
9224
        if (isCallValid)
9225
        {
9226
            context->renderbufferStorage(target, internalformat, width, height);
9227
        }
9228
        ANGLE_CAPTURE(RenderbufferStorageOES, isCallValid, context, target, internalformat, width,
9229
                      height);
9230
    }
9231
    else
9232
    {
9233
        GenerateContextLostErrorOnCurrentGlobalContext();
9234
    }
9235
}
9236

9237
// GL_OES_geometry_shader
9238
void GL_APIENTRY GL_FramebufferTextureOES(GLenum target,
9239
                                          GLenum attachment,
9240
                                          GLuint texture,
9241
                                          GLint level)
9242
{
9243
    Context *context = GetValidGlobalContext();
9244
    EVENT(context, GLFramebufferTextureOES,
9245
          "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context),
9246
          GLenumToString(GLenumGroup::FramebufferTarget, target),
9247
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
9248

9249
    if (context)
9250
    {
9251
        TextureID texturePacked                               = PackParam<TextureID>(texture);
9252
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9253
        bool isCallValid =
9254
            (context->skipValidation() ||
9255
             ValidateFramebufferTextureOES(context, target, attachment, texturePacked, level));
9256
        if (isCallValid)
9257
        {
9258
            context->framebufferTexture(target, attachment, texturePacked, level);
9259
        }
9260
        ANGLE_CAPTURE(FramebufferTextureOES, isCallValid, context, target, attachment,
9261
                      texturePacked, level);
9262
    }
9263
    else
9264
    {
9265
        GenerateContextLostErrorOnCurrentGlobalContext();
9266
    }
9267
}
9268

9269
// GL_OES_get_program_binary
9270
void GL_APIENTRY GL_GetProgramBinaryOES(GLuint program,
9271
                                        GLsizei bufSize,
9272
                                        GLsizei *length,
9273
                                        GLenum *binaryFormat,
9274
                                        void *binary)
9275
{
9276
    Context *context = GetValidGlobalContext();
9277
    EVENT(context, GLGetProgramBinaryOES,
9278
          "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
9279
          ", binaryFormat = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR "",
9280
          CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
9281
          (uintptr_t)binary);
9282

9283
    if (context)
9284
    {
9285
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
9286
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9287
        bool isCallValid                                      = (context->skipValidation() ||
9288
                            ValidateGetProgramBinaryOES(context, programPacked, bufSize, length,
9289
                                                        binaryFormat, binary));
9290
        if (isCallValid)
9291
        {
9292
            context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
9293
        }
9294
        ANGLE_CAPTURE(GetProgramBinaryOES, isCallValid, context, programPacked, bufSize, length,
9295
                      binaryFormat, binary);
9296
    }
9297
    else
9298
    {
9299
        GenerateContextLostErrorOnCurrentGlobalContext();
9300
    }
9301
}
9302

9303
void GL_APIENTRY GL_ProgramBinaryOES(GLuint program,
9304
                                     GLenum binaryFormat,
9305
                                     const void *binary,
9306
                                     GLint length)
9307
{
9308
    Context *context = GetValidGlobalContext();
9309
    EVENT(context, GLProgramBinaryOES,
9310
          "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d",
9311
          CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat),
9312
          (uintptr_t)binary, length);
9313

9314
    if (context)
9315
    {
9316
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
9317
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9318
        bool isCallValid =
9319
            (context->skipValidation() ||
9320
             ValidateProgramBinaryOES(context, programPacked, binaryFormat, binary, length));
9321
        if (isCallValid)
9322
        {
9323
            context->programBinary(programPacked, binaryFormat, binary, length);
9324
        }
9325
        ANGLE_CAPTURE(ProgramBinaryOES, isCallValid, context, programPacked, binaryFormat, binary,
9326
                      length);
9327
    }
9328
    else
9329
    {
9330
        GenerateContextLostErrorOnCurrentGlobalContext();
9331
    }
9332
}
9333

9334
// GL_OES_mapbuffer
9335
void GL_APIENTRY GL_GetBufferPointervOES(GLenum target, GLenum pname, void **params)
9336
{
9337
    Context *context = GetValidGlobalContext();
9338
    EVENT(context, GLGetBufferPointervOES,
9339
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9340
          GLenumToString(GLenumGroup::BufferTargetARB, target),
9341
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
9342

9343
    if (context)
9344
    {
9345
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
9346
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9347
        bool isCallValid                                      = (context->skipValidation() ||
9348
                            ValidateGetBufferPointervOES(context, targetPacked, pname, params));
9349
        if (isCallValid)
9350
        {
9351
            context->getBufferPointerv(targetPacked, pname, params);
9352
        }
9353
        ANGLE_CAPTURE(GetBufferPointervOES, isCallValid, context, targetPacked, pname, params);
9354
    }
9355
    else
9356
    {
9357
        GenerateContextLostErrorOnCurrentGlobalContext();
9358
    }
9359
}
9360

9361
void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access)
9362
{
9363
    Context *context = GetValidGlobalContext();
9364
    EVENT(context, GLMapBufferOES, "context = %d, target = %s, access = %s", CID(context),
9365
          GLenumToString(GLenumGroup::BufferTargetARB, target),
9366
          GLenumToString(GLenumGroup::BufferAccessARB, access));
9367

9368
    void *returnValue;
9369
    if (context)
9370
    {
9371
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
9372
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9373
        bool isCallValid =
9374
            (context->skipValidation() || ValidateMapBufferOES(context, targetPacked, access));
9375
        if (isCallValid)
9376
        {
9377
            returnValue = context->mapBuffer(targetPacked, access);
9378
        }
9379
        else
9380
        {
9381
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>();
9382
        }
9383
        ANGLE_CAPTURE(MapBufferOES, isCallValid, context, targetPacked, access, returnValue);
9384
    }
9385
    else
9386
    {
9387
        GenerateContextLostErrorOnCurrentGlobalContext();
9388
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>();
9389
    }
9390
    return returnValue;
9391
}
9392

9393
GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target)
9394
{
9395
    Context *context = GetValidGlobalContext();
9396
    EVENT(context, GLUnmapBufferOES, "context = %d, target = %s", CID(context),
9397
          GLenumToString(GLenumGroup::DefaultGroup, target));
9398

9399
    GLboolean returnValue;
9400
    if (context)
9401
    {
9402
        BufferBinding targetPacked                            = PackParam<BufferBinding>(target);
9403
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9404
        bool isCallValid =
9405
            (context->skipValidation() || ValidateUnmapBufferOES(context, targetPacked));
9406
        if (isCallValid)
9407
        {
9408
            returnValue = context->unmapBuffer(targetPacked);
9409
        }
9410
        else
9411
        {
9412
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>();
9413
        }
9414
        ANGLE_CAPTURE(UnmapBufferOES, isCallValid, context, targetPacked, returnValue);
9415
    }
9416
    else
9417
    {
9418
        GenerateContextLostErrorOnCurrentGlobalContext();
9419
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>();
9420
    }
9421
    return returnValue;
9422
}
9423

9424
// GL_OES_matrix_palette
9425
void GL_APIENTRY GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex)
9426
{
9427
    Context *context = GetValidGlobalContext();
9428
    EVENT(context, GLCurrentPaletteMatrixOES, "context = %d, matrixpaletteindex = %u", CID(context),
9429
          matrixpaletteindex);
9430

9431
    if (context)
9432
    {
9433
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9434
        bool isCallValid                                      = (context->skipValidation() ||
9435
                            ValidateCurrentPaletteMatrixOES(context, matrixpaletteindex));
9436
        if (isCallValid)
9437
        {
9438
            context->currentPaletteMatrix(matrixpaletteindex);
9439
        }
9440
        ANGLE_CAPTURE(CurrentPaletteMatrixOES, isCallValid, context, matrixpaletteindex);
9441
    }
9442
    else
9443
    {
9444
        GenerateContextLostErrorOnCurrentGlobalContext();
9445
    }
9446
}
9447

9448
void GL_APIENTRY GL_LoadPaletteFromModelViewMatrixOES()
9449
{
9450
    Context *context = GetValidGlobalContext();
9451
    EVENT(context, GLLoadPaletteFromModelViewMatrixOES, "context = %d", CID(context));
9452

9453
    if (context)
9454
    {
9455
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9456
        bool isCallValid =
9457
            (context->skipValidation() || ValidateLoadPaletteFromModelViewMatrixOES(context));
9458
        if (isCallValid)
9459
        {
9460
            context->loadPaletteFromModelViewMatrix();
9461
        }
9462
        ANGLE_CAPTURE(LoadPaletteFromModelViewMatrixOES, isCallValid, context);
9463
    }
9464
    else
9465
    {
9466
        GenerateContextLostErrorOnCurrentGlobalContext();
9467
    }
9468
}
9469

9470
void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size,
9471
                                          GLenum type,
9472
                                          GLsizei stride,
9473
                                          const void *pointer)
9474
{
9475
    Context *context = GetValidGlobalContext();
9476
    EVENT(context, GLMatrixIndexPointerOES,
9477
          "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
9478
          CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
9479
          (uintptr_t)pointer);
9480

9481
    if (context)
9482
    {
9483
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9484
        bool isCallValid                                      = (context->skipValidation() ||
9485
                            ValidateMatrixIndexPointerOES(context, size, type, stride, pointer));
9486
        if (isCallValid)
9487
        {
9488
            context->matrixIndexPointer(size, type, stride, pointer);
9489
        }
9490
        ANGLE_CAPTURE(MatrixIndexPointerOES, isCallValid, context, size, type, stride, pointer);
9491
    }
9492
    else
9493
    {
9494
        GenerateContextLostErrorOnCurrentGlobalContext();
9495
    }
9496
}
9497

9498
void GL_APIENTRY GL_WeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
9499
{
9500
    Context *context = GetValidGlobalContext();
9501
    EVENT(context, GLWeightPointerOES,
9502
          "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
9503
          CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
9504
          (uintptr_t)pointer);
9505

9506
    if (context)
9507
    {
9508
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9509
        bool isCallValid                                      = (context->skipValidation() ||
9510
                            ValidateWeightPointerOES(context, size, type, stride, pointer));
9511
        if (isCallValid)
9512
        {
9513
            context->weightPointer(size, type, stride, pointer);
9514
        }
9515
        ANGLE_CAPTURE(WeightPointerOES, isCallValid, context, size, type, stride, pointer);
9516
    }
9517
    else
9518
    {
9519
        GenerateContextLostErrorOnCurrentGlobalContext();
9520
    }
9521
}
9522

9523
// GL_OES_point_size_array
9524
void GL_APIENTRY GL_PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
9525
{
9526
    Context *context = GetValidGlobalContext();
9527
    EVENT(context, GLPointSizePointerOES,
9528
          "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
9529
          GLenumToString(GLenumGroup::DefaultGroup, type), stride, (uintptr_t)pointer);
9530

9531
    if (context)
9532
    {
9533
        VertexAttribType typePacked                           = PackParam<VertexAttribType>(type);
9534
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9535
        bool isCallValid                                      = (context->skipValidation() ||
9536
                            ValidatePointSizePointerOES(context, typePacked, stride, pointer));
9537
        if (isCallValid)
9538
        {
9539
            context->pointSizePointer(typePacked, stride, pointer);
9540
        }
9541
        ANGLE_CAPTURE(PointSizePointerOES, isCallValid, context, typePacked, stride, pointer);
9542
    }
9543
    else
9544
    {
9545
        GenerateContextLostErrorOnCurrentGlobalContext();
9546
    }
9547
}
9548

9549
// GL_OES_query_matrix
9550
GLbitfield GL_APIENTRY GL_QueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
9551
{
9552
    Context *context = GetValidGlobalContext();
9553
    EVENT(context, GLQueryMatrixxOES,
9554
          "context = %d, mantissa = 0x%016" PRIxPTR ", exponent = 0x%016" PRIxPTR "", CID(context),
9555
          (uintptr_t)mantissa, (uintptr_t)exponent);
9556

9557
    GLbitfield returnValue;
9558
    if (context)
9559
    {
9560
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9561
        bool isCallValid =
9562
            (context->skipValidation() || ValidateQueryMatrixxOES(context, mantissa, exponent));
9563
        if (isCallValid)
9564
        {
9565
            returnValue = context->queryMatrixx(mantissa, exponent);
9566
        }
9567
        else
9568
        {
9569
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>();
9570
        }
9571
        ANGLE_CAPTURE(QueryMatrixxOES, isCallValid, context, mantissa, exponent, returnValue);
9572
    }
9573
    else
9574
    {
9575
        GenerateContextLostErrorOnCurrentGlobalContext();
9576
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>();
9577
    }
9578
    return returnValue;
9579
}
9580

9581
// GL_OES_sample_shading
9582
void GL_APIENTRY GL_MinSampleShadingOES(GLfloat value)
9583
{
9584
    Context *context = GetValidGlobalContext();
9585
    EVENT(context, GLMinSampleShadingOES, "context = %d, value = %f", CID(context), value);
9586

9587
    if (context)
9588
    {
9589
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9590
        bool isCallValid =
9591
            (context->skipValidation() || ValidateMinSampleShadingOES(context, value));
9592
        if (isCallValid)
9593
        {
9594
            context->minSampleShading(value);
9595
        }
9596
        ANGLE_CAPTURE(MinSampleShadingOES, isCallValid, context, value);
9597
    }
9598
    else
9599
    {
9600
        GenerateContextLostErrorOnCurrentGlobalContext();
9601
    }
9602
}
9603

9604
// GL_OES_shader_io_blocks
9605

9606
// GL_OES_texture_3D
9607
void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target,
9608
                                            GLint level,
9609
                                            GLenum internalformat,
9610
                                            GLsizei width,
9611
                                            GLsizei height,
9612
                                            GLsizei depth,
9613
                                            GLint border,
9614
                                            GLsizei imageSize,
9615
                                            const void *data)
9616
{
9617
    Context *context = GetValidGlobalContext();
9618
    EVENT(context, GLCompressedTexImage3DOES,
9619
          "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
9620
          "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "",
9621
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
9622
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
9623
          imageSize, (uintptr_t)data);
9624

9625
    if (context)
9626
    {
9627
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
9628
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9629
        bool isCallValid =
9630
            (context->skipValidation() ||
9631
             ValidateCompressedTexImage3DOES(context, targetPacked, level, internalformat, width,
9632
                                             height, depth, border, imageSize, data));
9633
        if (isCallValid)
9634
        {
9635
            context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
9636
                                          border, imageSize, data);
9637
        }
9638
        ANGLE_CAPTURE(CompressedTexImage3DOES, isCallValid, context, targetPacked, level,
9639
                      internalformat, width, height, depth, border, imageSize, data);
9640
    }
9641
    else
9642
    {
9643
        GenerateContextLostErrorOnCurrentGlobalContext();
9644
    }
9645
}
9646

9647
void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target,
9648
                                               GLint level,
9649
                                               GLint xoffset,
9650
                                               GLint yoffset,
9651
                                               GLint zoffset,
9652
                                               GLsizei width,
9653
                                               GLsizei height,
9654
                                               GLsizei depth,
9655
                                               GLenum format,
9656
                                               GLsizei imageSize,
9657
                                               const void *data)
9658
{
9659
    Context *context = GetValidGlobalContext();
9660
    EVENT(context, GLCompressedTexSubImage3DOES,
9661
          "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
9662
          "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "",
9663
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9664
          zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
9665
          imageSize, (uintptr_t)data);
9666

9667
    if (context)
9668
    {
9669
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
9670
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9671
        bool isCallValid                                      = (context->skipValidation() ||
9672
                            ValidateCompressedTexSubImage3DOES(
9673
                                context, targetPacked, level, xoffset, yoffset, zoffset, width,
9674
                                height, depth, format, imageSize, data));
9675
        if (isCallValid)
9676
        {
9677
            context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
9678
                                             height, depth, format, imageSize, data);
9679
        }
9680
        ANGLE_CAPTURE(CompressedTexSubImage3DOES, isCallValid, context, targetPacked, level,
9681
                      xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
9682
    }
9683
    else
9684
    {
9685
        GenerateContextLostErrorOnCurrentGlobalContext();
9686
    }
9687
}
9688

9689
void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target,
9690
                                         GLint level,
9691
                                         GLint xoffset,
9692
                                         GLint yoffset,
9693
                                         GLint zoffset,
9694
                                         GLint x,
9695
                                         GLint y,
9696
                                         GLsizei width,
9697
                                         GLsizei height)
9698
{
9699
    Context *context = GetValidGlobalContext();
9700
    EVENT(context, GLCopyTexSubImage3DOES,
9701
          "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = "
9702
          "%d, y = %d, width = %d, height = %d",
9703
          CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
9704
          zoffset, x, y, width, height);
9705

9706
    if (context)
9707
    {
9708
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
9709
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9710
        bool isCallValid                                      = (context->skipValidation() ||
9711
                            ValidateCopyTexSubImage3DOES(context, targetPacked, level, xoffset,
9712
                                                         yoffset, zoffset, x, y, width, height));
9713
        if (isCallValid)
9714
        {
9715
            context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
9716
                                       height);
9717
        }
9718
        ANGLE_CAPTURE(CopyTexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset,
9719
                      yoffset, zoffset, x, y, width, height);
9720
    }
9721
    else
9722
    {
9723
        GenerateContextLostErrorOnCurrentGlobalContext();
9724
    }
9725
}
9726

9727
void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target,
9728
                                            GLenum attachment,
9729
                                            GLenum textarget,
9730
                                            GLuint texture,
9731
                                            GLint level,
9732
                                            GLint zoffset)
9733
{
9734
    Context *context = GetValidGlobalContext();
9735
    EVENT(context, GLFramebufferTexture3DOES,
9736
          "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
9737
          "zoffset = %d",
9738
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
9739
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
9740
          GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset);
9741

9742
    if (context)
9743
    {
9744
        TextureTarget textargetPacked                         = PackParam<TextureTarget>(textarget);
9745
        TextureID texturePacked                               = PackParam<TextureID>(texture);
9746
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9747
        bool isCallValid =
9748
            (context->skipValidation() ||
9749
             ValidateFramebufferTexture3DOES(context, target, attachment, textargetPacked,
9750
                                             texturePacked, level, zoffset));
9751
        if (isCallValid)
9752
        {
9753
            context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
9754
                                          zoffset);
9755
        }
9756
        ANGLE_CAPTURE(FramebufferTexture3DOES, isCallValid, context, target, attachment,
9757
                      textargetPacked, texturePacked, level, zoffset);
9758
    }
9759
    else
9760
    {
9761
        GenerateContextLostErrorOnCurrentGlobalContext();
9762
    }
9763
}
9764

9765
void GL_APIENTRY GL_TexImage3DOES(GLenum target,
9766
                                  GLint level,
9767
                                  GLenum internalformat,
9768
                                  GLsizei width,
9769
                                  GLsizei height,
9770
                                  GLsizei depth,
9771
                                  GLint border,
9772
                                  GLenum format,
9773
                                  GLenum type,
9774
                                  const void *pixels)
9775
{
9776
    Context *context = GetValidGlobalContext();
9777
    EVENT(context, GLTexImage3DOES,
9778
          "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
9779
          "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
9780
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
9781
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
9782
          GLenumToString(GLenumGroup::PixelFormat, format),
9783
          GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
9784

9785
    if (context)
9786
    {
9787
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
9788
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9789
        bool isCallValid =
9790
            (context->skipValidation() ||
9791
             ValidateTexImage3DOES(context, targetPacked, level, internalformat, width, height,
9792
                                   depth, border, format, type, pixels));
9793
        if (isCallValid)
9794
        {
9795
            context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
9796
                                format, type, pixels);
9797
        }
9798
        ANGLE_CAPTURE(TexImage3DOES, isCallValid, context, targetPacked, level, internalformat,
9799
                      width, height, depth, border, format, type, pixels);
9800
    }
9801
    else
9802
    {
9803
        GenerateContextLostErrorOnCurrentGlobalContext();
9804
    }
9805
}
9806

9807
void GL_APIENTRY GL_TexSubImage3DOES(GLenum target,
9808
                                     GLint level,
9809
                                     GLint xoffset,
9810
                                     GLint yoffset,
9811
                                     GLint zoffset,
9812
                                     GLsizei width,
9813
                                     GLsizei height,
9814
                                     GLsizei depth,
9815
                                     GLenum format,
9816
                                     GLenum type,
9817
                                     const void *pixels)
9818
{
9819
    Context *context = GetValidGlobalContext();
9820
    EVENT(context, GLTexSubImage3DOES,
9821
          "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
9822
          "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
9823
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9824
          zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
9825
          GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
9826

9827
    if (context)
9828
    {
9829
        TextureTarget targetPacked                            = PackParam<TextureTarget>(target);
9830
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9831
        bool isCallValid =
9832
            (context->skipValidation() ||
9833
             ValidateTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset,
9834
                                      width, height, depth, format, type, pixels));
9835
        if (isCallValid)
9836
        {
9837
            context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
9838
                                   depth, format, type, pixels);
9839
        }
9840
        ANGLE_CAPTURE(TexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset, yoffset,
9841
                      zoffset, width, height, depth, format, type, pixels);
9842
    }
9843
    else
9844
    {
9845
        GenerateContextLostErrorOnCurrentGlobalContext();
9846
    }
9847
}
9848

9849
// GL_OES_texture_border_clamp
9850
void GL_APIENTRY GL_GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
9851
{
9852
    Context *context = GetValidGlobalContext();
9853
    EVENT(context, GLGetSamplerParameterIivOES,
9854
          "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9855
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
9856

9857
    if (context)
9858
    {
9859
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
9860
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9861
        bool isCallValid =
9862
            (context->skipValidation() ||
9863
             ValidateGetSamplerParameterIivOES(context, samplerPacked, pname, params));
9864
        if (isCallValid)
9865
        {
9866
            context->getSamplerParameterIiv(samplerPacked, pname, params);
9867
        }
9868
        ANGLE_CAPTURE(GetSamplerParameterIivOES, isCallValid, context, samplerPacked, pname,
9869
                      params);
9870
    }
9871
    else
9872
    {
9873
        GenerateContextLostErrorOnCurrentGlobalContext();
9874
    }
9875
}
9876

9877
void GL_APIENTRY GL_GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
9878
{
9879
    Context *context = GetValidGlobalContext();
9880
    EVENT(context, GLGetSamplerParameterIuivOES,
9881
          "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9882
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
9883

9884
    if (context)
9885
    {
9886
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
9887
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9888
        bool isCallValid =
9889
            (context->skipValidation() ||
9890
             ValidateGetSamplerParameterIuivOES(context, samplerPacked, pname, params));
9891
        if (isCallValid)
9892
        {
9893
            context->getSamplerParameterIuiv(samplerPacked, pname, params);
9894
        }
9895
        ANGLE_CAPTURE(GetSamplerParameterIuivOES, isCallValid, context, samplerPacked, pname,
9896
                      params);
9897
    }
9898
    else
9899
    {
9900
        GenerateContextLostErrorOnCurrentGlobalContext();
9901
    }
9902
}
9903

9904
void GL_APIENTRY GL_GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
9905
{
9906
    Context *context = GetValidGlobalContext();
9907
    EVENT(context, GLGetTexParameterIivOES,
9908
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9909
          GLenumToString(GLenumGroup::TextureTarget, target),
9910
          GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
9911

9912
    if (context)
9913
    {
9914
        TextureType targetPacked                              = PackParam<TextureType>(target);
9915
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9916
        bool isCallValid                                      = (context->skipValidation() ||
9917
                            ValidateGetTexParameterIivOES(context, targetPacked, pname, params));
9918
        if (isCallValid)
9919
        {
9920
            context->getTexParameterIiv(targetPacked, pname, params);
9921
        }
9922
        ANGLE_CAPTURE(GetTexParameterIivOES, isCallValid, context, targetPacked, pname, params);
9923
    }
9924
    else
9925
    {
9926
        GenerateContextLostErrorOnCurrentGlobalContext();
9927
    }
9928
}
9929

9930
void GL_APIENTRY GL_GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
9931
{
9932
    Context *context = GetValidGlobalContext();
9933
    EVENT(context, GLGetTexParameterIuivOES,
9934
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9935
          GLenumToString(GLenumGroup::TextureTarget, target),
9936
          GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
9937

9938
    if (context)
9939
    {
9940
        TextureType targetPacked                              = PackParam<TextureType>(target);
9941
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9942
        bool isCallValid                                      = (context->skipValidation() ||
9943
                            ValidateGetTexParameterIuivOES(context, targetPacked, pname, params));
9944
        if (isCallValid)
9945
        {
9946
            context->getTexParameterIuiv(targetPacked, pname, params);
9947
        }
9948
        ANGLE_CAPTURE(GetTexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
9949
    }
9950
    else
9951
    {
9952
        GenerateContextLostErrorOnCurrentGlobalContext();
9953
    }
9954
}
9955

9956
void GL_APIENTRY GL_SamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
9957
{
9958
    Context *context = GetValidGlobalContext();
9959
    EVENT(context, GLSamplerParameterIivOES,
9960
          "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
9961
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
9962

9963
    if (context)
9964
    {
9965
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
9966
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9967
        bool isCallValid                                      = (context->skipValidation() ||
9968
                            ValidateSamplerParameterIivOES(context, samplerPacked, pname, param));
9969
        if (isCallValid)
9970
        {
9971
            context->samplerParameterIiv(samplerPacked, pname, param);
9972
        }
9973
        ANGLE_CAPTURE(SamplerParameterIivOES, isCallValid, context, samplerPacked, pname, param);
9974
    }
9975
    else
9976
    {
9977
        GenerateContextLostErrorOnCurrentGlobalContext();
9978
    }
9979
}
9980

9981
void GL_APIENTRY GL_SamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
9982
{
9983
    Context *context = GetValidGlobalContext();
9984
    EVENT(context, GLSamplerParameterIuivOES,
9985
          "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
9986
          sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
9987

9988
    if (context)
9989
    {
9990
        SamplerID samplerPacked                               = PackParam<SamplerID>(sampler);
9991
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9992
        bool isCallValid                                      = (context->skipValidation() ||
9993
                            ValidateSamplerParameterIuivOES(context, samplerPacked, pname, param));
9994
        if (isCallValid)
9995
        {
9996
            context->samplerParameterIuiv(samplerPacked, pname, param);
9997
        }
9998
        ANGLE_CAPTURE(SamplerParameterIuivOES, isCallValid, context, samplerPacked, pname, param);
9999
    }
10000
    else
10001
    {
10002
        GenerateContextLostErrorOnCurrentGlobalContext();
10003
    }
10004
}
10005

10006
void GL_APIENTRY GL_TexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
10007
{
10008
    Context *context = GetValidGlobalContext();
10009
    EVENT(context, GLTexParameterIivOES,
10010
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10011
          GLenumToString(GLenumGroup::TextureTarget, target),
10012
          GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
10013

10014
    if (context)
10015
    {
10016
        TextureType targetPacked                              = PackParam<TextureType>(target);
10017
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10018
        bool isCallValid                                      = (context->skipValidation() ||
10019
                            ValidateTexParameterIivOES(context, targetPacked, pname, params));
10020
        if (isCallValid)
10021
        {
10022
            context->texParameterIiv(targetPacked, pname, params);
10023
        }
10024
        ANGLE_CAPTURE(TexParameterIivOES, isCallValid, context, targetPacked, pname, params);
10025
    }
10026
    else
10027
    {
10028
        GenerateContextLostErrorOnCurrentGlobalContext();
10029
    }
10030
}
10031

10032
void GL_APIENTRY GL_TexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
10033
{
10034
    Context *context = GetValidGlobalContext();
10035
    EVENT(context, GLTexParameterIuivOES,
10036
          "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10037
          GLenumToString(GLenumGroup::TextureTarget, target),
10038
          GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
10039

10040
    if (context)
10041
    {
10042
        TextureType targetPacked                              = PackParam<TextureType>(target);
10043
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10044
        bool isCallValid                                      = (context->skipValidation() ||
10045
                            ValidateTexParameterIuivOES(context, targetPacked, pname, params));
10046
        if (isCallValid)
10047
        {
10048
            context->texParameterIuiv(targetPacked, pname, params);
10049
        }
10050
        ANGLE_CAPTURE(TexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
10051
    }
10052
    else
10053
    {
10054
        GenerateContextLostErrorOnCurrentGlobalContext();
10055
    }
10056
}
10057

10058
// GL_OES_texture_buffer
10059
void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint buffer)
10060
{
10061
    Context *context = GetValidGlobalContext();
10062
    EVENT(context, GLTexBufferOES, "context = %d, target = %s, internalformat = %s, buffer = %u",
10063
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
10064
          GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer);
10065

10066
    if (context)
10067
    {
10068
        TextureType targetPacked                              = PackParam<TextureType>(target);
10069
        BufferID bufferPacked                                 = PackParam<BufferID>(buffer);
10070
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10071
        bool isCallValid =
10072
            (context->skipValidation() ||
10073
             ValidateTexBufferOES(context, targetPacked, internalformat, bufferPacked));
10074
        if (isCallValid)
10075
        {
10076
            context->texBuffer(targetPacked, internalformat, bufferPacked);
10077
        }
10078
        ANGLE_CAPTURE(TexBufferOES, isCallValid, context, targetPacked, internalformat,
10079
                      bufferPacked);
10080
    }
10081
    else
10082
    {
10083
        GenerateContextLostErrorOnCurrentGlobalContext();
10084
    }
10085
}
10086

10087
void GL_APIENTRY GL_TexBufferRangeOES(GLenum target,
10088
                                      GLenum internalformat,
10089
                                      GLuint buffer,
10090
                                      GLintptr offset,
10091
                                      GLsizeiptr size)
10092
{
10093
    Context *context = GetValidGlobalContext();
10094
    EVENT(context, GLTexBufferRangeOES,
10095
          "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu",
10096
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
10097
          GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer,
10098
          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
10099

10100
    if (context)
10101
    {
10102
        TextureType targetPacked                              = PackParam<TextureType>(target);
10103
        BufferID bufferPacked                                 = PackParam<BufferID>(buffer);
10104
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10105
        bool isCallValid                                      = (context->skipValidation() ||
10106
                            ValidateTexBufferRangeOES(context, targetPacked, internalformat,
10107
                                                      bufferPacked, offset, size));
10108
        if (isCallValid)
10109
        {
10110
            context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size);
10111
        }
10112
        ANGLE_CAPTURE(TexBufferRangeOES, isCallValid, context, targetPacked, internalformat,
10113
                      bufferPacked, offset, size);
10114
    }
10115
    else
10116
    {
10117
        GenerateContextLostErrorOnCurrentGlobalContext();
10118
    }
10119
}
10120

10121
// GL_OES_texture_cube_map
10122
void GL_APIENTRY GL_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
10123
{
10124
    Context *context = GetValidGlobalContext();
10125
    EVENT(context, GLGetTexGenfvOES,
10126
          "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10127
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10128
          GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
10129

10130
    if (context)
10131
    {
10132
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10133
        bool isCallValid =
10134
            (context->skipValidation() || ValidateGetTexGenfvOES(context, coord, pname, params));
10135
        if (isCallValid)
10136
        {
10137
            context->getTexGenfv(coord, pname, params);
10138
        }
10139
        ANGLE_CAPTURE(GetTexGenfvOES, isCallValid, context, coord, pname, params);
10140
    }
10141
    else
10142
    {
10143
        GenerateContextLostErrorOnCurrentGlobalContext();
10144
    }
10145
}
10146

10147
void GL_APIENTRY GL_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
10148
{
10149
    Context *context = GetValidGlobalContext();
10150
    EVENT(context, GLGetTexGenivOES,
10151
          "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10152
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10153
          GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
10154

10155
    if (context)
10156
    {
10157
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10158
        bool isCallValid =
10159
            (context->skipValidation() || ValidateGetTexGenivOES(context, coord, pname, params));
10160
        if (isCallValid)
10161
        {
10162
            context->getTexGeniv(coord, pname, params);
10163
        }
10164
        ANGLE_CAPTURE(GetTexGenivOES, isCallValid, context, coord, pname, params);
10165
    }
10166
    else
10167
    {
10168
        GenerateContextLostErrorOnCurrentGlobalContext();
10169
    }
10170
}
10171

10172
void GL_APIENTRY GL_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
10173
{
10174
    Context *context = GetValidGlobalContext();
10175
    EVENT(context, GLGetTexGenxvOES,
10176
          "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10177
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10178
          GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
10179

10180
    if (context)
10181
    {
10182
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10183
        bool isCallValid =
10184
            (context->skipValidation() || ValidateGetTexGenxvOES(context, coord, pname, params));
10185
        if (isCallValid)
10186
        {
10187
            context->getTexGenxv(coord, pname, params);
10188
        }
10189
        ANGLE_CAPTURE(GetTexGenxvOES, isCallValid, context, coord, pname, params);
10190
    }
10191
    else
10192
    {
10193
        GenerateContextLostErrorOnCurrentGlobalContext();
10194
    }
10195
}
10196

10197
void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param)
10198
{
10199
    Context *context = GetValidGlobalContext();
10200
    EVENT(context, GLTexGenfOES, "context = %d, coord = %s, pname = %s, param = %f", CID(context),
10201
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10202
          GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
10203

10204
    if (context)
10205
    {
10206
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10207
        bool isCallValid =
10208
            (context->skipValidation() || ValidateTexGenfOES(context, coord, pname, param));
10209
        if (isCallValid)
10210
        {
10211
            context->texGenf(coord, pname, param);
10212
        }
10213
        ANGLE_CAPTURE(TexGenfOES, isCallValid, context, coord, pname, param);
10214
    }
10215
    else
10216
    {
10217
        GenerateContextLostErrorOnCurrentGlobalContext();
10218
    }
10219
}
10220

10221
void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
10222
{
10223
    Context *context = GetValidGlobalContext();
10224
    EVENT(context, GLTexGenfvOES,
10225
          "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10226
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10227
          GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
10228

10229
    if (context)
10230
    {
10231
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10232
        bool isCallValid =
10233
            (context->skipValidation() || ValidateTexGenfvOES(context, coord, pname, params));
10234
        if (isCallValid)
10235
        {
10236
            context->texGenfv(coord, pname, params);
10237
        }
10238
        ANGLE_CAPTURE(TexGenfvOES, isCallValid, context, coord, pname, params);
10239
    }
10240
    else
10241
    {
10242
        GenerateContextLostErrorOnCurrentGlobalContext();
10243
    }
10244
}
10245

10246
void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param)
10247
{
10248
    Context *context = GetValidGlobalContext();
10249
    EVENT(context, GLTexGeniOES, "context = %d, coord = %s, pname = %s, param = %d", CID(context),
10250
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10251
          GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
10252

10253
    if (context)
10254
    {
10255
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10256
        bool isCallValid =
10257
            (context->skipValidation() || ValidateTexGeniOES(context, coord, pname, param));
10258
        if (isCallValid)
10259
        {
10260
            context->texGeni(coord, pname, param);
10261
        }
10262
        ANGLE_CAPTURE(TexGeniOES, isCallValid, context, coord, pname, param);
10263
    }
10264
    else
10265
    {
10266
        GenerateContextLostErrorOnCurrentGlobalContext();
10267
    }
10268
}
10269

10270
void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
10271
{
10272
    Context *context = GetValidGlobalContext();
10273
    EVENT(context, GLTexGenivOES,
10274
          "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10275
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10276
          GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
10277

10278
    if (context)
10279
    {
10280
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10281
        bool isCallValid =
10282
            (context->skipValidation() || ValidateTexGenivOES(context, coord, pname, params));
10283
        if (isCallValid)
10284
        {
10285
            context->texGeniv(coord, pname, params);
10286
        }
10287
        ANGLE_CAPTURE(TexGenivOES, isCallValid, context, coord, pname, params);
10288
    }
10289
    else
10290
    {
10291
        GenerateContextLostErrorOnCurrentGlobalContext();
10292
    }
10293
}
10294

10295
void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
10296
{
10297
    Context *context = GetValidGlobalContext();
10298
    EVENT(context, GLTexGenxOES, "context = %d, coord = %s, pname = %s, param = 0x%X", CID(context),
10299
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10300
          GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
10301

10302
    if (context)
10303
    {
10304
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10305
        bool isCallValid =
10306
            (context->skipValidation() || ValidateTexGenxOES(context, coord, pname, param));
10307
        if (isCallValid)
10308
        {
10309
            context->texGenx(coord, pname, param);
10310
        }
10311
        ANGLE_CAPTURE(TexGenxOES, isCallValid, context, coord, pname, param);
10312
    }
10313
    else
10314
    {
10315
        GenerateContextLostErrorOnCurrentGlobalContext();
10316
    }
10317
}
10318

10319
void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
10320
{
10321
    Context *context = GetValidGlobalContext();
10322
    EVENT(context, GLTexGenxvOES,
10323
          "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10324
          GLenumToString(GLenumGroup::TextureCoordName, coord),
10325
          GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
10326

10327
    if (context)
10328
    {
10329
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10330
        bool isCallValid =
10331
            (context->skipValidation() || ValidateTexGenxvOES(context, coord, pname, params));
10332
        if (isCallValid)
10333
        {
10334
            context->texGenxv(coord, pname, params);
10335
        }
10336
        ANGLE_CAPTURE(TexGenxvOES, isCallValid, context, coord, pname, params);
10337
    }
10338
    else
10339
    {
10340
        GenerateContextLostErrorOnCurrentGlobalContext();
10341
    }
10342
}
10343

10344
// GL_OES_texture_cube_map_array
10345

10346
// GL_OES_texture_half_float
10347

10348
// GL_OES_texture_stencil8
10349

10350
// GL_OES_texture_storage_multisample_2d_array
10351
void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target,
10352
                                               GLsizei samples,
10353
                                               GLenum internalformat,
10354
                                               GLsizei width,
10355
                                               GLsizei height,
10356
                                               GLsizei depth,
10357
                                               GLboolean fixedsamplelocations)
10358
{
10359
    Context *context = GetValidGlobalContext();
10360
    EVENT(context, GLTexStorage3DMultisampleOES,
10361
          "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
10362
          "depth = %d, fixedsamplelocations = %s",
10363
          CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
10364
          GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth,
10365
          GLbooleanToString(fixedsamplelocations));
10366

10367
    if (context)
10368
    {
10369
        TextureType targetPacked                              = PackParam<TextureType>(target);
10370
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10371
        bool isCallValid =
10372
            (context->skipValidation() ||
10373
             ValidateTexStorage3DMultisampleOES(context, targetPacked, samples, internalformat,
10374
                                                width, height, depth, fixedsamplelocations));
10375
        if (isCallValid)
10376
        {
10377
            context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
10378
                                             depth, fixedsamplelocations);
10379
        }
10380
        ANGLE_CAPTURE(TexStorage3DMultisampleOES, isCallValid, context, targetPacked, samples,
10381
                      internalformat, width, height, depth, fixedsamplelocations);
10382
    }
10383
    else
10384
    {
10385
        GenerateContextLostErrorOnCurrentGlobalContext();
10386
    }
10387
}
10388

10389
// GL_OES_vertex_array_object
10390
void GL_APIENTRY GL_BindVertexArrayOES(GLuint array)
10391
{
10392
    Context *context = GetValidGlobalContext();
10393
    EVENT(context, GLBindVertexArrayOES, "context = %d, array = %u", CID(context), array);
10394

10395
    if (context)
10396
    {
10397
        VertexArrayID arrayPacked                             = PackParam<VertexArrayID>(array);
10398
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10399
        bool isCallValid =
10400
            (context->skipValidation() || ValidateBindVertexArrayOES(context, arrayPacked));
10401
        if (isCallValid)
10402
        {
10403
            context->bindVertexArray(arrayPacked);
10404
        }
10405
        ANGLE_CAPTURE(BindVertexArrayOES, isCallValid, context, arrayPacked);
10406
    }
10407
    else
10408
    {
10409
        GenerateContextLostErrorOnCurrentGlobalContext();
10410
    }
10411
}
10412

10413
void GL_APIENTRY GL_DeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
10414
{
10415
    Context *context = GetValidGlobalContext();
10416
    EVENT(context, GLDeleteVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
10417
          CID(context), n, (uintptr_t)arrays);
10418

10419
    if (context)
10420
    {
10421
        const VertexArrayID *arraysPacked = PackParam<const VertexArrayID *>(arrays);
10422
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10423
        bool isCallValid =
10424
            (context->skipValidation() || ValidateDeleteVertexArraysOES(context, n, arraysPacked));
10425
        if (isCallValid)
10426
        {
10427
            context->deleteVertexArrays(n, arraysPacked);
10428
        }
10429
        ANGLE_CAPTURE(DeleteVertexArraysOES, isCallValid, context, n, arraysPacked);
10430
    }
10431
    else
10432
    {
10433
        GenerateContextLostErrorOnCurrentGlobalContext();
10434
    }
10435
}
10436

10437
void GL_APIENTRY GL_GenVertexArraysOES(GLsizei n, GLuint *arrays)
10438
{
10439
    Context *context = GetValidGlobalContext();
10440
    EVENT(context, GLGenVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
10441
          CID(context), n, (uintptr_t)arrays);
10442

10443
    if (context)
10444
    {
10445
        VertexArrayID *arraysPacked                           = PackParam<VertexArrayID *>(arrays);
10446
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10447
        bool isCallValid =
10448
            (context->skipValidation() || ValidateGenVertexArraysOES(context, n, arraysPacked));
10449
        if (isCallValid)
10450
        {
10451
            context->genVertexArrays(n, arraysPacked);
10452
        }
10453
        ANGLE_CAPTURE(GenVertexArraysOES, isCallValid, context, n, arraysPacked);
10454
    }
10455
    else
10456
    {
10457
        GenerateContextLostErrorOnCurrentGlobalContext();
10458
    }
10459
}
10460

10461
GLboolean GL_APIENTRY GL_IsVertexArrayOES(GLuint array)
10462
{
10463
    Context *context = GetValidGlobalContext();
10464
    EVENT(context, GLIsVertexArrayOES, "context = %d, array = %u", CID(context), array);
10465

10466
    GLboolean returnValue;
10467
    if (context)
10468
    {
10469
        VertexArrayID arrayPacked                             = PackParam<VertexArrayID>(array);
10470
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10471
        bool isCallValid =
10472
            (context->skipValidation() || ValidateIsVertexArrayOES(context, arrayPacked));
10473
        if (isCallValid)
10474
        {
10475
            returnValue = context->isVertexArray(arrayPacked);
10476
        }
10477
        else
10478
        {
10479
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>();
10480
        }
10481
        ANGLE_CAPTURE(IsVertexArrayOES, isCallValid, context, arrayPacked, returnValue);
10482
    }
10483
    else
10484
    {
10485
        GenerateContextLostErrorOnCurrentGlobalContext();
10486
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>();
10487
    }
10488
    return returnValue;
10489
}
10490

10491
// GL_OVR_multiview
10492
void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target,
10493
                                                   GLenum attachment,
10494
                                                   GLuint texture,
10495
                                                   GLint level,
10496
                                                   GLint baseViewIndex,
10497
                                                   GLsizei numViews)
10498
{
10499
    Context *context = GetValidGlobalContext();
10500
    EVENT(context, GLFramebufferTextureMultiviewOVR,
10501
          "context = %d, target = %s, attachment = %s, texture = %u, level = %d, baseViewIndex = "
10502
          "%d, numViews = %d",
10503
          CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
10504
          GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level,
10505
          baseViewIndex, numViews);
10506

10507
    if (context)
10508
    {
10509
        TextureID texturePacked                               = PackParam<TextureID>(texture);
10510
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10511
        bool isCallValid =
10512
            (context->skipValidation() ||
10513
             ValidateFramebufferTextureMultiviewOVR(context, target, attachment, texturePacked,
10514
                                                    level, baseViewIndex, numViews));
10515
        if (isCallValid)
10516
        {
10517
            context->framebufferTextureMultiview(target, attachment, texturePacked, level,
10518
                                                 baseViewIndex, numViews);
10519
        }
10520
        ANGLE_CAPTURE(FramebufferTextureMultiviewOVR, isCallValid, context, target, attachment,
10521
                      texturePacked, level, baseViewIndex, numViews);
10522
    }
10523
    else
10524
    {
10525
        GenerateContextLostErrorOnCurrentGlobalContext();
10526
    }
10527
}
10528

10529
// GL_OVR_multiview2
10530
}  // extern "C"
10531

10532
Product

Resources

Company
