CoCalc -- entry_points_gl_2

GitHub Repository: PojavLauncherTeam/angle
Path: blob/main_old/src/libGL/entry_points_gl_2_autogen.cpp
¹⁶⁹³ views
1
// GENERATED FILE - DO NOT EDIT.
2
// Generated by generate_entry_points.py using data from gl.xml.
3
//
4
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
5
// Use of this source code is governed by a BSD-style license that can be
6
// found in the LICENSE file.
7
//
8
// entry_points_gl_2_autogen.cpp:
9
//   Defines the Desktop GL 2.x entry points.
10

11
#include "libGL/entry_points_gl_2_autogen.h"
12

13
#include "libANGLE/Context.h"
14
#include "libANGLE/Context.inl.h"
15
#include "libANGLE/capture/gl_enum_utils.h"
16
#include "libANGLE/entry_points_utils.h"
17
#include "libANGLE/validationEGL.h"
18
#include "libANGLE/validationES.h"
19
#include "libANGLE/validationES1.h"
20
#include "libANGLE/validationES2.h"
21
#include "libANGLE/validationES3.h"
22
#include "libANGLE/validationES31.h"
23
#include "libANGLE/validationES32.h"
24
#include "libANGLE/validationESEXT.h"
25
#include "libANGLE/validationGL2_autogen.h"
26
#include "libGLESv2/global_state.h"
27

28
using namespace gl;
29

30
extern "C" {
31

32
// GL 2.0
33
void GL_APIENTRY GL_AttachShader(GLuint program, GLuint shader)
34
{
35
    Context *context = GetValidGlobalContext();
36
    EVENT(context, GLAttachShader, "context = %d, program = %u, shader = %u", CID(context), program,
37
          shader);
38

39
    if (context)
40
    {
41
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
42
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
43
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
44
        bool isCallValid                                      = (context->skipValidation() ||
45
                            ValidateAttachShader(context, programPacked, shaderPacked));
46
        if (isCallValid)
47
        {
48
            context->attachShader(programPacked, shaderPacked);
49
        }
50
        ANGLE_CAPTURE(AttachShader, isCallValid, context, programPacked, shaderPacked);
51
    }
52
    else
53
    {
54
        GenerateContextLostErrorOnCurrentGlobalContext();
55
    }
56
}
57

58
void GL_APIENTRY GL_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
59
{
60
    Context *context = GetValidGlobalContext();
61
    EVENT(context, GLBindAttribLocation,
62
          "context = %d, program = %u, index = %u, name = 0x%016" PRIxPTR "", CID(context), program,
63
          index, (uintptr_t)name);
64

65
    if (context)
66
    {
67
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
68
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
69
        bool isCallValid                                      = (context->skipValidation() ||
70
                            ValidateBindAttribLocation(context, programPacked, index, name));
71
        if (isCallValid)
72
        {
73
            context->bindAttribLocation(programPacked, index, name);
74
        }
75
        ANGLE_CAPTURE(BindAttribLocation, isCallValid, context, programPacked, index, name);
76
    }
77
    else
78
    {
79
        GenerateContextLostErrorOnCurrentGlobalContext();
80
    }
81
}
82

83
void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
84
{
85
    Context *context = GetValidGlobalContext();
86
    EVENT(context, GLBlendEquationSeparate, "context = %d, modeRGB = %s, modeAlpha = %s",
87
          CID(context), GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
88
          GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
89

90
    if (context)
91
    {
92
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
93
        bool isCallValid                                      = (context->skipValidation() ||
94
                            ValidateBlendEquationSeparate(context, modeRGB, modeAlpha));
95
        if (isCallValid)
96
        {
97
            context->blendEquationSeparate(modeRGB, modeAlpha);
98
        }
99
        ANGLE_CAPTURE(BlendEquationSeparate, isCallValid, context, modeRGB, modeAlpha);
100
    }
101
    else
102
    {
103
        GenerateContextLostErrorOnCurrentGlobalContext();
104
    }
105
}
106

107
void GL_APIENTRY GL_CompileShader(GLuint shader)
108
{
109
    Context *context = GetValidGlobalContext();
110
    EVENT(context, GLCompileShader, "context = %d, shader = %u", CID(context), shader);
111

112
    if (context)
113
    {
114
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
115
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
116
        bool isCallValid =
117
            (context->skipValidation() || ValidateCompileShader(context, shaderPacked));
118
        if (isCallValid)
119
        {
120
            context->compileShader(shaderPacked);
121
        }
122
        ANGLE_CAPTURE(CompileShader, isCallValid, context, shaderPacked);
123
    }
124
    else
125
    {
126
        GenerateContextLostErrorOnCurrentGlobalContext();
127
    }
128
}
129

130
GLuint GL_APIENTRY GL_CreateProgram()
131
{
132
    Context *context = GetValidGlobalContext();
133
    EVENT(context, GLCreateProgram, "context = %d", CID(context));
134

135
    GLuint returnValue;
136
    if (context)
137
    {
138
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
139
        bool isCallValid = (context->skipValidation() || ValidateCreateProgram(context));
140
        if (isCallValid)
141
        {
142
            returnValue = context->createProgram();
143
        }
144
        else
145
        {
146
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
147
        }
148
        ANGLE_CAPTURE(CreateProgram, isCallValid, context, returnValue);
149
    }
150
    else
151
    {
152
        GenerateContextLostErrorOnCurrentGlobalContext();
153
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
154
    }
155
    return returnValue;
156
}
157

158
GLuint GL_APIENTRY GL_CreateShader(GLenum type)
159
{
160
    Context *context = GetValidGlobalContext();
161
    EVENT(context, GLCreateShader, "context = %d, type = %s", CID(context),
162
          GLenumToString(GLenumGroup::ShaderType, type));
163

164
    GLuint returnValue;
165
    if (context)
166
    {
167
        ShaderType typePacked                                 = PackParam<ShaderType>(type);
168
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
169
        bool isCallValid = (context->skipValidation() || ValidateCreateShader(context, typePacked));
170
        if (isCallValid)
171
        {
172
            returnValue = context->createShader(typePacked);
173
        }
174
        else
175
        {
176
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
177
        }
178
        ANGLE_CAPTURE(CreateShader, isCallValid, context, typePacked, returnValue);
179
    }
180
    else
181
    {
182
        GenerateContextLostErrorOnCurrentGlobalContext();
183
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
184
    }
185
    return returnValue;
186
}
187

188
void GL_APIENTRY GL_DeleteProgram(GLuint program)
189
{
190
    Context *context = GetValidGlobalContext();
191
    EVENT(context, GLDeleteProgram, "context = %d, program = %u", CID(context), program);
192

193
    if (context)
194
    {
195
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
196
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
197
        bool isCallValid =
198
            (context->skipValidation() || ValidateDeleteProgram(context, programPacked));
199
        if (isCallValid)
200
        {
201
            context->deleteProgram(programPacked);
202
        }
203
        ANGLE_CAPTURE(DeleteProgram, isCallValid, context, programPacked);
204
    }
205
    else
206
    {
207
        GenerateContextLostErrorOnCurrentGlobalContext();
208
    }
209
}
210

211
void GL_APIENTRY GL_DeleteShader(GLuint shader)
212
{
213
    Context *context = GetValidGlobalContext();
214
    EVENT(context, GLDeleteShader, "context = %d, shader = %u", CID(context), shader);
215

216
    if (context)
217
    {
218
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
219
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
220
        bool isCallValid =
221
            (context->skipValidation() || ValidateDeleteShader(context, shaderPacked));
222
        if (isCallValid)
223
        {
224
            context->deleteShader(shaderPacked);
225
        }
226
        ANGLE_CAPTURE(DeleteShader, isCallValid, context, shaderPacked);
227
    }
228
    else
229
    {
230
        GenerateContextLostErrorOnCurrentGlobalContext();
231
    }
232
}
233

234
void GL_APIENTRY GL_DetachShader(GLuint program, GLuint shader)
235
{
236
    Context *context = GetValidGlobalContext();
237
    EVENT(context, GLDetachShader, "context = %d, program = %u, shader = %u", CID(context), program,
238
          shader);
239

240
    if (context)
241
    {
242
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
243
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
244
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
245
        bool isCallValid                                      = (context->skipValidation() ||
246
                            ValidateDetachShader(context, programPacked, shaderPacked));
247
        if (isCallValid)
248
        {
249
            context->detachShader(programPacked, shaderPacked);
250
        }
251
        ANGLE_CAPTURE(DetachShader, isCallValid, context, programPacked, shaderPacked);
252
    }
253
    else
254
    {
255
        GenerateContextLostErrorOnCurrentGlobalContext();
256
    }
257
}
258

259
void GL_APIENTRY GL_DisableVertexAttribArray(GLuint index)
260
{
261
    Context *context = GetValidGlobalContext();
262
    EVENT(context, GLDisableVertexAttribArray, "context = %d, index = %u", CID(context), index);
263

264
    if (context)
265
    {
266
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
267
        bool isCallValid =
268
            (context->skipValidation() || ValidateDisableVertexAttribArray(context, index));
269
        if (isCallValid)
270
        {
271
            context->disableVertexAttribArray(index);
272
        }
273
        ANGLE_CAPTURE(DisableVertexAttribArray, isCallValid, context, index);
274
    }
275
    else
276
    {
277
        GenerateContextLostErrorOnCurrentGlobalContext();
278
    }
279
}
280

281
void GL_APIENTRY GL_DrawBuffers(GLsizei n, const GLenum *bufs)
282
{
283
    Context *context = GetValidGlobalContext();
284
    EVENT(context, GLDrawBuffers, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context), n,
285
          (uintptr_t)bufs);
286

287
    if (context)
288
    {
289
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
290
        bool isCallValid = (context->skipValidation() || ValidateDrawBuffers(context, n, bufs));
291
        if (isCallValid)
292
        {
293
            context->drawBuffers(n, bufs);
294
        }
295
        ANGLE_CAPTURE(DrawBuffers, isCallValid, context, n, bufs);
296
    }
297
    else
298
    {
299
        GenerateContextLostErrorOnCurrentGlobalContext();
300
    }
301
}
302

303
void GL_APIENTRY GL_EnableVertexAttribArray(GLuint index)
304
{
305
    Context *context = GetValidGlobalContext();
306
    EVENT(context, GLEnableVertexAttribArray, "context = %d, index = %u", CID(context), index);
307

308
    if (context)
309
    {
310
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
311
        bool isCallValid =
312
            (context->skipValidation() || ValidateEnableVertexAttribArray(context, index));
313
        if (isCallValid)
314
        {
315
            context->enableVertexAttribArray(index);
316
        }
317
        ANGLE_CAPTURE(EnableVertexAttribArray, isCallValid, context, index);
318
    }
319
    else
320
    {
321
        GenerateContextLostErrorOnCurrentGlobalContext();
322
    }
323
}
324

325
void GL_APIENTRY GL_GetActiveAttrib(GLuint program,
326
                                    GLuint index,
327
                                    GLsizei bufSize,
328
                                    GLsizei *length,
329
                                    GLint *size,
330
                                    GLenum *type,
331
                                    GLchar *name)
332
{
333
    Context *context = GetValidGlobalContext();
334
    EVENT(context, GLGetActiveAttrib,
335
          "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
336
          ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
337
          CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
338
          (uintptr_t)type, (uintptr_t)name);
339

340
    if (context)
341
    {
342
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
343
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
344
        bool isCallValid                                      = (context->skipValidation() ||
345
                            ValidateGetActiveAttrib(context, programPacked, index, bufSize, length,
346
                                                    size, type, name));
347
        if (isCallValid)
348
        {
349
            context->getActiveAttrib(programPacked, index, bufSize, length, size, type, name);
350
        }
351
        ANGLE_CAPTURE(GetActiveAttrib, isCallValid, context, programPacked, index, bufSize, length,
352
                      size, type, name);
353
    }
354
    else
355
    {
356
        GenerateContextLostErrorOnCurrentGlobalContext();
357
    }
358
}
359

360
void GL_APIENTRY GL_GetActiveUniform(GLuint program,
361
                                     GLuint index,
362
                                     GLsizei bufSize,
363
                                     GLsizei *length,
364
                                     GLint *size,
365
                                     GLenum *type,
366
                                     GLchar *name)
367
{
368
    Context *context = GetValidGlobalContext();
369
    EVENT(context, GLGetActiveUniform,
370
          "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
371
          ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
372
          CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
373
          (uintptr_t)type, (uintptr_t)name);
374

375
    if (context)
376
    {
377
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
378
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
379
        bool isCallValid                                      = (context->skipValidation() ||
380
                            ValidateGetActiveUniform(context, programPacked, index, bufSize, length,
381
                                                     size, type, name));
382
        if (isCallValid)
383
        {
384
            context->getActiveUniform(programPacked, index, bufSize, length, size, type, name);
385
        }
386
        ANGLE_CAPTURE(GetActiveUniform, isCallValid, context, programPacked, index, bufSize, length,
387
                      size, type, name);
388
    }
389
    else
390
    {
391
        GenerateContextLostErrorOnCurrentGlobalContext();
392
    }
393
}
394

395
void GL_APIENTRY GL_GetAttachedShaders(GLuint program,
396
                                       GLsizei maxCount,
397
                                       GLsizei *count,
398
                                       GLuint *shaders)
399
{
400
    Context *context = GetValidGlobalContext();
401
    EVENT(context, GLGetAttachedShaders,
402
          "context = %d, program = %u, maxCount = %d, count = 0x%016" PRIxPTR
403
          ", shaders = 0x%016" PRIxPTR "",
404
          CID(context), program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
405

406
    if (context)
407
    {
408
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
409
        ShaderProgramID *shadersPacked = PackParam<ShaderProgramID *>(shaders);
410
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
411
        bool isCallValid =
412
            (context->skipValidation() ||
413
             ValidateGetAttachedShaders(context, programPacked, maxCount, count, shadersPacked));
414
        if (isCallValid)
415
        {
416
            context->getAttachedShaders(programPacked, maxCount, count, shadersPacked);
417
        }
418
        ANGLE_CAPTURE(GetAttachedShaders, isCallValid, context, programPacked, maxCount, count,
419
                      shadersPacked);
420
    }
421
    else
422
    {
423
        GenerateContextLostErrorOnCurrentGlobalContext();
424
    }
425
}
426

427
GLint GL_APIENTRY GL_GetAttribLocation(GLuint program, const GLchar *name)
428
{
429
    Context *context = GetValidGlobalContext();
430
    EVENT(context, GLGetAttribLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
431
          CID(context), program, (uintptr_t)name);
432

433
    GLint returnValue;
434
    if (context)
435
    {
436
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
437
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
438
        bool isCallValid =
439
            (context->skipValidation() || ValidateGetAttribLocation(context, programPacked, name));
440
        if (isCallValid)
441
        {
442
            returnValue = context->getAttribLocation(programPacked, name);
443
        }
444
        else
445
        {
446
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
447
        }
448
        ANGLE_CAPTURE(GetAttribLocation, isCallValid, context, programPacked, name, returnValue);
449
    }
450
    else
451
    {
452
        GenerateContextLostErrorOnCurrentGlobalContext();
453
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
454
    }
455
    return returnValue;
456
}
457

458
void GL_APIENTRY GL_GetProgramInfoLog(GLuint program,
459
                                      GLsizei bufSize,
460
                                      GLsizei *length,
461
                                      GLchar *infoLog)
462
{
463
    Context *context = GetValidGlobalContext();
464
    EVENT(context, GLGetProgramInfoLog,
465
          "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
466
          ", infoLog = 0x%016" PRIxPTR "",
467
          CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
468

469
    if (context)
470
    {
471
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
472
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
473
        bool isCallValid =
474
            (context->skipValidation() ||
475
             ValidateGetProgramInfoLog(context, programPacked, bufSize, length, infoLog));
476
        if (isCallValid)
477
        {
478
            context->getProgramInfoLog(programPacked, bufSize, length, infoLog);
479
        }
480
        ANGLE_CAPTURE(GetProgramInfoLog, isCallValid, context, programPacked, bufSize, length,
481
                      infoLog);
482
    }
483
    else
484
    {
485
        GenerateContextLostErrorOnCurrentGlobalContext();
486
    }
487
}
488

489
void GL_APIENTRY GL_GetProgramiv(GLuint program, GLenum pname, GLint *params)
490
{
491
    Context *context = GetGlobalContext();
492
    EVENT(context, GLGetProgramiv,
493
          "context = %d, program = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
494
          program, GLenumToString(GLenumGroup::ProgramPropertyARB, pname), (uintptr_t)params);
495

496
    if (context)
497
    {
498
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
499
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
500
        bool isCallValid                                      = (context->skipValidation() ||
501
                            ValidateGetProgramiv(context, programPacked, pname, params));
502
        if (isCallValid)
503
        {
504
            context->getProgramiv(programPacked, pname, params);
505
        }
506
        ANGLE_CAPTURE(GetProgramiv, isCallValid, context, programPacked, pname, params);
507
    }
508
    else
509
    {}
510
}
511

512
void GL_APIENTRY GL_GetShaderInfoLog(GLuint shader,
513
                                     GLsizei bufSize,
514
                                     GLsizei *length,
515
                                     GLchar *infoLog)
516
{
517
    Context *context = GetValidGlobalContext();
518
    EVENT(context, GLGetShaderInfoLog,
519
          "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
520
          ", infoLog = 0x%016" PRIxPTR "",
521
          CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
522

523
    if (context)
524
    {
525
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
526
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
527
        bool isCallValid =
528
            (context->skipValidation() ||
529
             ValidateGetShaderInfoLog(context, shaderPacked, bufSize, length, infoLog));
530
        if (isCallValid)
531
        {
532
            context->getShaderInfoLog(shaderPacked, bufSize, length, infoLog);
533
        }
534
        ANGLE_CAPTURE(GetShaderInfoLog, isCallValid, context, shaderPacked, bufSize, length,
535
                      infoLog);
536
    }
537
    else
538
    {
539
        GenerateContextLostErrorOnCurrentGlobalContext();
540
    }
541
}
542

543
void GL_APIENTRY GL_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
544
{
545
    Context *context = GetValidGlobalContext();
546
    EVENT(context, GLGetShaderSource,
547
          "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
548
          ", source = 0x%016" PRIxPTR "",
549
          CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
550

551
    if (context)
552
    {
553
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
554
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
555
        bool isCallValid =
556
            (context->skipValidation() ||
557
             ValidateGetShaderSource(context, shaderPacked, bufSize, length, source));
558
        if (isCallValid)
559
        {
560
            context->getShaderSource(shaderPacked, bufSize, length, source);
561
        }
562
        ANGLE_CAPTURE(GetShaderSource, isCallValid, context, shaderPacked, bufSize, length, source);
563
    }
564
    else
565
    {
566
        GenerateContextLostErrorOnCurrentGlobalContext();
567
    }
568
}
569

570
void GL_APIENTRY GL_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
571
{
572
    Context *context = GetGlobalContext();
573
    EVENT(context, GLGetShaderiv,
574
          "context = %d, shader = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), shader,
575
          GLenumToString(GLenumGroup::ShaderParameterName, pname), (uintptr_t)params);
576

577
    if (context)
578
    {
579
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
580
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
581
        bool isCallValid                                      = (context->skipValidation() ||
582
                            ValidateGetShaderiv(context, shaderPacked, pname, params));
583
        if (isCallValid)
584
        {
585
            context->getShaderiv(shaderPacked, pname, params);
586
        }
587
        ANGLE_CAPTURE(GetShaderiv, isCallValid, context, shaderPacked, pname, params);
588
    }
589
    else
590
    {}
591
}
592

593
GLint GL_APIENTRY GL_GetUniformLocation(GLuint program, const GLchar *name)
594
{
595
    Context *context = GetValidGlobalContext();
596
    EVENT(context, GLGetUniformLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
597
          CID(context), program, (uintptr_t)name);
598

599
    GLint returnValue;
600
    if (context)
601
    {
602
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
603
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
604
        bool isCallValid =
605
            (context->skipValidation() || ValidateGetUniformLocation(context, programPacked, name));
606
        if (isCallValid)
607
        {
608
            returnValue = context->getUniformLocation(programPacked, name);
609
        }
610
        else
611
        {
612
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
613
        }
614
        ANGLE_CAPTURE(GetUniformLocation, isCallValid, context, programPacked, name, returnValue);
615
    }
616
    else
617
    {
618
        GenerateContextLostErrorOnCurrentGlobalContext();
619
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
620
    }
621
    return returnValue;
622
}
623

624
void GL_APIENTRY GL_GetUniformfv(GLuint program, GLint location, GLfloat *params)
625
{
626
    Context *context = GetValidGlobalContext();
627
    EVENT(context, GLGetUniformfv,
628
          "context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
629
          program, location, (uintptr_t)params);
630

631
    if (context)
632
    {
633
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
634
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
635
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
636
        bool isCallValid                                      = (context->skipValidation() ||
637
                            ValidateGetUniformfv(context, programPacked, locationPacked, params));
638
        if (isCallValid)
639
        {
640
            context->getUniformfv(programPacked, locationPacked, params);
641
        }
642
        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
643
    }
644
    else
645
    {
646
        GenerateContextLostErrorOnCurrentGlobalContext();
647
    }
648
}
649

650
void GL_APIENTRY GL_GetUniformiv(GLuint program, GLint location, GLint *params)
651
{
652
    Context *context = GetValidGlobalContext();
653
    EVENT(context, GLGetUniformiv,
654
          "context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
655
          program, location, (uintptr_t)params);
656

657
    if (context)
658
    {
659
        ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
660
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
661
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
662
        bool isCallValid                                      = (context->skipValidation() ||
663
                            ValidateGetUniformiv(context, programPacked, locationPacked, params));
664
        if (isCallValid)
665
        {
666
            context->getUniformiv(programPacked, locationPacked, params);
667
        }
668
        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
669
    }
670
    else
671
    {
672
        GenerateContextLostErrorOnCurrentGlobalContext();
673
    }
674
}
675

676
void GL_APIENTRY GL_GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
677
{
678
    Context *context = GetValidGlobalContext();
679
    EVENT(context, GLGetVertexAttribPointerv,
680
          "context = %d, index = %u, pname = %s, pointer = 0x%016" PRIxPTR "", CID(context), index,
681
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)pointer);
682

683
    if (context)
684
    {
685
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
686
        bool isCallValid                                      = (context->skipValidation() ||
687
                            ValidateGetVertexAttribPointerv(context, index, pname, pointer));
688
        if (isCallValid)
689
        {
690
            context->getVertexAttribPointerv(index, pname, pointer);
691
        }
692
        ANGLE_CAPTURE(GetVertexAttribPointerv, isCallValid, context, index, pname, pointer);
693
    }
694
    else
695
    {
696
        GenerateContextLostErrorOnCurrentGlobalContext();
697
    }
698
}
699

700
void GL_APIENTRY GL_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
701
{
702
    Context *context = GetValidGlobalContext();
703
    EVENT(context, GLGetVertexAttribdv,
704
          "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
705
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
706

707
    if (context)
708
    {
709
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
710
        bool isCallValid =
711
            (context->skipValidation() || ValidateGetVertexAttribdv(context, index, pname, params));
712
        if (isCallValid)
713
        {
714
            context->getVertexAttribdv(index, pname, params);
715
        }
716
        ANGLE_CAPTURE(GetVertexAttribdv, isCallValid, context, index, pname, params);
717
    }
718
    else
719
    {
720
        GenerateContextLostErrorOnCurrentGlobalContext();
721
    }
722
}
723

724
void GL_APIENTRY GL_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
725
{
726
    Context *context = GetValidGlobalContext();
727
    EVENT(context, GLGetVertexAttribfv,
728
          "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
729
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
730

731
    if (context)
732
    {
733
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
734
        bool isCallValid =
735
            (context->skipValidation() || ValidateGetVertexAttribfv(context, index, pname, params));
736
        if (isCallValid)
737
        {
738
            context->getVertexAttribfv(index, pname, params);
739
        }
740
        ANGLE_CAPTURE(GetVertexAttribfv, isCallValid, context, index, pname, params);
741
    }
742
    else
743
    {
744
        GenerateContextLostErrorOnCurrentGlobalContext();
745
    }
746
}
747

748
void GL_APIENTRY GL_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
749
{
750
    Context *context = GetValidGlobalContext();
751
    EVENT(context, GLGetVertexAttribiv,
752
          "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
753
          GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
754

755
    if (context)
756
    {
757
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
758
        bool isCallValid =
759
            (context->skipValidation() || ValidateGetVertexAttribiv(context, index, pname, params));
760
        if (isCallValid)
761
        {
762
            context->getVertexAttribiv(index, pname, params);
763
        }
764
        ANGLE_CAPTURE(GetVertexAttribiv, isCallValid, context, index, pname, params);
765
    }
766
    else
767
    {
768
        GenerateContextLostErrorOnCurrentGlobalContext();
769
    }
770
}
771

772
GLboolean GL_APIENTRY GL_IsProgram(GLuint program)
773
{
774
    Context *context = GetValidGlobalContext();
775
    EVENT(context, GLIsProgram, "context = %d, program = %u", CID(context), program);
776

777
    GLboolean returnValue;
778
    if (context)
779
    {
780
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
781
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
782
        bool isCallValid = (context->skipValidation() || ValidateIsProgram(context, programPacked));
783
        if (isCallValid)
784
        {
785
            returnValue = context->isProgram(programPacked);
786
        }
787
        else
788
        {
789
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
790
        }
791
        ANGLE_CAPTURE(IsProgram, isCallValid, context, programPacked, returnValue);
792
    }
793
    else
794
    {
795
        GenerateContextLostErrorOnCurrentGlobalContext();
796
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
797
    }
798
    return returnValue;
799
}
800

801
GLboolean GL_APIENTRY GL_IsShader(GLuint shader)
802
{
803
    Context *context = GetValidGlobalContext();
804
    EVENT(context, GLIsShader, "context = %d, shader = %u", CID(context), shader);
805

806
    GLboolean returnValue;
807
    if (context)
808
    {
809
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
810
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
811
        bool isCallValid = (context->skipValidation() || ValidateIsShader(context, shaderPacked));
812
        if (isCallValid)
813
        {
814
            returnValue = context->isShader(shaderPacked);
815
        }
816
        else
817
        {
818
            returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
819
        }
820
        ANGLE_CAPTURE(IsShader, isCallValid, context, shaderPacked, returnValue);
821
    }
822
    else
823
    {
824
        GenerateContextLostErrorOnCurrentGlobalContext();
825
        returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
826
    }
827
    return returnValue;
828
}
829

830
void GL_APIENTRY GL_LinkProgram(GLuint program)
831
{
832
    Context *context = GetValidGlobalContext();
833
    EVENT(context, GLLinkProgram, "context = %d, program = %u", CID(context), program);
834

835
    if (context)
836
    {
837
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
838
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
839
        bool isCallValid =
840
            (context->skipValidation() || ValidateLinkProgram(context, programPacked));
841
        if (isCallValid)
842
        {
843
            context->linkProgram(programPacked);
844
        }
845
        ANGLE_CAPTURE(LinkProgram, isCallValid, context, programPacked);
846
    }
847
    else
848
    {
849
        GenerateContextLostErrorOnCurrentGlobalContext();
850
    }
851
}
852

853
void GL_APIENTRY GL_ShaderSource(GLuint shader,
854
                                 GLsizei count,
855
                                 const GLchar *const *string,
856
                                 const GLint *length)
857
{
858
    Context *context = GetValidGlobalContext();
859
    EVENT(context, GLShaderSource,
860
          "context = %d, shader = %u, count = %d, string = 0x%016" PRIxPTR
861
          ", length = 0x%016" PRIxPTR "",
862
          CID(context), shader, count, (uintptr_t)string, (uintptr_t)length);
863

864
    if (context)
865
    {
866
        ShaderProgramID shaderPacked                          = PackParam<ShaderProgramID>(shader);
867
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
868
        bool isCallValid                                      = (context->skipValidation() ||
869
                            ValidateShaderSource(context, shaderPacked, count, string, length));
870
        if (isCallValid)
871
        {
872
            context->shaderSource(shaderPacked, count, string, length);
873
        }
874
        ANGLE_CAPTURE(ShaderSource, isCallValid, context, shaderPacked, count, string, length);
875
    }
876
    else
877
    {
878
        GenerateContextLostErrorOnCurrentGlobalContext();
879
    }
880
}
881

882
void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
883
{
884
    Context *context = GetValidGlobalContext();
885
    EVENT(context, GLStencilFuncSeparate, "context = %d, face = %s, func = %s, ref = %d, mask = %u",
886
          CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face),
887
          GLenumToString(GLenumGroup::StencilFunction, func), ref, mask);
888

889
    if (context)
890
    {
891
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
892
        bool isCallValid                                      = (context->skipValidation() ||
893
                            ValidateStencilFuncSeparate(context, face, func, ref, mask));
894
        if (isCallValid)
895
        {
896
            context->stencilFuncSeparate(face, func, ref, mask);
897
        }
898
        ANGLE_CAPTURE(StencilFuncSeparate, isCallValid, context, face, func, ref, mask);
899
    }
900
    else
901
    {
902
        GenerateContextLostErrorOnCurrentGlobalContext();
903
    }
904
}
905

906
void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask)
907
{
908
    Context *context = GetValidGlobalContext();
909
    EVENT(context, GLStencilMaskSeparate, "context = %d, face = %s, mask = %u", CID(context),
910
          GLenumToString(GLenumGroup::StencilFaceDirection, face), mask);
911

912
    if (context)
913
    {
914
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
915
        bool isCallValid =
916
            (context->skipValidation() || ValidateStencilMaskSeparate(context, face, mask));
917
        if (isCallValid)
918
        {
919
            context->stencilMaskSeparate(face, mask);
920
        }
921
        ANGLE_CAPTURE(StencilMaskSeparate, isCallValid, context, face, mask);
922
    }
923
    else
924
    {
925
        GenerateContextLostErrorOnCurrentGlobalContext();
926
    }
927
}
928

929
void GL_APIENTRY GL_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
930
{
931
    Context *context = GetValidGlobalContext();
932
    EVENT(context, GLStencilOpSeparate,
933
          "context = %d, face = %s, sfail = %s, dpfail = %s, dppass = %s", CID(context),
934
          GLenumToString(GLenumGroup::StencilFaceDirection, face),
935
          GLenumToString(GLenumGroup::StencilOp, sfail),
936
          GLenumToString(GLenumGroup::StencilOp, dpfail),
937
          GLenumToString(GLenumGroup::StencilOp, dppass));
938

939
    if (context)
940
    {
941
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
942
        bool isCallValid                                      = (context->skipValidation() ||
943
                            ValidateStencilOpSeparate(context, face, sfail, dpfail, dppass));
944
        if (isCallValid)
945
        {
946
            context->stencilOpSeparate(face, sfail, dpfail, dppass);
947
        }
948
        ANGLE_CAPTURE(StencilOpSeparate, isCallValid, context, face, sfail, dpfail, dppass);
949
    }
950
    else
951
    {
952
        GenerateContextLostErrorOnCurrentGlobalContext();
953
    }
954
}
955

956
void GL_APIENTRY GL_Uniform1f(GLint location, GLfloat v0)
957
{
958
    Context *context = GetValidGlobalContext();
959
    EVENT(context, GLUniform1f, "context = %d, location = %d, v0 = %f", CID(context), location, v0);
960

961
    if (context)
962
    {
963
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
964
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
965
        bool isCallValid =
966
            (context->skipValidation() || ValidateUniform1f(context, locationPacked, v0));
967
        if (isCallValid)
968
        {
969
            context->uniform1f(locationPacked, v0);
970
        }
971
        ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
972
    }
973
    else
974
    {
975
        GenerateContextLostErrorOnCurrentGlobalContext();
976
    }
977
}
978

979
void GL_APIENTRY GL_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
980
{
981
    Context *context = GetValidGlobalContext();
982
    EVENT(context, GLUniform1fv,
983
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
984
          location, count, (uintptr_t)value);
985

986
    if (context)
987
    {
988
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
989
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
990
        bool isCallValid                                      = (context->skipValidation() ||
991
                            ValidateUniform1fv(context, locationPacked, count, value));
992
        if (isCallValid)
993
        {
994
            context->uniform1fv(locationPacked, count, value);
995
        }
996
        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
997
    }
998
    else
999
    {
1000
        GenerateContextLostErrorOnCurrentGlobalContext();
1001
    }
1002
}
1003

1004
void GL_APIENTRY GL_Uniform1i(GLint location, GLint v0)
1005
{
1006
    Context *context = GetValidGlobalContext();
1007
    EVENT(context, GLUniform1i, "context = %d, location = %d, v0 = %d", CID(context), location, v0);
1008

1009
    if (context)
1010
    {
1011
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1012
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1013
        bool isCallValid =
1014
            (context->skipValidation() || ValidateUniform1i(context, locationPacked, v0));
1015
        if (isCallValid)
1016
        {
1017
            context->uniform1i(locationPacked, v0);
1018
        }
1019
        ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
1020
    }
1021
    else
1022
    {
1023
        GenerateContextLostErrorOnCurrentGlobalContext();
1024
    }
1025
}
1026

1027
void GL_APIENTRY GL_Uniform1iv(GLint location, GLsizei count, const GLint *value)
1028
{
1029
    Context *context = GetValidGlobalContext();
1030
    EVENT(context, GLUniform1iv,
1031
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1032
          location, count, (uintptr_t)value);
1033

1034
    if (context)
1035
    {
1036
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1037
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1038
        bool isCallValid                                      = (context->skipValidation() ||
1039
                            ValidateUniform1iv(context, locationPacked, count, value));
1040
        if (isCallValid)
1041
        {
1042
            context->uniform1iv(locationPacked, count, value);
1043
        }
1044
        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
1045
    }
1046
    else
1047
    {
1048
        GenerateContextLostErrorOnCurrentGlobalContext();
1049
    }
1050
}
1051

1052
void GL_APIENTRY GL_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
1053
{
1054
    Context *context = GetValidGlobalContext();
1055
    EVENT(context, GLUniform2f, "context = %d, location = %d, v0 = %f, v1 = %f", CID(context),
1056
          location, v0, v1);
1057

1058
    if (context)
1059
    {
1060
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1061
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1062
        bool isCallValid =
1063
            (context->skipValidation() || ValidateUniform2f(context, locationPacked, v0, v1));
1064
        if (isCallValid)
1065
        {
1066
            context->uniform2f(locationPacked, v0, v1);
1067
        }
1068
        ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
1069
    }
1070
    else
1071
    {
1072
        GenerateContextLostErrorOnCurrentGlobalContext();
1073
    }
1074
}
1075

1076
void GL_APIENTRY GL_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
1077
{
1078
    Context *context = GetValidGlobalContext();
1079
    EVENT(context, GLUniform2fv,
1080
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1081
          location, count, (uintptr_t)value);
1082

1083
    if (context)
1084
    {
1085
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1086
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1087
        bool isCallValid                                      = (context->skipValidation() ||
1088
                            ValidateUniform2fv(context, locationPacked, count, value));
1089
        if (isCallValid)
1090
        {
1091
            context->uniform2fv(locationPacked, count, value);
1092
        }
1093
        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
1094
    }
1095
    else
1096
    {
1097
        GenerateContextLostErrorOnCurrentGlobalContext();
1098
    }
1099
}
1100

1101
void GL_APIENTRY GL_Uniform2i(GLint location, GLint v0, GLint v1)
1102
{
1103
    Context *context = GetValidGlobalContext();
1104
    EVENT(context, GLUniform2i, "context = %d, location = %d, v0 = %d, v1 = %d", CID(context),
1105
          location, v0, v1);
1106

1107
    if (context)
1108
    {
1109
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1110
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1111
        bool isCallValid =
1112
            (context->skipValidation() || ValidateUniform2i(context, locationPacked, v0, v1));
1113
        if (isCallValid)
1114
        {
1115
            context->uniform2i(locationPacked, v0, v1);
1116
        }
1117
        ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
1118
    }
1119
    else
1120
    {
1121
        GenerateContextLostErrorOnCurrentGlobalContext();
1122
    }
1123
}
1124

1125
void GL_APIENTRY GL_Uniform2iv(GLint location, GLsizei count, const GLint *value)
1126
{
1127
    Context *context = GetValidGlobalContext();
1128
    EVENT(context, GLUniform2iv,
1129
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1130
          location, count, (uintptr_t)value);
1131

1132
    if (context)
1133
    {
1134
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1135
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1136
        bool isCallValid                                      = (context->skipValidation() ||
1137
                            ValidateUniform2iv(context, locationPacked, count, value));
1138
        if (isCallValid)
1139
        {
1140
            context->uniform2iv(locationPacked, count, value);
1141
        }
1142
        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
1143
    }
1144
    else
1145
    {
1146
        GenerateContextLostErrorOnCurrentGlobalContext();
1147
    }
1148
}
1149

1150
void GL_APIENTRY GL_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
1151
{
1152
    Context *context = GetValidGlobalContext();
1153
    EVENT(context, GLUniform3f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f",
1154
          CID(context), location, v0, v1, v2);
1155

1156
    if (context)
1157
    {
1158
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1159
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1160
        bool isCallValid =
1161
            (context->skipValidation() || ValidateUniform3f(context, locationPacked, v0, v1, v2));
1162
        if (isCallValid)
1163
        {
1164
            context->uniform3f(locationPacked, v0, v1, v2);
1165
        }
1166
        ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
1167
    }
1168
    else
1169
    {
1170
        GenerateContextLostErrorOnCurrentGlobalContext();
1171
    }
1172
}
1173

1174
void GL_APIENTRY GL_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
1175
{
1176
    Context *context = GetValidGlobalContext();
1177
    EVENT(context, GLUniform3fv,
1178
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1179
          location, count, (uintptr_t)value);
1180

1181
    if (context)
1182
    {
1183
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1184
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1185
        bool isCallValid                                      = (context->skipValidation() ||
1186
                            ValidateUniform3fv(context, locationPacked, count, value));
1187
        if (isCallValid)
1188
        {
1189
            context->uniform3fv(locationPacked, count, value);
1190
        }
1191
        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
1192
    }
1193
    else
1194
    {
1195
        GenerateContextLostErrorOnCurrentGlobalContext();
1196
    }
1197
}
1198

1199
void GL_APIENTRY GL_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
1200
{
1201
    Context *context = GetValidGlobalContext();
1202
    EVENT(context, GLUniform3i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d",
1203
          CID(context), location, v0, v1, v2);
1204

1205
    if (context)
1206
    {
1207
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1208
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1209
        bool isCallValid =
1210
            (context->skipValidation() || ValidateUniform3i(context, locationPacked, v0, v1, v2));
1211
        if (isCallValid)
1212
        {
1213
            context->uniform3i(locationPacked, v0, v1, v2);
1214
        }
1215
        ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
1216
    }
1217
    else
1218
    {
1219
        GenerateContextLostErrorOnCurrentGlobalContext();
1220
    }
1221
}
1222

1223
void GL_APIENTRY GL_Uniform3iv(GLint location, GLsizei count, const GLint *value)
1224
{
1225
    Context *context = GetValidGlobalContext();
1226
    EVENT(context, GLUniform3iv,
1227
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1228
          location, count, (uintptr_t)value);
1229

1230
    if (context)
1231
    {
1232
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1233
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1234
        bool isCallValid                                      = (context->skipValidation() ||
1235
                            ValidateUniform3iv(context, locationPacked, count, value));
1236
        if (isCallValid)
1237
        {
1238
            context->uniform3iv(locationPacked, count, value);
1239
        }
1240
        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
1241
    }
1242
    else
1243
    {
1244
        GenerateContextLostErrorOnCurrentGlobalContext();
1245
    }
1246
}
1247

1248
void GL_APIENTRY GL_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
1249
{
1250
    Context *context = GetValidGlobalContext();
1251
    EVENT(context, GLUniform4f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
1252
          CID(context), location, v0, v1, v2, v3);
1253

1254
    if (context)
1255
    {
1256
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1257
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1258
        bool isCallValid                                      = (context->skipValidation() ||
1259
                            ValidateUniform4f(context, locationPacked, v0, v1, v2, v3));
1260
        if (isCallValid)
1261
        {
1262
            context->uniform4f(locationPacked, v0, v1, v2, v3);
1263
        }
1264
        ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
1265
    }
1266
    else
1267
    {
1268
        GenerateContextLostErrorOnCurrentGlobalContext();
1269
    }
1270
}
1271

1272
void GL_APIENTRY GL_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
1273
{
1274
    Context *context = GetValidGlobalContext();
1275
    EVENT(context, GLUniform4fv,
1276
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1277
          location, count, (uintptr_t)value);
1278

1279
    if (context)
1280
    {
1281
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1282
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1283
        bool isCallValid                                      = (context->skipValidation() ||
1284
                            ValidateUniform4fv(context, locationPacked, count, value));
1285
        if (isCallValid)
1286
        {
1287
            context->uniform4fv(locationPacked, count, value);
1288
        }
1289
        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
1290
    }
1291
    else
1292
    {
1293
        GenerateContextLostErrorOnCurrentGlobalContext();
1294
    }
1295
}
1296

1297
void GL_APIENTRY GL_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1298
{
1299
    Context *context = GetValidGlobalContext();
1300
    EVENT(context, GLUniform4i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
1301
          CID(context), location, v0, v1, v2, v3);
1302

1303
    if (context)
1304
    {
1305
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1306
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1307
        bool isCallValid                                      = (context->skipValidation() ||
1308
                            ValidateUniform4i(context, locationPacked, v0, v1, v2, v3));
1309
        if (isCallValid)
1310
        {
1311
            context->uniform4i(locationPacked, v0, v1, v2, v3);
1312
        }
1313
        ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
1314
    }
1315
    else
1316
    {
1317
        GenerateContextLostErrorOnCurrentGlobalContext();
1318
    }
1319
}
1320

1321
void GL_APIENTRY GL_Uniform4iv(GLint location, GLsizei count, const GLint *value)
1322
{
1323
    Context *context = GetValidGlobalContext();
1324
    EVENT(context, GLUniform4iv,
1325
          "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1326
          location, count, (uintptr_t)value);
1327

1328
    if (context)
1329
    {
1330
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1331
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1332
        bool isCallValid                                      = (context->skipValidation() ||
1333
                            ValidateUniform4iv(context, locationPacked, count, value));
1334
        if (isCallValid)
1335
        {
1336
            context->uniform4iv(locationPacked, count, value);
1337
        }
1338
        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
1339
    }
1340
    else
1341
    {
1342
        GenerateContextLostErrorOnCurrentGlobalContext();
1343
    }
1344
}
1345

1346
void GL_APIENTRY GL_UniformMatrix2fv(GLint location,
1347
                                     GLsizei count,
1348
                                     GLboolean transpose,
1349
                                     const GLfloat *value)
1350
{
1351
    Context *context = GetValidGlobalContext();
1352
    EVENT(context, GLUniformMatrix2fv,
1353
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
1354
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1355

1356
    if (context)
1357
    {
1358
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1359
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1360
        bool isCallValid =
1361
            (context->skipValidation() ||
1362
             ValidateUniformMatrix2fv(context, locationPacked, count, transpose, value));
1363
        if (isCallValid)
1364
        {
1365
            context->uniformMatrix2fv(locationPacked, count, transpose, value);
1366
        }
1367
        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
1368
                      value);
1369
    }
1370
    else
1371
    {
1372
        GenerateContextLostErrorOnCurrentGlobalContext();
1373
    }
1374
}
1375

1376
void GL_APIENTRY GL_UniformMatrix3fv(GLint location,
1377
                                     GLsizei count,
1378
                                     GLboolean transpose,
1379
                                     const GLfloat *value)
1380
{
1381
    Context *context = GetValidGlobalContext();
1382
    EVENT(context, GLUniformMatrix3fv,
1383
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
1384
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1385

1386
    if (context)
1387
    {
1388
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1389
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1390
        bool isCallValid =
1391
            (context->skipValidation() ||
1392
             ValidateUniformMatrix3fv(context, locationPacked, count, transpose, value));
1393
        if (isCallValid)
1394
        {
1395
            context->uniformMatrix3fv(locationPacked, count, transpose, value);
1396
        }
1397
        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
1398
                      value);
1399
    }
1400
    else
1401
    {
1402
        GenerateContextLostErrorOnCurrentGlobalContext();
1403
    }
1404
}
1405

1406
void GL_APIENTRY GL_UniformMatrix4fv(GLint location,
1407
                                     GLsizei count,
1408
                                     GLboolean transpose,
1409
                                     const GLfloat *value)
1410
{
1411
    Context *context = GetValidGlobalContext();
1412
    EVENT(context, GLUniformMatrix4fv,
1413
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
1414
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1415

1416
    if (context)
1417
    {
1418
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
1419
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1420
        bool isCallValid =
1421
            (context->skipValidation() ||
1422
             ValidateUniformMatrix4fv(context, locationPacked, count, transpose, value));
1423
        if (isCallValid)
1424
        {
1425
            context->uniformMatrix4fv(locationPacked, count, transpose, value);
1426
        }
1427
        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
1428
                      value);
1429
    }
1430
    else
1431
    {
1432
        GenerateContextLostErrorOnCurrentGlobalContext();
1433
    }
1434
}
1435

1436
void GL_APIENTRY GL_UseProgram(GLuint program)
1437
{
1438
    Context *context = GetValidGlobalContext();
1439
    EVENT(context, GLUseProgram, "context = %d, program = %u", CID(context), program);
1440

1441
    if (context)
1442
    {
1443
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
1444
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1445
        bool isCallValid =
1446
            (context->skipValidation() || ValidateUseProgram(context, programPacked));
1447
        if (isCallValid)
1448
        {
1449
            context->useProgram(programPacked);
1450
        }
1451
        ANGLE_CAPTURE(UseProgram, isCallValid, context, programPacked);
1452
    }
1453
    else
1454
    {
1455
        GenerateContextLostErrorOnCurrentGlobalContext();
1456
    }
1457
}
1458

1459
void GL_APIENTRY GL_ValidateProgram(GLuint program)
1460
{
1461
    Context *context = GetValidGlobalContext();
1462
    EVENT(context, GLValidateProgram, "context = %d, program = %u", CID(context), program);
1463

1464
    if (context)
1465
    {
1466
        ShaderProgramID programPacked                         = PackParam<ShaderProgramID>(program);
1467
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1468
        bool isCallValid =
1469
            (context->skipValidation() || ValidateValidateProgram(context, programPacked));
1470
        if (isCallValid)
1471
        {
1472
            context->validateProgram(programPacked);
1473
        }
1474
        ANGLE_CAPTURE(ValidateProgram, isCallValid, context, programPacked);
1475
    }
1476
    else
1477
    {
1478
        GenerateContextLostErrorOnCurrentGlobalContext();
1479
    }
1480
}
1481

1482
void GL_APIENTRY GL_VertexAttrib1d(GLuint index, GLdouble x)
1483
{
1484
    Context *context = GetValidGlobalContext();
1485
    EVENT(context, GLVertexAttrib1d, "context = %d, index = %u, x = %f", CID(context), index, x);
1486

1487
    if (context)
1488
    {
1489
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1490
        bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1d(context, index, x));
1491
        if (isCallValid)
1492
        {
1493
            context->vertexAttrib1d(index, x);
1494
        }
1495
        ANGLE_CAPTURE(VertexAttrib1d, isCallValid, context, index, x);
1496
    }
1497
    else
1498
    {
1499
        GenerateContextLostErrorOnCurrentGlobalContext();
1500
    }
1501
}
1502

1503
void GL_APIENTRY GL_VertexAttrib1dv(GLuint index, const GLdouble *v)
1504
{
1505
    Context *context = GetValidGlobalContext();
1506
    EVENT(context, GLVertexAttrib1dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1507
          CID(context), index, (uintptr_t)v);
1508

1509
    if (context)
1510
    {
1511
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1512
        bool isCallValid =
1513
            (context->skipValidation() || ValidateVertexAttrib1dv(context, index, v));
1514
        if (isCallValid)
1515
        {
1516
            context->vertexAttrib1dv(index, v);
1517
        }
1518
        ANGLE_CAPTURE(VertexAttrib1dv, isCallValid, context, index, v);
1519
    }
1520
    else
1521
    {
1522
        GenerateContextLostErrorOnCurrentGlobalContext();
1523
    }
1524
}
1525

1526
void GL_APIENTRY GL_VertexAttrib1f(GLuint index, GLfloat x)
1527
{
1528
    Context *context = GetValidGlobalContext();
1529
    EVENT(context, GLVertexAttrib1f, "context = %d, index = %u, x = %f", CID(context), index, x);
1530

1531
    if (context)
1532
    {
1533
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1534
        bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1f(context, index, x));
1535
        if (isCallValid)
1536
        {
1537
            context->vertexAttrib1f(index, x);
1538
        }
1539
        ANGLE_CAPTURE(VertexAttrib1f, isCallValid, context, index, x);
1540
    }
1541
    else
1542
    {
1543
        GenerateContextLostErrorOnCurrentGlobalContext();
1544
    }
1545
}
1546

1547
void GL_APIENTRY GL_VertexAttrib1fv(GLuint index, const GLfloat *v)
1548
{
1549
    Context *context = GetValidGlobalContext();
1550
    EVENT(context, GLVertexAttrib1fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1551
          CID(context), index, (uintptr_t)v);
1552

1553
    if (context)
1554
    {
1555
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1556
        bool isCallValid =
1557
            (context->skipValidation() || ValidateVertexAttrib1fv(context, index, v));
1558
        if (isCallValid)
1559
        {
1560
            context->vertexAttrib1fv(index, v);
1561
        }
1562
        ANGLE_CAPTURE(VertexAttrib1fv, isCallValid, context, index, v);
1563
    }
1564
    else
1565
    {
1566
        GenerateContextLostErrorOnCurrentGlobalContext();
1567
    }
1568
}
1569

1570
void GL_APIENTRY GL_VertexAttrib1s(GLuint index, GLshort x)
1571
{
1572
    Context *context = GetValidGlobalContext();
1573
    EVENT(context, GLVertexAttrib1s, "context = %d, index = %u, x = %d", CID(context), index, x);
1574

1575
    if (context)
1576
    {
1577
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1578
        bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1s(context, index, x));
1579
        if (isCallValid)
1580
        {
1581
            context->vertexAttrib1s(index, x);
1582
        }
1583
        ANGLE_CAPTURE(VertexAttrib1s, isCallValid, context, index, x);
1584
    }
1585
    else
1586
    {
1587
        GenerateContextLostErrorOnCurrentGlobalContext();
1588
    }
1589
}
1590

1591
void GL_APIENTRY GL_VertexAttrib1sv(GLuint index, const GLshort *v)
1592
{
1593
    Context *context = GetValidGlobalContext();
1594
    EVENT(context, GLVertexAttrib1sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1595
          CID(context), index, (uintptr_t)v);
1596

1597
    if (context)
1598
    {
1599
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1600
        bool isCallValid =
1601
            (context->skipValidation() || ValidateVertexAttrib1sv(context, index, v));
1602
        if (isCallValid)
1603
        {
1604
            context->vertexAttrib1sv(index, v);
1605
        }
1606
        ANGLE_CAPTURE(VertexAttrib1sv, isCallValid, context, index, v);
1607
    }
1608
    else
1609
    {
1610
        GenerateContextLostErrorOnCurrentGlobalContext();
1611
    }
1612
}
1613

1614
void GL_APIENTRY GL_VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
1615
{
1616
    Context *context = GetValidGlobalContext();
1617
    EVENT(context, GLVertexAttrib2d, "context = %d, index = %u, x = %f, y = %f", CID(context),
1618
          index, x, y);
1619

1620
    if (context)
1621
    {
1622
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1623
        bool isCallValid =
1624
            (context->skipValidation() || ValidateVertexAttrib2d(context, index, x, y));
1625
        if (isCallValid)
1626
        {
1627
            context->vertexAttrib2d(index, x, y);
1628
        }
1629
        ANGLE_CAPTURE(VertexAttrib2d, isCallValid, context, index, x, y);
1630
    }
1631
    else
1632
    {
1633
        GenerateContextLostErrorOnCurrentGlobalContext();
1634
    }
1635
}
1636

1637
void GL_APIENTRY GL_VertexAttrib2dv(GLuint index, const GLdouble *v)
1638
{
1639
    Context *context = GetValidGlobalContext();
1640
    EVENT(context, GLVertexAttrib2dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1641
          CID(context), index, (uintptr_t)v);
1642

1643
    if (context)
1644
    {
1645
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1646
        bool isCallValid =
1647
            (context->skipValidation() || ValidateVertexAttrib2dv(context, index, v));
1648
        if (isCallValid)
1649
        {
1650
            context->vertexAttrib2dv(index, v);
1651
        }
1652
        ANGLE_CAPTURE(VertexAttrib2dv, isCallValid, context, index, v);
1653
    }
1654
    else
1655
    {
1656
        GenerateContextLostErrorOnCurrentGlobalContext();
1657
    }
1658
}
1659

1660
void GL_APIENTRY GL_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
1661
{
1662
    Context *context = GetValidGlobalContext();
1663
    EVENT(context, GLVertexAttrib2f, "context = %d, index = %u, x = %f, y = %f", CID(context),
1664
          index, x, y);
1665

1666
    if (context)
1667
    {
1668
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1669
        bool isCallValid =
1670
            (context->skipValidation() || ValidateVertexAttrib2f(context, index, x, y));
1671
        if (isCallValid)
1672
        {
1673
            context->vertexAttrib2f(index, x, y);
1674
        }
1675
        ANGLE_CAPTURE(VertexAttrib2f, isCallValid, context, index, x, y);
1676
    }
1677
    else
1678
    {
1679
        GenerateContextLostErrorOnCurrentGlobalContext();
1680
    }
1681
}
1682

1683
void GL_APIENTRY GL_VertexAttrib2fv(GLuint index, const GLfloat *v)
1684
{
1685
    Context *context = GetValidGlobalContext();
1686
    EVENT(context, GLVertexAttrib2fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1687
          CID(context), index, (uintptr_t)v);
1688

1689
    if (context)
1690
    {
1691
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1692
        bool isCallValid =
1693
            (context->skipValidation() || ValidateVertexAttrib2fv(context, index, v));
1694
        if (isCallValid)
1695
        {
1696
            context->vertexAttrib2fv(index, v);
1697
        }
1698
        ANGLE_CAPTURE(VertexAttrib2fv, isCallValid, context, index, v);
1699
    }
1700
    else
1701
    {
1702
        GenerateContextLostErrorOnCurrentGlobalContext();
1703
    }
1704
}
1705

1706
void GL_APIENTRY GL_VertexAttrib2s(GLuint index, GLshort x, GLshort y)
1707
{
1708
    Context *context = GetValidGlobalContext();
1709
    EVENT(context, GLVertexAttrib2s, "context = %d, index = %u, x = %d, y = %d", CID(context),
1710
          index, x, y);
1711

1712
    if (context)
1713
    {
1714
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1715
        bool isCallValid =
1716
            (context->skipValidation() || ValidateVertexAttrib2s(context, index, x, y));
1717
        if (isCallValid)
1718
        {
1719
            context->vertexAttrib2s(index, x, y);
1720
        }
1721
        ANGLE_CAPTURE(VertexAttrib2s, isCallValid, context, index, x, y);
1722
    }
1723
    else
1724
    {
1725
        GenerateContextLostErrorOnCurrentGlobalContext();
1726
    }
1727
}
1728

1729
void GL_APIENTRY GL_VertexAttrib2sv(GLuint index, const GLshort *v)
1730
{
1731
    Context *context = GetValidGlobalContext();
1732
    EVENT(context, GLVertexAttrib2sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1733
          CID(context), index, (uintptr_t)v);
1734

1735
    if (context)
1736
    {
1737
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1738
        bool isCallValid =
1739
            (context->skipValidation() || ValidateVertexAttrib2sv(context, index, v));
1740
        if (isCallValid)
1741
        {
1742
            context->vertexAttrib2sv(index, v);
1743
        }
1744
        ANGLE_CAPTURE(VertexAttrib2sv, isCallValid, context, index, v);
1745
    }
1746
    else
1747
    {
1748
        GenerateContextLostErrorOnCurrentGlobalContext();
1749
    }
1750
}
1751

1752
void GL_APIENTRY GL_VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1753
{
1754
    Context *context = GetValidGlobalContext();
1755
    EVENT(context, GLVertexAttrib3d, "context = %d, index = %u, x = %f, y = %f, z = %f",
1756
          CID(context), index, x, y, z);
1757

1758
    if (context)
1759
    {
1760
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1761
        bool isCallValid =
1762
            (context->skipValidation() || ValidateVertexAttrib3d(context, index, x, y, z));
1763
        if (isCallValid)
1764
        {
1765
            context->vertexAttrib3d(index, x, y, z);
1766
        }
1767
        ANGLE_CAPTURE(VertexAttrib3d, isCallValid, context, index, x, y, z);
1768
    }
1769
    else
1770
    {
1771
        GenerateContextLostErrorOnCurrentGlobalContext();
1772
    }
1773
}
1774

1775
void GL_APIENTRY GL_VertexAttrib3dv(GLuint index, const GLdouble *v)
1776
{
1777
    Context *context = GetValidGlobalContext();
1778
    EVENT(context, GLVertexAttrib3dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1779
          CID(context), index, (uintptr_t)v);
1780

1781
    if (context)
1782
    {
1783
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1784
        bool isCallValid =
1785
            (context->skipValidation() || ValidateVertexAttrib3dv(context, index, v));
1786
        if (isCallValid)
1787
        {
1788
            context->vertexAttrib3dv(index, v);
1789
        }
1790
        ANGLE_CAPTURE(VertexAttrib3dv, isCallValid, context, index, v);
1791
    }
1792
    else
1793
    {
1794
        GenerateContextLostErrorOnCurrentGlobalContext();
1795
    }
1796
}
1797

1798
void GL_APIENTRY GL_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
1799
{
1800
    Context *context = GetValidGlobalContext();
1801
    EVENT(context, GLVertexAttrib3f, "context = %d, index = %u, x = %f, y = %f, z = %f",
1802
          CID(context), index, x, y, z);
1803

1804
    if (context)
1805
    {
1806
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1807
        bool isCallValid =
1808
            (context->skipValidation() || ValidateVertexAttrib3f(context, index, x, y, z));
1809
        if (isCallValid)
1810
        {
1811
            context->vertexAttrib3f(index, x, y, z);
1812
        }
1813
        ANGLE_CAPTURE(VertexAttrib3f, isCallValid, context, index, x, y, z);
1814
    }
1815
    else
1816
    {
1817
        GenerateContextLostErrorOnCurrentGlobalContext();
1818
    }
1819
}
1820

1821
void GL_APIENTRY GL_VertexAttrib3fv(GLuint index, const GLfloat *v)
1822
{
1823
    Context *context = GetValidGlobalContext();
1824
    EVENT(context, GLVertexAttrib3fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1825
          CID(context), index, (uintptr_t)v);
1826

1827
    if (context)
1828
    {
1829
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1830
        bool isCallValid =
1831
            (context->skipValidation() || ValidateVertexAttrib3fv(context, index, v));
1832
        if (isCallValid)
1833
        {
1834
            context->vertexAttrib3fv(index, v);
1835
        }
1836
        ANGLE_CAPTURE(VertexAttrib3fv, isCallValid, context, index, v);
1837
    }
1838
    else
1839
    {
1840
        GenerateContextLostErrorOnCurrentGlobalContext();
1841
    }
1842
}
1843

1844
void GL_APIENTRY GL_VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
1845
{
1846
    Context *context = GetValidGlobalContext();
1847
    EVENT(context, GLVertexAttrib3s, "context = %d, index = %u, x = %d, y = %d, z = %d",
1848
          CID(context), index, x, y, z);
1849

1850
    if (context)
1851
    {
1852
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1853
        bool isCallValid =
1854
            (context->skipValidation() || ValidateVertexAttrib3s(context, index, x, y, z));
1855
        if (isCallValid)
1856
        {
1857
            context->vertexAttrib3s(index, x, y, z);
1858
        }
1859
        ANGLE_CAPTURE(VertexAttrib3s, isCallValid, context, index, x, y, z);
1860
    }
1861
    else
1862
    {
1863
        GenerateContextLostErrorOnCurrentGlobalContext();
1864
    }
1865
}
1866

1867
void GL_APIENTRY GL_VertexAttrib3sv(GLuint index, const GLshort *v)
1868
{
1869
    Context *context = GetValidGlobalContext();
1870
    EVENT(context, GLVertexAttrib3sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1871
          CID(context), index, (uintptr_t)v);
1872

1873
    if (context)
1874
    {
1875
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1876
        bool isCallValid =
1877
            (context->skipValidation() || ValidateVertexAttrib3sv(context, index, v));
1878
        if (isCallValid)
1879
        {
1880
            context->vertexAttrib3sv(index, v);
1881
        }
1882
        ANGLE_CAPTURE(VertexAttrib3sv, isCallValid, context, index, v);
1883
    }
1884
    else
1885
    {
1886
        GenerateContextLostErrorOnCurrentGlobalContext();
1887
    }
1888
}
1889

1890
void GL_APIENTRY GL_VertexAttrib4Nbv(GLuint index, const GLbyte *v)
1891
{
1892
    Context *context = GetValidGlobalContext();
1893
    EVENT(context, GLVertexAttrib4Nbv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1894
          CID(context), index, (uintptr_t)v);
1895

1896
    if (context)
1897
    {
1898
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1899
        bool isCallValid =
1900
            (context->skipValidation() || ValidateVertexAttrib4Nbv(context, index, v));
1901
        if (isCallValid)
1902
        {
1903
            context->vertexAttrib4Nbv(index, v);
1904
        }
1905
        ANGLE_CAPTURE(VertexAttrib4Nbv, isCallValid, context, index, v);
1906
    }
1907
    else
1908
    {
1909
        GenerateContextLostErrorOnCurrentGlobalContext();
1910
    }
1911
}
1912

1913
void GL_APIENTRY GL_VertexAttrib4Niv(GLuint index, const GLint *v)
1914
{
1915
    Context *context = GetValidGlobalContext();
1916
    EVENT(context, GLVertexAttrib4Niv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1917
          CID(context), index, (uintptr_t)v);
1918

1919
    if (context)
1920
    {
1921
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1922
        bool isCallValid =
1923
            (context->skipValidation() || ValidateVertexAttrib4Niv(context, index, v));
1924
        if (isCallValid)
1925
        {
1926
            context->vertexAttrib4Niv(index, v);
1927
        }
1928
        ANGLE_CAPTURE(VertexAttrib4Niv, isCallValid, context, index, v);
1929
    }
1930
    else
1931
    {
1932
        GenerateContextLostErrorOnCurrentGlobalContext();
1933
    }
1934
}
1935

1936
void GL_APIENTRY GL_VertexAttrib4Nsv(GLuint index, const GLshort *v)
1937
{
1938
    Context *context = GetValidGlobalContext();
1939
    EVENT(context, GLVertexAttrib4Nsv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1940
          CID(context), index, (uintptr_t)v);
1941

1942
    if (context)
1943
    {
1944
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1945
        bool isCallValid =
1946
            (context->skipValidation() || ValidateVertexAttrib4Nsv(context, index, v));
1947
        if (isCallValid)
1948
        {
1949
            context->vertexAttrib4Nsv(index, v);
1950
        }
1951
        ANGLE_CAPTURE(VertexAttrib4Nsv, isCallValid, context, index, v);
1952
    }
1953
    else
1954
    {
1955
        GenerateContextLostErrorOnCurrentGlobalContext();
1956
    }
1957
}
1958

1959
void GL_APIENTRY GL_VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
1960
{
1961
    Context *context = GetValidGlobalContext();
1962
    EVENT(context, GLVertexAttrib4Nub, "context = %d, index = %u, x = %d, y = %d, z = %d, w = %d",
1963
          CID(context), index, x, y, z, w);
1964

1965
    if (context)
1966
    {
1967
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1968
        bool isCallValid =
1969
            (context->skipValidation() || ValidateVertexAttrib4Nub(context, index, x, y, z, w));
1970
        if (isCallValid)
1971
        {
1972
            context->vertexAttrib4Nub(index, x, y, z, w);
1973
        }
1974
        ANGLE_CAPTURE(VertexAttrib4Nub, isCallValid, context, index, x, y, z, w);
1975
    }
1976
    else
1977
    {
1978
        GenerateContextLostErrorOnCurrentGlobalContext();
1979
    }
1980
}
1981

1982
void GL_APIENTRY GL_VertexAttrib4Nubv(GLuint index, const GLubyte *v)
1983
{
1984
    Context *context = GetValidGlobalContext();
1985
    EVENT(context, GLVertexAttrib4Nubv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1986
          CID(context), index, (uintptr_t)v);
1987

1988
    if (context)
1989
    {
1990
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1991
        bool isCallValid =
1992
            (context->skipValidation() || ValidateVertexAttrib4Nubv(context, index, v));
1993
        if (isCallValid)
1994
        {
1995
            context->vertexAttrib4Nubv(index, v);
1996
        }
1997
        ANGLE_CAPTURE(VertexAttrib4Nubv, isCallValid, context, index, v);
1998
    }
1999
    else
2000
    {
2001
        GenerateContextLostErrorOnCurrentGlobalContext();
2002
    }
2003
}
2004

2005
void GL_APIENTRY GL_VertexAttrib4Nuiv(GLuint index, const GLuint *v)
2006
{
2007
    Context *context = GetValidGlobalContext();
2008
    EVENT(context, GLVertexAttrib4Nuiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2009
          CID(context), index, (uintptr_t)v);
2010

2011
    if (context)
2012
    {
2013
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2014
        bool isCallValid =
2015
            (context->skipValidation() || ValidateVertexAttrib4Nuiv(context, index, v));
2016
        if (isCallValid)
2017
        {
2018
            context->vertexAttrib4Nuiv(index, v);
2019
        }
2020
        ANGLE_CAPTURE(VertexAttrib4Nuiv, isCallValid, context, index, v);
2021
    }
2022
    else
2023
    {
2024
        GenerateContextLostErrorOnCurrentGlobalContext();
2025
    }
2026
}
2027

2028
void GL_APIENTRY GL_VertexAttrib4Nusv(GLuint index, const GLushort *v)
2029
{
2030
    Context *context = GetValidGlobalContext();
2031
    EVENT(context, GLVertexAttrib4Nusv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2032
          CID(context), index, (uintptr_t)v);
2033

2034
    if (context)
2035
    {
2036
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2037
        bool isCallValid =
2038
            (context->skipValidation() || ValidateVertexAttrib4Nusv(context, index, v));
2039
        if (isCallValid)
2040
        {
2041
            context->vertexAttrib4Nusv(index, v);
2042
        }
2043
        ANGLE_CAPTURE(VertexAttrib4Nusv, isCallValid, context, index, v);
2044
    }
2045
    else
2046
    {
2047
        GenerateContextLostErrorOnCurrentGlobalContext();
2048
    }
2049
}
2050

2051
void GL_APIENTRY GL_VertexAttrib4bv(GLuint index, const GLbyte *v)
2052
{
2053
    Context *context = GetValidGlobalContext();
2054
    EVENT(context, GLVertexAttrib4bv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2055
          CID(context), index, (uintptr_t)v);
2056

2057
    if (context)
2058
    {
2059
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2060
        bool isCallValid =
2061
            (context->skipValidation() || ValidateVertexAttrib4bv(context, index, v));
2062
        if (isCallValid)
2063
        {
2064
            context->vertexAttrib4bv(index, v);
2065
        }
2066
        ANGLE_CAPTURE(VertexAttrib4bv, isCallValid, context, index, v);
2067
    }
2068
    else
2069
    {
2070
        GenerateContextLostErrorOnCurrentGlobalContext();
2071
    }
2072
}
2073

2074
void GL_APIENTRY GL_VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2075
{
2076
    Context *context = GetValidGlobalContext();
2077
    EVENT(context, GLVertexAttrib4d, "context = %d, index = %u, x = %f, y = %f, z = %f, w = %f",
2078
          CID(context), index, x, y, z, w);
2079

2080
    if (context)
2081
    {
2082
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2083
        bool isCallValid =
2084
            (context->skipValidation() || ValidateVertexAttrib4d(context, index, x, y, z, w));
2085
        if (isCallValid)
2086
        {
2087
            context->vertexAttrib4d(index, x, y, z, w);
2088
        }
2089
        ANGLE_CAPTURE(VertexAttrib4d, isCallValid, context, index, x, y, z, w);
2090
    }
2091
    else
2092
    {
2093
        GenerateContextLostErrorOnCurrentGlobalContext();
2094
    }
2095
}
2096

2097
void GL_APIENTRY GL_VertexAttrib4dv(GLuint index, const GLdouble *v)
2098
{
2099
    Context *context = GetValidGlobalContext();
2100
    EVENT(context, GLVertexAttrib4dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2101
          CID(context), index, (uintptr_t)v);
2102

2103
    if (context)
2104
    {
2105
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2106
        bool isCallValid =
2107
            (context->skipValidation() || ValidateVertexAttrib4dv(context, index, v));
2108
        if (isCallValid)
2109
        {
2110
            context->vertexAttrib4dv(index, v);
2111
        }
2112
        ANGLE_CAPTURE(VertexAttrib4dv, isCallValid, context, index, v);
2113
    }
2114
    else
2115
    {
2116
        GenerateContextLostErrorOnCurrentGlobalContext();
2117
    }
2118
}
2119

2120
void GL_APIENTRY GL_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2121
{
2122
    Context *context = GetValidGlobalContext();
2123
    EVENT(context, GLVertexAttrib4f, "context = %d, index = %u, x = %f, y = %f, z = %f, w = %f",
2124
          CID(context), index, x, y, z, w);
2125

2126
    if (context)
2127
    {
2128
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2129
        bool isCallValid =
2130
            (context->skipValidation() || ValidateVertexAttrib4f(context, index, x, y, z, w));
2131
        if (isCallValid)
2132
        {
2133
            context->vertexAttrib4f(index, x, y, z, w);
2134
        }
2135
        ANGLE_CAPTURE(VertexAttrib4f, isCallValid, context, index, x, y, z, w);
2136
    }
2137
    else
2138
    {
2139
        GenerateContextLostErrorOnCurrentGlobalContext();
2140
    }
2141
}
2142

2143
void GL_APIENTRY GL_VertexAttrib4fv(GLuint index, const GLfloat *v)
2144
{
2145
    Context *context = GetValidGlobalContext();
2146
    EVENT(context, GLVertexAttrib4fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2147
          CID(context), index, (uintptr_t)v);
2148

2149
    if (context)
2150
    {
2151
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2152
        bool isCallValid =
2153
            (context->skipValidation() || ValidateVertexAttrib4fv(context, index, v));
2154
        if (isCallValid)
2155
        {
2156
            context->vertexAttrib4fv(index, v);
2157
        }
2158
        ANGLE_CAPTURE(VertexAttrib4fv, isCallValid, context, index, v);
2159
    }
2160
    else
2161
    {
2162
        GenerateContextLostErrorOnCurrentGlobalContext();
2163
    }
2164
}
2165

2166
void GL_APIENTRY GL_VertexAttrib4iv(GLuint index, const GLint *v)
2167
{
2168
    Context *context = GetValidGlobalContext();
2169
    EVENT(context, GLVertexAttrib4iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2170
          CID(context), index, (uintptr_t)v);
2171

2172
    if (context)
2173
    {
2174
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2175
        bool isCallValid =
2176
            (context->skipValidation() || ValidateVertexAttrib4iv(context, index, v));
2177
        if (isCallValid)
2178
        {
2179
            context->vertexAttrib4iv(index, v);
2180
        }
2181
        ANGLE_CAPTURE(VertexAttrib4iv, isCallValid, context, index, v);
2182
    }
2183
    else
2184
    {
2185
        GenerateContextLostErrorOnCurrentGlobalContext();
2186
    }
2187
}
2188

2189
void GL_APIENTRY GL_VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
2190
{
2191
    Context *context = GetValidGlobalContext();
2192
    EVENT(context, GLVertexAttrib4s, "context = %d, index = %u, x = %d, y = %d, z = %d, w = %d",
2193
          CID(context), index, x, y, z, w);
2194

2195
    if (context)
2196
    {
2197
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2198
        bool isCallValid =
2199
            (context->skipValidation() || ValidateVertexAttrib4s(context, index, x, y, z, w));
2200
        if (isCallValid)
2201
        {
2202
            context->vertexAttrib4s(index, x, y, z, w);
2203
        }
2204
        ANGLE_CAPTURE(VertexAttrib4s, isCallValid, context, index, x, y, z, w);
2205
    }
2206
    else
2207
    {
2208
        GenerateContextLostErrorOnCurrentGlobalContext();
2209
    }
2210
}
2211

2212
void GL_APIENTRY GL_VertexAttrib4sv(GLuint index, const GLshort *v)
2213
{
2214
    Context *context = GetValidGlobalContext();
2215
    EVENT(context, GLVertexAttrib4sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2216
          CID(context), index, (uintptr_t)v);
2217

2218
    if (context)
2219
    {
2220
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2221
        bool isCallValid =
2222
            (context->skipValidation() || ValidateVertexAttrib4sv(context, index, v));
2223
        if (isCallValid)
2224
        {
2225
            context->vertexAttrib4sv(index, v);
2226
        }
2227
        ANGLE_CAPTURE(VertexAttrib4sv, isCallValid, context, index, v);
2228
    }
2229
    else
2230
    {
2231
        GenerateContextLostErrorOnCurrentGlobalContext();
2232
    }
2233
}
2234

2235
void GL_APIENTRY GL_VertexAttrib4ubv(GLuint index, const GLubyte *v)
2236
{
2237
    Context *context = GetValidGlobalContext();
2238
    EVENT(context, GLVertexAttrib4ubv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2239
          CID(context), index, (uintptr_t)v);
2240

2241
    if (context)
2242
    {
2243
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2244
        bool isCallValid =
2245
            (context->skipValidation() || ValidateVertexAttrib4ubv(context, index, v));
2246
        if (isCallValid)
2247
        {
2248
            context->vertexAttrib4ubv(index, v);
2249
        }
2250
        ANGLE_CAPTURE(VertexAttrib4ubv, isCallValid, context, index, v);
2251
    }
2252
    else
2253
    {
2254
        GenerateContextLostErrorOnCurrentGlobalContext();
2255
    }
2256
}
2257

2258
void GL_APIENTRY GL_VertexAttrib4uiv(GLuint index, const GLuint *v)
2259
{
2260
    Context *context = GetValidGlobalContext();
2261
    EVENT(context, GLVertexAttrib4uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2262
          CID(context), index, (uintptr_t)v);
2263

2264
    if (context)
2265
    {
2266
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2267
        bool isCallValid =
2268
            (context->skipValidation() || ValidateVertexAttrib4uiv(context, index, v));
2269
        if (isCallValid)
2270
        {
2271
            context->vertexAttrib4uiv(index, v);
2272
        }
2273
        ANGLE_CAPTURE(VertexAttrib4uiv, isCallValid, context, index, v);
2274
    }
2275
    else
2276
    {
2277
        GenerateContextLostErrorOnCurrentGlobalContext();
2278
    }
2279
}
2280

2281
void GL_APIENTRY GL_VertexAttrib4usv(GLuint index, const GLushort *v)
2282
{
2283
    Context *context = GetValidGlobalContext();
2284
    EVENT(context, GLVertexAttrib4usv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2285
          CID(context), index, (uintptr_t)v);
2286

2287
    if (context)
2288
    {
2289
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2290
        bool isCallValid =
2291
            (context->skipValidation() || ValidateVertexAttrib4usv(context, index, v));
2292
        if (isCallValid)
2293
        {
2294
            context->vertexAttrib4usv(index, v);
2295
        }
2296
        ANGLE_CAPTURE(VertexAttrib4usv, isCallValid, context, index, v);
2297
    }
2298
    else
2299
    {
2300
        GenerateContextLostErrorOnCurrentGlobalContext();
2301
    }
2302
}
2303

2304
void GL_APIENTRY GL_VertexAttribPointer(GLuint index,
2305
                                        GLint size,
2306
                                        GLenum type,
2307
                                        GLboolean normalized,
2308
                                        GLsizei stride,
2309
                                        const void *pointer)
2310
{
2311
    Context *context = GetValidGlobalContext();
2312
    EVENT(context, GLVertexAttribPointer,
2313
          "context = %d, index = %u, size = %d, type = %s, normalized = %s, stride = %d, pointer = "
2314
          "0x%016" PRIxPTR "",
2315
          CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
2316
          GLbooleanToString(normalized), stride, (uintptr_t)pointer);
2317

2318
    if (context)
2319
    {
2320
        VertexAttribType typePacked                           = PackParam<VertexAttribType>(type);
2321
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2322
        bool isCallValid                                      = (context->skipValidation() ||
2323
                            ValidateVertexAttribPointer(context, index, size, typePacked,
2324
                                                        normalized, stride, pointer));
2325
        if (isCallValid)
2326
        {
2327
            context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
2328
        }
2329
        ANGLE_CAPTURE(VertexAttribPointer, isCallValid, context, index, size, typePacked,
2330
                      normalized, stride, pointer);
2331
    }
2332
    else
2333
    {
2334
        GenerateContextLostErrorOnCurrentGlobalContext();
2335
    }
2336
}
2337

2338
// GL 2.1
2339
void GL_APIENTRY GL_UniformMatrix2x3fv(GLint location,
2340
                                       GLsizei count,
2341
                                       GLboolean transpose,
2342
                                       const GLfloat *value)
2343
{
2344
    Context *context = GetValidGlobalContext();
2345
    EVENT(context, GLUniformMatrix2x3fv,
2346
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2347
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2348

2349
    if (context)
2350
    {
2351
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2352
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2353
        bool isCallValid =
2354
            (context->skipValidation() ||
2355
             ValidateUniformMatrix2x3fv(context, locationPacked, count, transpose, value));
2356
        if (isCallValid)
2357
        {
2358
            context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
2359
        }
2360
        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
2361
                      value);
2362
    }
2363
    else
2364
    {
2365
        GenerateContextLostErrorOnCurrentGlobalContext();
2366
    }
2367
}
2368

2369
void GL_APIENTRY GL_UniformMatrix2x4fv(GLint location,
2370
                                       GLsizei count,
2371
                                       GLboolean transpose,
2372
                                       const GLfloat *value)
2373
{
2374
    Context *context = GetValidGlobalContext();
2375
    EVENT(context, GLUniformMatrix2x4fv,
2376
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2377
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2378

2379
    if (context)
2380
    {
2381
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2382
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2383
        bool isCallValid =
2384
            (context->skipValidation() ||
2385
             ValidateUniformMatrix2x4fv(context, locationPacked, count, transpose, value));
2386
        if (isCallValid)
2387
        {
2388
            context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
2389
        }
2390
        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
2391
                      value);
2392
    }
2393
    else
2394
    {
2395
        GenerateContextLostErrorOnCurrentGlobalContext();
2396
    }
2397
}
2398

2399
void GL_APIENTRY GL_UniformMatrix3x2fv(GLint location,
2400
                                       GLsizei count,
2401
                                       GLboolean transpose,
2402
                                       const GLfloat *value)
2403
{
2404
    Context *context = GetValidGlobalContext();
2405
    EVENT(context, GLUniformMatrix3x2fv,
2406
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2407
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2408

2409
    if (context)
2410
    {
2411
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2412
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2413
        bool isCallValid =
2414
            (context->skipValidation() ||
2415
             ValidateUniformMatrix3x2fv(context, locationPacked, count, transpose, value));
2416
        if (isCallValid)
2417
        {
2418
            context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
2419
        }
2420
        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
2421
                      value);
2422
    }
2423
    else
2424
    {
2425
        GenerateContextLostErrorOnCurrentGlobalContext();
2426
    }
2427
}
2428

2429
void GL_APIENTRY GL_UniformMatrix3x4fv(GLint location,
2430
                                       GLsizei count,
2431
                                       GLboolean transpose,
2432
                                       const GLfloat *value)
2433
{
2434
    Context *context = GetValidGlobalContext();
2435
    EVENT(context, GLUniformMatrix3x4fv,
2436
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2437
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2438

2439
    if (context)
2440
    {
2441
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2442
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2443
        bool isCallValid =
2444
            (context->skipValidation() ||
2445
             ValidateUniformMatrix3x4fv(context, locationPacked, count, transpose, value));
2446
        if (isCallValid)
2447
        {
2448
            context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
2449
        }
2450
        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
2451
                      value);
2452
    }
2453
    else
2454
    {
2455
        GenerateContextLostErrorOnCurrentGlobalContext();
2456
    }
2457
}
2458

2459
void GL_APIENTRY GL_UniformMatrix4x2fv(GLint location,
2460
                                       GLsizei count,
2461
                                       GLboolean transpose,
2462
                                       const GLfloat *value)
2463
{
2464
    Context *context = GetValidGlobalContext();
2465
    EVENT(context, GLUniformMatrix4x2fv,
2466
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2467
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2468

2469
    if (context)
2470
    {
2471
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2472
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2473
        bool isCallValid =
2474
            (context->skipValidation() ||
2475
             ValidateUniformMatrix4x2fv(context, locationPacked, count, transpose, value));
2476
        if (isCallValid)
2477
        {
2478
            context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
2479
        }
2480
        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
2481
                      value);
2482
    }
2483
    else
2484
    {
2485
        GenerateContextLostErrorOnCurrentGlobalContext();
2486
    }
2487
}
2488

2489
void GL_APIENTRY GL_UniformMatrix4x3fv(GLint location,
2490
                                       GLsizei count,
2491
                                       GLboolean transpose,
2492
                                       const GLfloat *value)
2493
{
2494
    Context *context = GetValidGlobalContext();
2495
    EVENT(context, GLUniformMatrix4x3fv,
2496
          "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2497
          CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2498

2499
    if (context)
2500
    {
2501
        UniformLocation locationPacked = PackParam<UniformLocation>(location);
2502
        std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2503
        bool isCallValid =
2504
            (context->skipValidation() ||
2505
             ValidateUniformMatrix4x3fv(context, locationPacked, count, transpose, value));
2506
        if (isCallValid)
2507
        {
2508
            context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
2509
        }
2510
        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
2511
                      value);
2512
    }
2513
    else
2514
    {
2515
        GenerateContextLostErrorOnCurrentGlobalContext();
2516
    }
2517
}
2518

2519
}  // extern "C"
2520

2521
Product

Resources

Company
