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
GL_AttachShader(GLuint program,GLuint shader)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, angle::EntryPoint::GLAttachShader,
46 programPacked, shaderPacked));
47 if (isCallValid)
48 {
49 context->attachShader(programPacked, shaderPacked);
50 }
51 ANGLE_CAPTURE(AttachShader, isCallValid, context, programPacked, shaderPacked);
52 }
53 else
54 {
55 GenerateContextLostErrorOnCurrentGlobalContext();
56 }
57 }
58
GL_BindAttribLocation(GLuint program,GLuint index,const GLchar * name)59 void GL_APIENTRY GL_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
60 {
61 Context *context = GetValidGlobalContext();
62 EVENT(context, GLBindAttribLocation,
63 "context = %d, program = %u, index = %u, name = 0x%016" PRIxPTR "", CID(context), program,
64 index, (uintptr_t)name);
65
66 if (context)
67 {
68 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
69 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
70 bool isCallValid =
71 (context->skipValidation() ||
72 ValidateBindAttribLocation(context, angle::EntryPoint::GLBindAttribLocation,
73 programPacked, index, name));
74 if (isCallValid)
75 {
76 context->bindAttribLocation(programPacked, index, name);
77 }
78 ANGLE_CAPTURE(BindAttribLocation, isCallValid, context, programPacked, index, name);
79 }
80 else
81 {
82 GenerateContextLostErrorOnCurrentGlobalContext();
83 }
84 }
85
GL_BlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)86 void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
87 {
88 Context *context = GetValidGlobalContext();
89 EVENT(context, GLBlendEquationSeparate, "context = %d, modeRGB = %s, modeAlpha = %s",
90 CID(context), GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
91 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
92
93 if (context)
94 {
95 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
96 bool isCallValid =
97 (context->skipValidation() ||
98 ValidateBlendEquationSeparate(context, angle::EntryPoint::GLBlendEquationSeparate,
99 modeRGB, modeAlpha));
100 if (isCallValid)
101 {
102 context->blendEquationSeparate(modeRGB, modeAlpha);
103 }
104 ANGLE_CAPTURE(BlendEquationSeparate, isCallValid, context, modeRGB, modeAlpha);
105 }
106 else
107 {
108 GenerateContextLostErrorOnCurrentGlobalContext();
109 }
110 }
111
GL_CompileShader(GLuint shader)112 void GL_APIENTRY GL_CompileShader(GLuint shader)
113 {
114 Context *context = GetValidGlobalContext();
115 EVENT(context, GLCompileShader, "context = %d, shader = %u", CID(context), shader);
116
117 if (context)
118 {
119 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
120 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
121 bool isCallValid =
122 (context->skipValidation() ||
123 ValidateCompileShader(context, angle::EntryPoint::GLCompileShader, shaderPacked));
124 if (isCallValid)
125 {
126 context->compileShader(shaderPacked);
127 }
128 ANGLE_CAPTURE(CompileShader, isCallValid, context, shaderPacked);
129 }
130 else
131 {
132 GenerateContextLostErrorOnCurrentGlobalContext();
133 }
134 }
135
GL_CreateProgram()136 GLuint GL_APIENTRY GL_CreateProgram()
137 {
138 Context *context = GetValidGlobalContext();
139 EVENT(context, GLCreateProgram, "context = %d", CID(context));
140
141 GLuint returnValue;
142 if (context)
143 {
144 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
145 bool isCallValid = (context->skipValidation() ||
146 ValidateCreateProgram(context, angle::EntryPoint::GLCreateProgram));
147 if (isCallValid)
148 {
149 returnValue = context->createProgram();
150 }
151 else
152 {
153 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
154 }
155 ANGLE_CAPTURE(CreateProgram, isCallValid, context, returnValue);
156 }
157 else
158 {
159 GenerateContextLostErrorOnCurrentGlobalContext();
160 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
161 }
162 return returnValue;
163 }
164
GL_CreateShader(GLenum type)165 GLuint GL_APIENTRY GL_CreateShader(GLenum type)
166 {
167 Context *context = GetValidGlobalContext();
168 EVENT(context, GLCreateShader, "context = %d, type = %s", CID(context),
169 GLenumToString(GLenumGroup::ShaderType, type));
170
171 GLuint returnValue;
172 if (context)
173 {
174 ShaderType typePacked = PackParam<ShaderType>(type);
175 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
176 bool isCallValid =
177 (context->skipValidation() ||
178 ValidateCreateShader(context, angle::EntryPoint::GLCreateShader, typePacked));
179 if (isCallValid)
180 {
181 returnValue = context->createShader(typePacked);
182 }
183 else
184 {
185 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
186 }
187 ANGLE_CAPTURE(CreateShader, isCallValid, context, typePacked, returnValue);
188 }
189 else
190 {
191 GenerateContextLostErrorOnCurrentGlobalContext();
192 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
193 }
194 return returnValue;
195 }
196
GL_DeleteProgram(GLuint program)197 void GL_APIENTRY GL_DeleteProgram(GLuint program)
198 {
199 Context *context = GetValidGlobalContext();
200 EVENT(context, GLDeleteProgram, "context = %d, program = %u", CID(context), program);
201
202 if (context)
203 {
204 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
205 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
206 bool isCallValid =
207 (context->skipValidation() ||
208 ValidateDeleteProgram(context, angle::EntryPoint::GLDeleteProgram, programPacked));
209 if (isCallValid)
210 {
211 context->deleteProgram(programPacked);
212 }
213 ANGLE_CAPTURE(DeleteProgram, isCallValid, context, programPacked);
214 }
215 else
216 {
217 GenerateContextLostErrorOnCurrentGlobalContext();
218 }
219 }
220
GL_DeleteShader(GLuint shader)221 void GL_APIENTRY GL_DeleteShader(GLuint shader)
222 {
223 Context *context = GetValidGlobalContext();
224 EVENT(context, GLDeleteShader, "context = %d, shader = %u", CID(context), shader);
225
226 if (context)
227 {
228 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
229 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
230 bool isCallValid =
231 (context->skipValidation() ||
232 ValidateDeleteShader(context, angle::EntryPoint::GLDeleteShader, shaderPacked));
233 if (isCallValid)
234 {
235 context->deleteShader(shaderPacked);
236 }
237 ANGLE_CAPTURE(DeleteShader, isCallValid, context, shaderPacked);
238 }
239 else
240 {
241 GenerateContextLostErrorOnCurrentGlobalContext();
242 }
243 }
244
GL_DetachShader(GLuint program,GLuint shader)245 void GL_APIENTRY GL_DetachShader(GLuint program, GLuint shader)
246 {
247 Context *context = GetValidGlobalContext();
248 EVENT(context, GLDetachShader, "context = %d, program = %u, shader = %u", CID(context), program,
249 shader);
250
251 if (context)
252 {
253 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
254 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
255 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
256 bool isCallValid = (context->skipValidation() ||
257 ValidateDetachShader(context, angle::EntryPoint::GLDetachShader,
258 programPacked, shaderPacked));
259 if (isCallValid)
260 {
261 context->detachShader(programPacked, shaderPacked);
262 }
263 ANGLE_CAPTURE(DetachShader, isCallValid, context, programPacked, shaderPacked);
264 }
265 else
266 {
267 GenerateContextLostErrorOnCurrentGlobalContext();
268 }
269 }
270
GL_DisableVertexAttribArray(GLuint index)271 void GL_APIENTRY GL_DisableVertexAttribArray(GLuint index)
272 {
273 Context *context = GetValidGlobalContext();
274 EVENT(context, GLDisableVertexAttribArray, "context = %d, index = %u", CID(context), index);
275
276 if (context)
277 {
278 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
279 bool isCallValid = (context->skipValidation() ||
280 ValidateDisableVertexAttribArray(
281 context, angle::EntryPoint::GLDisableVertexAttribArray, index));
282 if (isCallValid)
283 {
284 context->disableVertexAttribArray(index);
285 }
286 ANGLE_CAPTURE(DisableVertexAttribArray, isCallValid, context, index);
287 }
288 else
289 {
290 GenerateContextLostErrorOnCurrentGlobalContext();
291 }
292 }
293
GL_DrawBuffers(GLsizei n,const GLenum * bufs)294 void GL_APIENTRY GL_DrawBuffers(GLsizei n, const GLenum *bufs)
295 {
296 Context *context = GetValidGlobalContext();
297 EVENT(context, GLDrawBuffers, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context), n,
298 (uintptr_t)bufs);
299
300 if (context)
301 {
302 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
303 bool isCallValid =
304 (context->skipValidation() ||
305 ValidateDrawBuffers(context, angle::EntryPoint::GLDrawBuffers, n, bufs));
306 if (isCallValid)
307 {
308 context->drawBuffers(n, bufs);
309 }
310 ANGLE_CAPTURE(DrawBuffers, isCallValid, context, n, bufs);
311 }
312 else
313 {
314 GenerateContextLostErrorOnCurrentGlobalContext();
315 }
316 }
317
GL_EnableVertexAttribArray(GLuint index)318 void GL_APIENTRY GL_EnableVertexAttribArray(GLuint index)
319 {
320 Context *context = GetValidGlobalContext();
321 EVENT(context, GLEnableVertexAttribArray, "context = %d, index = %u", CID(context), index);
322
323 if (context)
324 {
325 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
326 bool isCallValid = (context->skipValidation() ||
327 ValidateEnableVertexAttribArray(
328 context, angle::EntryPoint::GLEnableVertexAttribArray, index));
329 if (isCallValid)
330 {
331 context->enableVertexAttribArray(index);
332 }
333 ANGLE_CAPTURE(EnableVertexAttribArray, isCallValid, context, index);
334 }
335 else
336 {
337 GenerateContextLostErrorOnCurrentGlobalContext();
338 }
339 }
340
GL_GetActiveAttrib(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)341 void GL_APIENTRY GL_GetActiveAttrib(GLuint program,
342 GLuint index,
343 GLsizei bufSize,
344 GLsizei *length,
345 GLint *size,
346 GLenum *type,
347 GLchar *name)
348 {
349 Context *context = GetValidGlobalContext();
350 EVENT(context, GLGetActiveAttrib,
351 "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
352 ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
353 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
354 (uintptr_t)type, (uintptr_t)name);
355
356 if (context)
357 {
358 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
359 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
360 bool isCallValid =
361 (context->skipValidation() ||
362 ValidateGetActiveAttrib(context, angle::EntryPoint::GLGetActiveAttrib, programPacked,
363 index, bufSize, length, size, type, name));
364 if (isCallValid)
365 {
366 context->getActiveAttrib(programPacked, index, bufSize, length, size, type, name);
367 }
368 ANGLE_CAPTURE(GetActiveAttrib, isCallValid, context, programPacked, index, bufSize, length,
369 size, type, name);
370 }
371 else
372 {
373 GenerateContextLostErrorOnCurrentGlobalContext();
374 }
375 }
376
GL_GetActiveUniform(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)377 void GL_APIENTRY GL_GetActiveUniform(GLuint program,
378 GLuint index,
379 GLsizei bufSize,
380 GLsizei *length,
381 GLint *size,
382 GLenum *type,
383 GLchar *name)
384 {
385 Context *context = GetValidGlobalContext();
386 EVENT(context, GLGetActiveUniform,
387 "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
388 ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
389 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
390 (uintptr_t)type, (uintptr_t)name);
391
392 if (context)
393 {
394 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
395 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
396 bool isCallValid =
397 (context->skipValidation() ||
398 ValidateGetActiveUniform(context, angle::EntryPoint::GLGetActiveUniform, programPacked,
399 index, bufSize, length, size, type, name));
400 if (isCallValid)
401 {
402 context->getActiveUniform(programPacked, index, bufSize, length, size, type, name);
403 }
404 ANGLE_CAPTURE(GetActiveUniform, isCallValid, context, programPacked, index, bufSize, length,
405 size, type, name);
406 }
407 else
408 {
409 GenerateContextLostErrorOnCurrentGlobalContext();
410 }
411 }
412
GL_GetAttachedShaders(GLuint program,GLsizei maxCount,GLsizei * count,GLuint * shaders)413 void GL_APIENTRY GL_GetAttachedShaders(GLuint program,
414 GLsizei maxCount,
415 GLsizei *count,
416 GLuint *shaders)
417 {
418 Context *context = GetValidGlobalContext();
419 EVENT(context, GLGetAttachedShaders,
420 "context = %d, program = %u, maxCount = %d, count = 0x%016" PRIxPTR
421 ", shaders = 0x%016" PRIxPTR "",
422 CID(context), program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
423
424 if (context)
425 {
426 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
427 ShaderProgramID *shadersPacked = PackParam<ShaderProgramID *>(shaders);
428 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
429 bool isCallValid =
430 (context->skipValidation() ||
431 ValidateGetAttachedShaders(context, angle::EntryPoint::GLGetAttachedShaders,
432 programPacked, maxCount, count, shadersPacked));
433 if (isCallValid)
434 {
435 context->getAttachedShaders(programPacked, maxCount, count, shadersPacked);
436 }
437 ANGLE_CAPTURE(GetAttachedShaders, isCallValid, context, programPacked, maxCount, count,
438 shadersPacked);
439 }
440 else
441 {
442 GenerateContextLostErrorOnCurrentGlobalContext();
443 }
444 }
445
GL_GetAttribLocation(GLuint program,const GLchar * name)446 GLint GL_APIENTRY GL_GetAttribLocation(GLuint program, const GLchar *name)
447 {
448 Context *context = GetValidGlobalContext();
449 EVENT(context, GLGetAttribLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
450 CID(context), program, (uintptr_t)name);
451
452 GLint returnValue;
453 if (context)
454 {
455 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
456 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
457 bool isCallValid =
458 (context->skipValidation() ||
459 ValidateGetAttribLocation(context, angle::EntryPoint::GLGetAttribLocation,
460 programPacked, name));
461 if (isCallValid)
462 {
463 returnValue = context->getAttribLocation(programPacked, name);
464 }
465 else
466 {
467 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
468 }
469 ANGLE_CAPTURE(GetAttribLocation, isCallValid, context, programPacked, name, returnValue);
470 }
471 else
472 {
473 GenerateContextLostErrorOnCurrentGlobalContext();
474 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
475 }
476 return returnValue;
477 }
478
GL_GetProgramInfoLog(GLuint program,GLsizei bufSize,GLsizei * length,GLchar * infoLog)479 void GL_APIENTRY GL_GetProgramInfoLog(GLuint program,
480 GLsizei bufSize,
481 GLsizei *length,
482 GLchar *infoLog)
483 {
484 Context *context = GetValidGlobalContext();
485 EVENT(context, GLGetProgramInfoLog,
486 "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
487 ", infoLog = 0x%016" PRIxPTR "",
488 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
489
490 if (context)
491 {
492 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
493 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
494 bool isCallValid =
495 (context->skipValidation() ||
496 ValidateGetProgramInfoLog(context, angle::EntryPoint::GLGetProgramInfoLog,
497 programPacked, bufSize, length, infoLog));
498 if (isCallValid)
499 {
500 context->getProgramInfoLog(programPacked, bufSize, length, infoLog);
501 }
502 ANGLE_CAPTURE(GetProgramInfoLog, isCallValid, context, programPacked, bufSize, length,
503 infoLog);
504 }
505 else
506 {
507 GenerateContextLostErrorOnCurrentGlobalContext();
508 }
509 }
510
GL_GetProgramiv(GLuint program,GLenum pname,GLint * params)511 void GL_APIENTRY GL_GetProgramiv(GLuint program, GLenum pname, GLint *params)
512 {
513 Context *context = GetGlobalContext();
514 EVENT(context, GLGetProgramiv,
515 "context = %d, program = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
516 program, GLenumToString(GLenumGroup::ProgramPropertyARB, pname), (uintptr_t)params);
517
518 if (context)
519 {
520 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
521 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
522 bool isCallValid = (context->skipValidation() ||
523 ValidateGetProgramiv(context, angle::EntryPoint::GLGetProgramiv,
524 programPacked, pname, params));
525 if (isCallValid)
526 {
527 context->getProgramiv(programPacked, pname, params);
528 }
529 ANGLE_CAPTURE(GetProgramiv, isCallValid, context, programPacked, pname, params);
530 }
531 else
532 {}
533 }
534
GL_GetShaderInfoLog(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * infoLog)535 void GL_APIENTRY GL_GetShaderInfoLog(GLuint shader,
536 GLsizei bufSize,
537 GLsizei *length,
538 GLchar *infoLog)
539 {
540 Context *context = GetValidGlobalContext();
541 EVENT(context, GLGetShaderInfoLog,
542 "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
543 ", infoLog = 0x%016" PRIxPTR "",
544 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
545
546 if (context)
547 {
548 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
549 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
550 bool isCallValid = (context->skipValidation() ||
551 ValidateGetShaderInfoLog(context, angle::EntryPoint::GLGetShaderInfoLog,
552 shaderPacked, bufSize, length, infoLog));
553 if (isCallValid)
554 {
555 context->getShaderInfoLog(shaderPacked, bufSize, length, infoLog);
556 }
557 ANGLE_CAPTURE(GetShaderInfoLog, isCallValid, context, shaderPacked, bufSize, length,
558 infoLog);
559 }
560 else
561 {
562 GenerateContextLostErrorOnCurrentGlobalContext();
563 }
564 }
565
GL_GetShaderSource(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source)566 void GL_APIENTRY GL_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
567 {
568 Context *context = GetValidGlobalContext();
569 EVENT(context, GLGetShaderSource,
570 "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
571 ", source = 0x%016" PRIxPTR "",
572 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
573
574 if (context)
575 {
576 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
577 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
578 bool isCallValid = (context->skipValidation() ||
579 ValidateGetShaderSource(context, angle::EntryPoint::GLGetShaderSource,
580 shaderPacked, bufSize, length, source));
581 if (isCallValid)
582 {
583 context->getShaderSource(shaderPacked, bufSize, length, source);
584 }
585 ANGLE_CAPTURE(GetShaderSource, isCallValid, context, shaderPacked, bufSize, length, source);
586 }
587 else
588 {
589 GenerateContextLostErrorOnCurrentGlobalContext();
590 }
591 }
592
GL_GetShaderiv(GLuint shader,GLenum pname,GLint * params)593 void GL_APIENTRY GL_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
594 {
595 Context *context = GetGlobalContext();
596 EVENT(context, GLGetShaderiv,
597 "context = %d, shader = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), shader,
598 GLenumToString(GLenumGroup::ShaderParameterName, pname), (uintptr_t)params);
599
600 if (context)
601 {
602 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
604 bool isCallValid = (context->skipValidation() ||
605 ValidateGetShaderiv(context, angle::EntryPoint::GLGetShaderiv,
606 shaderPacked, pname, params));
607 if (isCallValid)
608 {
609 context->getShaderiv(shaderPacked, pname, params);
610 }
611 ANGLE_CAPTURE(GetShaderiv, isCallValid, context, shaderPacked, pname, params);
612 }
613 else
614 {}
615 }
616
GL_GetUniformLocation(GLuint program,const GLchar * name)617 GLint GL_APIENTRY GL_GetUniformLocation(GLuint program, const GLchar *name)
618 {
619 Context *context = GetValidGlobalContext();
620 EVENT(context, GLGetUniformLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
621 CID(context), program, (uintptr_t)name);
622
623 GLint returnValue;
624 if (context)
625 {
626 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
627 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
628 bool isCallValid =
629 (context->skipValidation() ||
630 ValidateGetUniformLocation(context, angle::EntryPoint::GLGetUniformLocation,
631 programPacked, name));
632 if (isCallValid)
633 {
634 returnValue = context->getUniformLocation(programPacked, name);
635 }
636 else
637 {
638 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
639 }
640 ANGLE_CAPTURE(GetUniformLocation, isCallValid, context, programPacked, name, returnValue);
641 }
642 else
643 {
644 GenerateContextLostErrorOnCurrentGlobalContext();
645 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
646 }
647 return returnValue;
648 }
649
GL_GetUniformfv(GLuint program,GLint location,GLfloat * params)650 void GL_APIENTRY GL_GetUniformfv(GLuint program, GLint location, GLfloat *params)
651 {
652 Context *context = GetValidGlobalContext();
653 EVENT(context, GLGetUniformfv,
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 ValidateGetUniformfv(context, angle::EntryPoint::GLGetUniformfv,
664 programPacked, locationPacked, params));
665 if (isCallValid)
666 {
667 context->getUniformfv(programPacked, locationPacked, params);
668 }
669 ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
670 }
671 else
672 {
673 GenerateContextLostErrorOnCurrentGlobalContext();
674 }
675 }
676
GL_GetUniformiv(GLuint program,GLint location,GLint * params)677 void GL_APIENTRY GL_GetUniformiv(GLuint program, GLint location, GLint *params)
678 {
679 Context *context = GetValidGlobalContext();
680 EVENT(context, GLGetUniformiv,
681 "context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
682 program, location, (uintptr_t)params);
683
684 if (context)
685 {
686 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
687 UniformLocation locationPacked = PackParam<UniformLocation>(location);
688 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
689 bool isCallValid = (context->skipValidation() ||
690 ValidateGetUniformiv(context, angle::EntryPoint::GLGetUniformiv,
691 programPacked, locationPacked, params));
692 if (isCallValid)
693 {
694 context->getUniformiv(programPacked, locationPacked, params);
695 }
696 ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
697 }
698 else
699 {
700 GenerateContextLostErrorOnCurrentGlobalContext();
701 }
702 }
703
GL_GetVertexAttribPointerv(GLuint index,GLenum pname,void ** pointer)704 void GL_APIENTRY GL_GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
705 {
706 Context *context = GetValidGlobalContext();
707 EVENT(context, GLGetVertexAttribPointerv,
708 "context = %d, index = %u, pname = %s, pointer = 0x%016" PRIxPTR "", CID(context), index,
709 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)pointer);
710
711 if (context)
712 {
713 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
714 bool isCallValid =
715 (context->skipValidation() ||
716 ValidateGetVertexAttribPointerv(context, angle::EntryPoint::GLGetVertexAttribPointerv,
717 index, pname, pointer));
718 if (isCallValid)
719 {
720 context->getVertexAttribPointerv(index, pname, pointer);
721 }
722 ANGLE_CAPTURE(GetVertexAttribPointerv, isCallValid, context, index, pname, pointer);
723 }
724 else
725 {
726 GenerateContextLostErrorOnCurrentGlobalContext();
727 }
728 }
729
GL_GetVertexAttribdv(GLuint index,GLenum pname,GLdouble * params)730 void GL_APIENTRY GL_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
731 {
732 Context *context = GetValidGlobalContext();
733 EVENT(context, GLGetVertexAttribdv,
734 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
735 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
736
737 if (context)
738 {
739 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
740 bool isCallValid =
741 (context->skipValidation() ||
742 ValidateGetVertexAttribdv(context, angle::EntryPoint::GLGetVertexAttribdv, index,
743 pname, params));
744 if (isCallValid)
745 {
746 context->getVertexAttribdv(index, pname, params);
747 }
748 ANGLE_CAPTURE(GetVertexAttribdv, isCallValid, context, index, pname, params);
749 }
750 else
751 {
752 GenerateContextLostErrorOnCurrentGlobalContext();
753 }
754 }
755
GL_GetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)756 void GL_APIENTRY GL_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
757 {
758 Context *context = GetValidGlobalContext();
759 EVENT(context, GLGetVertexAttribfv,
760 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
761 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
762
763 if (context)
764 {
765 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
766 bool isCallValid =
767 (context->skipValidation() ||
768 ValidateGetVertexAttribfv(context, angle::EntryPoint::GLGetVertexAttribfv, index,
769 pname, params));
770 if (isCallValid)
771 {
772 context->getVertexAttribfv(index, pname, params);
773 }
774 ANGLE_CAPTURE(GetVertexAttribfv, isCallValid, context, index, pname, params);
775 }
776 else
777 {
778 GenerateContextLostErrorOnCurrentGlobalContext();
779 }
780 }
781
GL_GetVertexAttribiv(GLuint index,GLenum pname,GLint * params)782 void GL_APIENTRY GL_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
783 {
784 Context *context = GetValidGlobalContext();
785 EVENT(context, GLGetVertexAttribiv,
786 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
787 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
788
789 if (context)
790 {
791 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
792 bool isCallValid =
793 (context->skipValidation() ||
794 ValidateGetVertexAttribiv(context, angle::EntryPoint::GLGetVertexAttribiv, index,
795 pname, params));
796 if (isCallValid)
797 {
798 context->getVertexAttribiv(index, pname, params);
799 }
800 ANGLE_CAPTURE(GetVertexAttribiv, isCallValid, context, index, pname, params);
801 }
802 else
803 {
804 GenerateContextLostErrorOnCurrentGlobalContext();
805 }
806 }
807
GL_IsProgram(GLuint program)808 GLboolean GL_APIENTRY GL_IsProgram(GLuint program)
809 {
810 Context *context = GetValidGlobalContext();
811 EVENT(context, GLIsProgram, "context = %d, program = %u", CID(context), program);
812
813 GLboolean returnValue;
814 if (context)
815 {
816 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
817 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
818 bool isCallValid =
819 (context->skipValidation() ||
820 ValidateIsProgram(context, angle::EntryPoint::GLIsProgram, programPacked));
821 if (isCallValid)
822 {
823 returnValue = context->isProgram(programPacked);
824 }
825 else
826 {
827 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
828 }
829 ANGLE_CAPTURE(IsProgram, isCallValid, context, programPacked, returnValue);
830 }
831 else
832 {
833 GenerateContextLostErrorOnCurrentGlobalContext();
834 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
835 }
836 return returnValue;
837 }
838
GL_IsShader(GLuint shader)839 GLboolean GL_APIENTRY GL_IsShader(GLuint shader)
840 {
841 Context *context = GetValidGlobalContext();
842 EVENT(context, GLIsShader, "context = %d, shader = %u", CID(context), shader);
843
844 GLboolean returnValue;
845 if (context)
846 {
847 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
848 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
849 bool isCallValid = (context->skipValidation() ||
850 ValidateIsShader(context, angle::EntryPoint::GLIsShader, shaderPacked));
851 if (isCallValid)
852 {
853 returnValue = context->isShader(shaderPacked);
854 }
855 else
856 {
857 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
858 }
859 ANGLE_CAPTURE(IsShader, isCallValid, context, shaderPacked, returnValue);
860 }
861 else
862 {
863 GenerateContextLostErrorOnCurrentGlobalContext();
864 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
865 }
866 return returnValue;
867 }
868
GL_LinkProgram(GLuint program)869 void GL_APIENTRY GL_LinkProgram(GLuint program)
870 {
871 Context *context = GetValidGlobalContext();
872 EVENT(context, GLLinkProgram, "context = %d, program = %u", CID(context), program);
873
874 if (context)
875 {
876 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
877 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
878 bool isCallValid =
879 (context->skipValidation() ||
880 ValidateLinkProgram(context, angle::EntryPoint::GLLinkProgram, programPacked));
881 if (isCallValid)
882 {
883 context->linkProgram(programPacked);
884 }
885 ANGLE_CAPTURE(LinkProgram, isCallValid, context, programPacked);
886 }
887 else
888 {
889 GenerateContextLostErrorOnCurrentGlobalContext();
890 }
891 }
892
GL_ShaderSource(GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length)893 void GL_APIENTRY GL_ShaderSource(GLuint shader,
894 GLsizei count,
895 const GLchar *const *string,
896 const GLint *length)
897 {
898 Context *context = GetValidGlobalContext();
899 EVENT(context, GLShaderSource,
900 "context = %d, shader = %u, count = %d, string = 0x%016" PRIxPTR
901 ", length = 0x%016" PRIxPTR "",
902 CID(context), shader, count, (uintptr_t)string, (uintptr_t)length);
903
904 if (context)
905 {
906 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
907 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
908 bool isCallValid = (context->skipValidation() ||
909 ValidateShaderSource(context, angle::EntryPoint::GLShaderSource,
910 shaderPacked, count, string, length));
911 if (isCallValid)
912 {
913 context->shaderSource(shaderPacked, count, string, length);
914 }
915 ANGLE_CAPTURE(ShaderSource, isCallValid, context, shaderPacked, count, string, length);
916 }
917 else
918 {
919 GenerateContextLostErrorOnCurrentGlobalContext();
920 }
921 }
922
GL_StencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)923 void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
924 {
925 Context *context = GetValidGlobalContext();
926 EVENT(context, GLStencilFuncSeparate, "context = %d, face = %s, func = %s, ref = %d, mask = %u",
927 CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face),
928 GLenumToString(GLenumGroup::StencilFunction, func), ref, mask);
929
930 if (context)
931 {
932 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
933 bool isCallValid =
934 (context->skipValidation() ||
935 ValidateStencilFuncSeparate(context, angle::EntryPoint::GLStencilFuncSeparate, face,
936 func, ref, mask));
937 if (isCallValid)
938 {
939 context->stencilFuncSeparate(face, func, ref, mask);
940 }
941 ANGLE_CAPTURE(StencilFuncSeparate, isCallValid, context, face, func, ref, mask);
942 }
943 else
944 {
945 GenerateContextLostErrorOnCurrentGlobalContext();
946 }
947 }
948
GL_StencilMaskSeparate(GLenum face,GLuint mask)949 void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask)
950 {
951 Context *context = GetValidGlobalContext();
952 EVENT(context, GLStencilMaskSeparate, "context = %d, face = %s, mask = %u", CID(context),
953 GLenumToString(GLenumGroup::StencilFaceDirection, face), mask);
954
955 if (context)
956 {
957 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
958 bool isCallValid = (context->skipValidation() ||
959 ValidateStencilMaskSeparate(
960 context, angle::EntryPoint::GLStencilMaskSeparate, face, mask));
961 if (isCallValid)
962 {
963 context->stencilMaskSeparate(face, mask);
964 }
965 ANGLE_CAPTURE(StencilMaskSeparate, isCallValid, context, face, mask);
966 }
967 else
968 {
969 GenerateContextLostErrorOnCurrentGlobalContext();
970 }
971 }
972
GL_StencilOpSeparate(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass)973 void GL_APIENTRY GL_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
974 {
975 Context *context = GetValidGlobalContext();
976 EVENT(context, GLStencilOpSeparate,
977 "context = %d, face = %s, sfail = %s, dpfail = %s, dppass = %s", CID(context),
978 GLenumToString(GLenumGroup::StencilFaceDirection, face),
979 GLenumToString(GLenumGroup::StencilOp, sfail),
980 GLenumToString(GLenumGroup::StencilOp, dpfail),
981 GLenumToString(GLenumGroup::StencilOp, dppass));
982
983 if (context)
984 {
985 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
986 bool isCallValid =
987 (context->skipValidation() ||
988 ValidateStencilOpSeparate(context, angle::EntryPoint::GLStencilOpSeparate, face, sfail,
989 dpfail, dppass));
990 if (isCallValid)
991 {
992 context->stencilOpSeparate(face, sfail, dpfail, dppass);
993 }
994 ANGLE_CAPTURE(StencilOpSeparate, isCallValid, context, face, sfail, dpfail, dppass);
995 }
996 else
997 {
998 GenerateContextLostErrorOnCurrentGlobalContext();
999 }
1000 }
1001
GL_Uniform1f(GLint location,GLfloat v0)1002 void GL_APIENTRY GL_Uniform1f(GLint location, GLfloat v0)
1003 {
1004 Context *context = GetValidGlobalContext();
1005 EVENT(context, GLUniform1f, "context = %d, location = %d, v0 = %f", CID(context), location, v0);
1006
1007 if (context)
1008 {
1009 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1010 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1011 bool isCallValid =
1012 (context->skipValidation() ||
1013 ValidateUniform1f(context, angle::EntryPoint::GLUniform1f, locationPacked, v0));
1014 if (isCallValid)
1015 {
1016 context->uniform1f(locationPacked, v0);
1017 }
1018 ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
1019 }
1020 else
1021 {
1022 GenerateContextLostErrorOnCurrentGlobalContext();
1023 }
1024 }
1025
GL_Uniform1fv(GLint location,GLsizei count,const GLfloat * value)1026 void GL_APIENTRY GL_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
1027 {
1028 Context *context = GetValidGlobalContext();
1029 EVENT(context, GLUniform1fv,
1030 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1031 location, count, (uintptr_t)value);
1032
1033 if (context)
1034 {
1035 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1036 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1037 bool isCallValid = (context->skipValidation() ||
1038 ValidateUniform1fv(context, angle::EntryPoint::GLUniform1fv,
1039 locationPacked, count, value));
1040 if (isCallValid)
1041 {
1042 context->uniform1fv(locationPacked, count, value);
1043 }
1044 ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
1045 }
1046 else
1047 {
1048 GenerateContextLostErrorOnCurrentGlobalContext();
1049 }
1050 }
1051
GL_Uniform1i(GLint location,GLint v0)1052 void GL_APIENTRY GL_Uniform1i(GLint location, GLint v0)
1053 {
1054 Context *context = GetValidGlobalContext();
1055 EVENT(context, GLUniform1i, "context = %d, location = %d, v0 = %d", CID(context), location, v0);
1056
1057 if (context)
1058 {
1059 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1060 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1061 bool isCallValid =
1062 (context->skipValidation() ||
1063 ValidateUniform1i(context, angle::EntryPoint::GLUniform1i, locationPacked, v0));
1064 if (isCallValid)
1065 {
1066 context->uniform1i(locationPacked, v0);
1067 }
1068 ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
1069 }
1070 else
1071 {
1072 GenerateContextLostErrorOnCurrentGlobalContext();
1073 }
1074 }
1075
GL_Uniform1iv(GLint location,GLsizei count,const GLint * value)1076 void GL_APIENTRY GL_Uniform1iv(GLint location, GLsizei count, const GLint *value)
1077 {
1078 Context *context = GetValidGlobalContext();
1079 EVENT(context, GLUniform1iv,
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 ValidateUniform1iv(context, angle::EntryPoint::GLUniform1iv,
1089 locationPacked, count, value));
1090 if (isCallValid)
1091 {
1092 context->uniform1iv(locationPacked, count, value);
1093 }
1094 ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
1095 }
1096 else
1097 {
1098 GenerateContextLostErrorOnCurrentGlobalContext();
1099 }
1100 }
1101
GL_Uniform2f(GLint location,GLfloat v0,GLfloat v1)1102 void GL_APIENTRY GL_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
1103 {
1104 Context *context = GetValidGlobalContext();
1105 EVENT(context, GLUniform2f, "context = %d, location = %d, v0 = %f, v1 = %f", CID(context),
1106 location, v0, v1);
1107
1108 if (context)
1109 {
1110 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1111 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1112 bool isCallValid =
1113 (context->skipValidation() ||
1114 ValidateUniform2f(context, angle::EntryPoint::GLUniform2f, locationPacked, v0, v1));
1115 if (isCallValid)
1116 {
1117 context->uniform2f(locationPacked, v0, v1);
1118 }
1119 ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
1120 }
1121 else
1122 {
1123 GenerateContextLostErrorOnCurrentGlobalContext();
1124 }
1125 }
1126
GL_Uniform2fv(GLint location,GLsizei count,const GLfloat * value)1127 void GL_APIENTRY GL_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
1128 {
1129 Context *context = GetValidGlobalContext();
1130 EVENT(context, GLUniform2fv,
1131 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1132 location, count, (uintptr_t)value);
1133
1134 if (context)
1135 {
1136 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1137 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1138 bool isCallValid = (context->skipValidation() ||
1139 ValidateUniform2fv(context, angle::EntryPoint::GLUniform2fv,
1140 locationPacked, count, value));
1141 if (isCallValid)
1142 {
1143 context->uniform2fv(locationPacked, count, value);
1144 }
1145 ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
1146 }
1147 else
1148 {
1149 GenerateContextLostErrorOnCurrentGlobalContext();
1150 }
1151 }
1152
GL_Uniform2i(GLint location,GLint v0,GLint v1)1153 void GL_APIENTRY GL_Uniform2i(GLint location, GLint v0, GLint v1)
1154 {
1155 Context *context = GetValidGlobalContext();
1156 EVENT(context, GLUniform2i, "context = %d, location = %d, v0 = %d, v1 = %d", CID(context),
1157 location, v0, v1);
1158
1159 if (context)
1160 {
1161 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1162 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1163 bool isCallValid =
1164 (context->skipValidation() ||
1165 ValidateUniform2i(context, angle::EntryPoint::GLUniform2i, locationPacked, v0, v1));
1166 if (isCallValid)
1167 {
1168 context->uniform2i(locationPacked, v0, v1);
1169 }
1170 ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
1171 }
1172 else
1173 {
1174 GenerateContextLostErrorOnCurrentGlobalContext();
1175 }
1176 }
1177
GL_Uniform2iv(GLint location,GLsizei count,const GLint * value)1178 void GL_APIENTRY GL_Uniform2iv(GLint location, GLsizei count, const GLint *value)
1179 {
1180 Context *context = GetValidGlobalContext();
1181 EVENT(context, GLUniform2iv,
1182 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1183 location, count, (uintptr_t)value);
1184
1185 if (context)
1186 {
1187 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1188 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1189 bool isCallValid = (context->skipValidation() ||
1190 ValidateUniform2iv(context, angle::EntryPoint::GLUniform2iv,
1191 locationPacked, count, value));
1192 if (isCallValid)
1193 {
1194 context->uniform2iv(locationPacked, count, value);
1195 }
1196 ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
1197 }
1198 else
1199 {
1200 GenerateContextLostErrorOnCurrentGlobalContext();
1201 }
1202 }
1203
GL_Uniform3f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2)1204 void GL_APIENTRY GL_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
1205 {
1206 Context *context = GetValidGlobalContext();
1207 EVENT(context, GLUniform3f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f",
1208 CID(context), location, v0, v1, v2);
1209
1210 if (context)
1211 {
1212 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1213 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1214 bool isCallValid =
1215 (context->skipValidation() || ValidateUniform3f(context, angle::EntryPoint::GLUniform3f,
1216 locationPacked, v0, v1, v2));
1217 if (isCallValid)
1218 {
1219 context->uniform3f(locationPacked, v0, v1, v2);
1220 }
1221 ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
1222 }
1223 else
1224 {
1225 GenerateContextLostErrorOnCurrentGlobalContext();
1226 }
1227 }
1228
GL_Uniform3fv(GLint location,GLsizei count,const GLfloat * value)1229 void GL_APIENTRY GL_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
1230 {
1231 Context *context = GetValidGlobalContext();
1232 EVENT(context, GLUniform3fv,
1233 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1234 location, count, (uintptr_t)value);
1235
1236 if (context)
1237 {
1238 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1239 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1240 bool isCallValid = (context->skipValidation() ||
1241 ValidateUniform3fv(context, angle::EntryPoint::GLUniform3fv,
1242 locationPacked, count, value));
1243 if (isCallValid)
1244 {
1245 context->uniform3fv(locationPacked, count, value);
1246 }
1247 ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
1248 }
1249 else
1250 {
1251 GenerateContextLostErrorOnCurrentGlobalContext();
1252 }
1253 }
1254
GL_Uniform3i(GLint location,GLint v0,GLint v1,GLint v2)1255 void GL_APIENTRY GL_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
1256 {
1257 Context *context = GetValidGlobalContext();
1258 EVENT(context, GLUniform3i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d",
1259 CID(context), location, v0, v1, v2);
1260
1261 if (context)
1262 {
1263 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1264 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1265 bool isCallValid =
1266 (context->skipValidation() || ValidateUniform3i(context, angle::EntryPoint::GLUniform3i,
1267 locationPacked, v0, v1, v2));
1268 if (isCallValid)
1269 {
1270 context->uniform3i(locationPacked, v0, v1, v2);
1271 }
1272 ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
1273 }
1274 else
1275 {
1276 GenerateContextLostErrorOnCurrentGlobalContext();
1277 }
1278 }
1279
GL_Uniform3iv(GLint location,GLsizei count,const GLint * value)1280 void GL_APIENTRY GL_Uniform3iv(GLint location, GLsizei count, const GLint *value)
1281 {
1282 Context *context = GetValidGlobalContext();
1283 EVENT(context, GLUniform3iv,
1284 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1285 location, count, (uintptr_t)value);
1286
1287 if (context)
1288 {
1289 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1290 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1291 bool isCallValid = (context->skipValidation() ||
1292 ValidateUniform3iv(context, angle::EntryPoint::GLUniform3iv,
1293 locationPacked, count, value));
1294 if (isCallValid)
1295 {
1296 context->uniform3iv(locationPacked, count, value);
1297 }
1298 ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
1299 }
1300 else
1301 {
1302 GenerateContextLostErrorOnCurrentGlobalContext();
1303 }
1304 }
1305
GL_Uniform4f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)1306 void GL_APIENTRY GL_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
1307 {
1308 Context *context = GetValidGlobalContext();
1309 EVENT(context, GLUniform4f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
1310 CID(context), location, v0, v1, v2, v3);
1311
1312 if (context)
1313 {
1314 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1315 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1316 bool isCallValid =
1317 (context->skipValidation() || ValidateUniform4f(context, angle::EntryPoint::GLUniform4f,
1318 locationPacked, v0, v1, v2, v3));
1319 if (isCallValid)
1320 {
1321 context->uniform4f(locationPacked, v0, v1, v2, v3);
1322 }
1323 ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
1324 }
1325 else
1326 {
1327 GenerateContextLostErrorOnCurrentGlobalContext();
1328 }
1329 }
1330
GL_Uniform4fv(GLint location,GLsizei count,const GLfloat * value)1331 void GL_APIENTRY GL_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
1332 {
1333 Context *context = GetValidGlobalContext();
1334 EVENT(context, GLUniform4fv,
1335 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1336 location, count, (uintptr_t)value);
1337
1338 if (context)
1339 {
1340 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1341 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1342 bool isCallValid = (context->skipValidation() ||
1343 ValidateUniform4fv(context, angle::EntryPoint::GLUniform4fv,
1344 locationPacked, count, value));
1345 if (isCallValid)
1346 {
1347 context->uniform4fv(locationPacked, count, value);
1348 }
1349 ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
1350 }
1351 else
1352 {
1353 GenerateContextLostErrorOnCurrentGlobalContext();
1354 }
1355 }
1356
GL_Uniform4i(GLint location,GLint v0,GLint v1,GLint v2,GLint v3)1357 void GL_APIENTRY GL_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1358 {
1359 Context *context = GetValidGlobalContext();
1360 EVENT(context, GLUniform4i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
1361 CID(context), location, v0, v1, v2, v3);
1362
1363 if (context)
1364 {
1365 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1366 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1367 bool isCallValid =
1368 (context->skipValidation() || ValidateUniform4i(context, angle::EntryPoint::GLUniform4i,
1369 locationPacked, v0, v1, v2, v3));
1370 if (isCallValid)
1371 {
1372 context->uniform4i(locationPacked, v0, v1, v2, v3);
1373 }
1374 ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
1375 }
1376 else
1377 {
1378 GenerateContextLostErrorOnCurrentGlobalContext();
1379 }
1380 }
1381
GL_Uniform4iv(GLint location,GLsizei count,const GLint * value)1382 void GL_APIENTRY GL_Uniform4iv(GLint location, GLsizei count, const GLint *value)
1383 {
1384 Context *context = GetValidGlobalContext();
1385 EVENT(context, GLUniform4iv,
1386 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
1387 location, count, (uintptr_t)value);
1388
1389 if (context)
1390 {
1391 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1392 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1393 bool isCallValid = (context->skipValidation() ||
1394 ValidateUniform4iv(context, angle::EntryPoint::GLUniform4iv,
1395 locationPacked, count, value));
1396 if (isCallValid)
1397 {
1398 context->uniform4iv(locationPacked, count, value);
1399 }
1400 ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
1401 }
1402 else
1403 {
1404 GenerateContextLostErrorOnCurrentGlobalContext();
1405 }
1406 }
1407
GL_UniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1408 void GL_APIENTRY GL_UniformMatrix2fv(GLint location,
1409 GLsizei count,
1410 GLboolean transpose,
1411 const GLfloat *value)
1412 {
1413 Context *context = GetValidGlobalContext();
1414 EVENT(context, GLUniformMatrix2fv,
1415 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
1416 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1417
1418 if (context)
1419 {
1420 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1421 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1422 bool isCallValid = (context->skipValidation() ||
1423 ValidateUniformMatrix2fv(context, angle::EntryPoint::GLUniformMatrix2fv,
1424 locationPacked, count, transpose, value));
1425 if (isCallValid)
1426 {
1427 context->uniformMatrix2fv(locationPacked, count, transpose, value);
1428 }
1429 ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
1430 value);
1431 }
1432 else
1433 {
1434 GenerateContextLostErrorOnCurrentGlobalContext();
1435 }
1436 }
1437
GL_UniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1438 void GL_APIENTRY GL_UniformMatrix3fv(GLint location,
1439 GLsizei count,
1440 GLboolean transpose,
1441 const GLfloat *value)
1442 {
1443 Context *context = GetValidGlobalContext();
1444 EVENT(context, GLUniformMatrix3fv,
1445 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
1446 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1447
1448 if (context)
1449 {
1450 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1451 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1452 bool isCallValid = (context->skipValidation() ||
1453 ValidateUniformMatrix3fv(context, angle::EntryPoint::GLUniformMatrix3fv,
1454 locationPacked, count, transpose, value));
1455 if (isCallValid)
1456 {
1457 context->uniformMatrix3fv(locationPacked, count, transpose, value);
1458 }
1459 ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
1460 value);
1461 }
1462 else
1463 {
1464 GenerateContextLostErrorOnCurrentGlobalContext();
1465 }
1466 }
1467
GL_UniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1468 void GL_APIENTRY GL_UniformMatrix4fv(GLint location,
1469 GLsizei count,
1470 GLboolean transpose,
1471 const GLfloat *value)
1472 {
1473 Context *context = GetValidGlobalContext();
1474 EVENT(context, GLUniformMatrix4fv,
1475 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
1476 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1477
1478 if (context)
1479 {
1480 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1481 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1482 bool isCallValid = (context->skipValidation() ||
1483 ValidateUniformMatrix4fv(context, angle::EntryPoint::GLUniformMatrix4fv,
1484 locationPacked, count, transpose, value));
1485 if (isCallValid)
1486 {
1487 context->uniformMatrix4fv(locationPacked, count, transpose, value);
1488 }
1489 ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
1490 value);
1491 }
1492 else
1493 {
1494 GenerateContextLostErrorOnCurrentGlobalContext();
1495 }
1496 }
1497
GL_UseProgram(GLuint program)1498 void GL_APIENTRY GL_UseProgram(GLuint program)
1499 {
1500 Context *context = GetValidGlobalContext();
1501 EVENT(context, GLUseProgram, "context = %d, program = %u", CID(context), program);
1502
1503 if (context)
1504 {
1505 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1506 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1507 bool isCallValid =
1508 (context->skipValidation() ||
1509 ValidateUseProgram(context, angle::EntryPoint::GLUseProgram, programPacked));
1510 if (isCallValid)
1511 {
1512 context->useProgram(programPacked);
1513 }
1514 ANGLE_CAPTURE(UseProgram, isCallValid, context, programPacked);
1515 }
1516 else
1517 {
1518 GenerateContextLostErrorOnCurrentGlobalContext();
1519 }
1520 }
1521
GL_ValidateProgram(GLuint program)1522 void GL_APIENTRY GL_ValidateProgram(GLuint program)
1523 {
1524 Context *context = GetValidGlobalContext();
1525 EVENT(context, GLValidateProgram, "context = %d, program = %u", CID(context), program);
1526
1527 if (context)
1528 {
1529 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1530 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1531 bool isCallValid =
1532 (context->skipValidation() ||
1533 ValidateValidateProgram(context, angle::EntryPoint::GLValidateProgram, programPacked));
1534 if (isCallValid)
1535 {
1536 context->validateProgram(programPacked);
1537 }
1538 ANGLE_CAPTURE(ValidateProgram, isCallValid, context, programPacked);
1539 }
1540 else
1541 {
1542 GenerateContextLostErrorOnCurrentGlobalContext();
1543 }
1544 }
1545
GL_VertexAttrib1d(GLuint index,GLdouble x)1546 void GL_APIENTRY GL_VertexAttrib1d(GLuint index, GLdouble x)
1547 {
1548 Context *context = GetValidGlobalContext();
1549 EVENT(context, GLVertexAttrib1d, "context = %d, index = %u, x = %f", CID(context), index, x);
1550
1551 if (context)
1552 {
1553 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1554 bool isCallValid =
1555 (context->skipValidation() ||
1556 ValidateVertexAttrib1d(context, angle::EntryPoint::GLVertexAttrib1d, index, x));
1557 if (isCallValid)
1558 {
1559 context->vertexAttrib1d(index, x);
1560 }
1561 ANGLE_CAPTURE(VertexAttrib1d, isCallValid, context, index, x);
1562 }
1563 else
1564 {
1565 GenerateContextLostErrorOnCurrentGlobalContext();
1566 }
1567 }
1568
GL_VertexAttrib1dv(GLuint index,const GLdouble * v)1569 void GL_APIENTRY GL_VertexAttrib1dv(GLuint index, const GLdouble *v)
1570 {
1571 Context *context = GetValidGlobalContext();
1572 EVENT(context, GLVertexAttrib1dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1573 CID(context), index, (uintptr_t)v);
1574
1575 if (context)
1576 {
1577 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1578 bool isCallValid =
1579 (context->skipValidation() ||
1580 ValidateVertexAttrib1dv(context, angle::EntryPoint::GLVertexAttrib1dv, index, v));
1581 if (isCallValid)
1582 {
1583 context->vertexAttrib1dv(index, v);
1584 }
1585 ANGLE_CAPTURE(VertexAttrib1dv, isCallValid, context, index, v);
1586 }
1587 else
1588 {
1589 GenerateContextLostErrorOnCurrentGlobalContext();
1590 }
1591 }
1592
GL_VertexAttrib1f(GLuint index,GLfloat x)1593 void GL_APIENTRY GL_VertexAttrib1f(GLuint index, GLfloat x)
1594 {
1595 Context *context = GetValidGlobalContext();
1596 EVENT(context, GLVertexAttrib1f, "context = %d, index = %u, x = %f", CID(context), index, x);
1597
1598 if (context)
1599 {
1600 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1601 bool isCallValid =
1602 (context->skipValidation() ||
1603 ValidateVertexAttrib1f(context, angle::EntryPoint::GLVertexAttrib1f, index, x));
1604 if (isCallValid)
1605 {
1606 context->vertexAttrib1f(index, x);
1607 }
1608 ANGLE_CAPTURE(VertexAttrib1f, isCallValid, context, index, x);
1609 }
1610 else
1611 {
1612 GenerateContextLostErrorOnCurrentGlobalContext();
1613 }
1614 }
1615
GL_VertexAttrib1fv(GLuint index,const GLfloat * v)1616 void GL_APIENTRY GL_VertexAttrib1fv(GLuint index, const GLfloat *v)
1617 {
1618 Context *context = GetValidGlobalContext();
1619 EVENT(context, GLVertexAttrib1fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1620 CID(context), index, (uintptr_t)v);
1621
1622 if (context)
1623 {
1624 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1625 bool isCallValid =
1626 (context->skipValidation() ||
1627 ValidateVertexAttrib1fv(context, angle::EntryPoint::GLVertexAttrib1fv, index, v));
1628 if (isCallValid)
1629 {
1630 context->vertexAttrib1fv(index, v);
1631 }
1632 ANGLE_CAPTURE(VertexAttrib1fv, isCallValid, context, index, v);
1633 }
1634 else
1635 {
1636 GenerateContextLostErrorOnCurrentGlobalContext();
1637 }
1638 }
1639
GL_VertexAttrib1s(GLuint index,GLshort x)1640 void GL_APIENTRY GL_VertexAttrib1s(GLuint index, GLshort x)
1641 {
1642 Context *context = GetValidGlobalContext();
1643 EVENT(context, GLVertexAttrib1s, "context = %d, index = %u, x = %d", CID(context), index, x);
1644
1645 if (context)
1646 {
1647 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1648 bool isCallValid =
1649 (context->skipValidation() ||
1650 ValidateVertexAttrib1s(context, angle::EntryPoint::GLVertexAttrib1s, index, x));
1651 if (isCallValid)
1652 {
1653 context->vertexAttrib1s(index, x);
1654 }
1655 ANGLE_CAPTURE(VertexAttrib1s, isCallValid, context, index, x);
1656 }
1657 else
1658 {
1659 GenerateContextLostErrorOnCurrentGlobalContext();
1660 }
1661 }
1662
GL_VertexAttrib1sv(GLuint index,const GLshort * v)1663 void GL_APIENTRY GL_VertexAttrib1sv(GLuint index, const GLshort *v)
1664 {
1665 Context *context = GetValidGlobalContext();
1666 EVENT(context, GLVertexAttrib1sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1667 CID(context), index, (uintptr_t)v);
1668
1669 if (context)
1670 {
1671 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1672 bool isCallValid =
1673 (context->skipValidation() ||
1674 ValidateVertexAttrib1sv(context, angle::EntryPoint::GLVertexAttrib1sv, index, v));
1675 if (isCallValid)
1676 {
1677 context->vertexAttrib1sv(index, v);
1678 }
1679 ANGLE_CAPTURE(VertexAttrib1sv, isCallValid, context, index, v);
1680 }
1681 else
1682 {
1683 GenerateContextLostErrorOnCurrentGlobalContext();
1684 }
1685 }
1686
GL_VertexAttrib2d(GLuint index,GLdouble x,GLdouble y)1687 void GL_APIENTRY GL_VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
1688 {
1689 Context *context = GetValidGlobalContext();
1690 EVENT(context, GLVertexAttrib2d, "context = %d, index = %u, x = %f, y = %f", CID(context),
1691 index, x, y);
1692
1693 if (context)
1694 {
1695 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1696 bool isCallValid =
1697 (context->skipValidation() ||
1698 ValidateVertexAttrib2d(context, angle::EntryPoint::GLVertexAttrib2d, index, x, y));
1699 if (isCallValid)
1700 {
1701 context->vertexAttrib2d(index, x, y);
1702 }
1703 ANGLE_CAPTURE(VertexAttrib2d, isCallValid, context, index, x, y);
1704 }
1705 else
1706 {
1707 GenerateContextLostErrorOnCurrentGlobalContext();
1708 }
1709 }
1710
GL_VertexAttrib2dv(GLuint index,const GLdouble * v)1711 void GL_APIENTRY GL_VertexAttrib2dv(GLuint index, const GLdouble *v)
1712 {
1713 Context *context = GetValidGlobalContext();
1714 EVENT(context, GLVertexAttrib2dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1715 CID(context), index, (uintptr_t)v);
1716
1717 if (context)
1718 {
1719 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1720 bool isCallValid =
1721 (context->skipValidation() ||
1722 ValidateVertexAttrib2dv(context, angle::EntryPoint::GLVertexAttrib2dv, index, v));
1723 if (isCallValid)
1724 {
1725 context->vertexAttrib2dv(index, v);
1726 }
1727 ANGLE_CAPTURE(VertexAttrib2dv, isCallValid, context, index, v);
1728 }
1729 else
1730 {
1731 GenerateContextLostErrorOnCurrentGlobalContext();
1732 }
1733 }
1734
GL_VertexAttrib2f(GLuint index,GLfloat x,GLfloat y)1735 void GL_APIENTRY GL_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
1736 {
1737 Context *context = GetValidGlobalContext();
1738 EVENT(context, GLVertexAttrib2f, "context = %d, index = %u, x = %f, y = %f", CID(context),
1739 index, x, y);
1740
1741 if (context)
1742 {
1743 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1744 bool isCallValid =
1745 (context->skipValidation() ||
1746 ValidateVertexAttrib2f(context, angle::EntryPoint::GLVertexAttrib2f, index, x, y));
1747 if (isCallValid)
1748 {
1749 context->vertexAttrib2f(index, x, y);
1750 }
1751 ANGLE_CAPTURE(VertexAttrib2f, isCallValid, context, index, x, y);
1752 }
1753 else
1754 {
1755 GenerateContextLostErrorOnCurrentGlobalContext();
1756 }
1757 }
1758
GL_VertexAttrib2fv(GLuint index,const GLfloat * v)1759 void GL_APIENTRY GL_VertexAttrib2fv(GLuint index, const GLfloat *v)
1760 {
1761 Context *context = GetValidGlobalContext();
1762 EVENT(context, GLVertexAttrib2fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1763 CID(context), index, (uintptr_t)v);
1764
1765 if (context)
1766 {
1767 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1768 bool isCallValid =
1769 (context->skipValidation() ||
1770 ValidateVertexAttrib2fv(context, angle::EntryPoint::GLVertexAttrib2fv, index, v));
1771 if (isCallValid)
1772 {
1773 context->vertexAttrib2fv(index, v);
1774 }
1775 ANGLE_CAPTURE(VertexAttrib2fv, isCallValid, context, index, v);
1776 }
1777 else
1778 {
1779 GenerateContextLostErrorOnCurrentGlobalContext();
1780 }
1781 }
1782
GL_VertexAttrib2s(GLuint index,GLshort x,GLshort y)1783 void GL_APIENTRY GL_VertexAttrib2s(GLuint index, GLshort x, GLshort y)
1784 {
1785 Context *context = GetValidGlobalContext();
1786 EVENT(context, GLVertexAttrib2s, "context = %d, index = %u, x = %d, y = %d", CID(context),
1787 index, x, y);
1788
1789 if (context)
1790 {
1791 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1792 bool isCallValid =
1793 (context->skipValidation() ||
1794 ValidateVertexAttrib2s(context, angle::EntryPoint::GLVertexAttrib2s, index, x, y));
1795 if (isCallValid)
1796 {
1797 context->vertexAttrib2s(index, x, y);
1798 }
1799 ANGLE_CAPTURE(VertexAttrib2s, isCallValid, context, index, x, y);
1800 }
1801 else
1802 {
1803 GenerateContextLostErrorOnCurrentGlobalContext();
1804 }
1805 }
1806
GL_VertexAttrib2sv(GLuint index,const GLshort * v)1807 void GL_APIENTRY GL_VertexAttrib2sv(GLuint index, const GLshort *v)
1808 {
1809 Context *context = GetValidGlobalContext();
1810 EVENT(context, GLVertexAttrib2sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1811 CID(context), index, (uintptr_t)v);
1812
1813 if (context)
1814 {
1815 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1816 bool isCallValid =
1817 (context->skipValidation() ||
1818 ValidateVertexAttrib2sv(context, angle::EntryPoint::GLVertexAttrib2sv, index, v));
1819 if (isCallValid)
1820 {
1821 context->vertexAttrib2sv(index, v);
1822 }
1823 ANGLE_CAPTURE(VertexAttrib2sv, isCallValid, context, index, v);
1824 }
1825 else
1826 {
1827 GenerateContextLostErrorOnCurrentGlobalContext();
1828 }
1829 }
1830
GL_VertexAttrib3d(GLuint index,GLdouble x,GLdouble y,GLdouble z)1831 void GL_APIENTRY GL_VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1832 {
1833 Context *context = GetValidGlobalContext();
1834 EVENT(context, GLVertexAttrib3d, "context = %d, index = %u, x = %f, y = %f, z = %f",
1835 CID(context), index, x, y, z);
1836
1837 if (context)
1838 {
1839 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1840 bool isCallValid =
1841 (context->skipValidation() ||
1842 ValidateVertexAttrib3d(context, angle::EntryPoint::GLVertexAttrib3d, index, x, y, z));
1843 if (isCallValid)
1844 {
1845 context->vertexAttrib3d(index, x, y, z);
1846 }
1847 ANGLE_CAPTURE(VertexAttrib3d, isCallValid, context, index, x, y, z);
1848 }
1849 else
1850 {
1851 GenerateContextLostErrorOnCurrentGlobalContext();
1852 }
1853 }
1854
GL_VertexAttrib3dv(GLuint index,const GLdouble * v)1855 void GL_APIENTRY GL_VertexAttrib3dv(GLuint index, const GLdouble *v)
1856 {
1857 Context *context = GetValidGlobalContext();
1858 EVENT(context, GLVertexAttrib3dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1859 CID(context), index, (uintptr_t)v);
1860
1861 if (context)
1862 {
1863 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1864 bool isCallValid =
1865 (context->skipValidation() ||
1866 ValidateVertexAttrib3dv(context, angle::EntryPoint::GLVertexAttrib3dv, index, v));
1867 if (isCallValid)
1868 {
1869 context->vertexAttrib3dv(index, v);
1870 }
1871 ANGLE_CAPTURE(VertexAttrib3dv, isCallValid, context, index, v);
1872 }
1873 else
1874 {
1875 GenerateContextLostErrorOnCurrentGlobalContext();
1876 }
1877 }
1878
GL_VertexAttrib3f(GLuint index,GLfloat x,GLfloat y,GLfloat z)1879 void GL_APIENTRY GL_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
1880 {
1881 Context *context = GetValidGlobalContext();
1882 EVENT(context, GLVertexAttrib3f, "context = %d, index = %u, x = %f, y = %f, z = %f",
1883 CID(context), index, x, y, z);
1884
1885 if (context)
1886 {
1887 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1888 bool isCallValid =
1889 (context->skipValidation() ||
1890 ValidateVertexAttrib3f(context, angle::EntryPoint::GLVertexAttrib3f, index, x, y, z));
1891 if (isCallValid)
1892 {
1893 context->vertexAttrib3f(index, x, y, z);
1894 }
1895 ANGLE_CAPTURE(VertexAttrib3f, isCallValid, context, index, x, y, z);
1896 }
1897 else
1898 {
1899 GenerateContextLostErrorOnCurrentGlobalContext();
1900 }
1901 }
1902
GL_VertexAttrib3fv(GLuint index,const GLfloat * v)1903 void GL_APIENTRY GL_VertexAttrib3fv(GLuint index, const GLfloat *v)
1904 {
1905 Context *context = GetValidGlobalContext();
1906 EVENT(context, GLVertexAttrib3fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1907 CID(context), index, (uintptr_t)v);
1908
1909 if (context)
1910 {
1911 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1912 bool isCallValid =
1913 (context->skipValidation() ||
1914 ValidateVertexAttrib3fv(context, angle::EntryPoint::GLVertexAttrib3fv, index, v));
1915 if (isCallValid)
1916 {
1917 context->vertexAttrib3fv(index, v);
1918 }
1919 ANGLE_CAPTURE(VertexAttrib3fv, isCallValid, context, index, v);
1920 }
1921 else
1922 {
1923 GenerateContextLostErrorOnCurrentGlobalContext();
1924 }
1925 }
1926
GL_VertexAttrib3s(GLuint index,GLshort x,GLshort y,GLshort z)1927 void GL_APIENTRY GL_VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
1928 {
1929 Context *context = GetValidGlobalContext();
1930 EVENT(context, GLVertexAttrib3s, "context = %d, index = %u, x = %d, y = %d, z = %d",
1931 CID(context), index, x, y, z);
1932
1933 if (context)
1934 {
1935 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1936 bool isCallValid =
1937 (context->skipValidation() ||
1938 ValidateVertexAttrib3s(context, angle::EntryPoint::GLVertexAttrib3s, index, x, y, z));
1939 if (isCallValid)
1940 {
1941 context->vertexAttrib3s(index, x, y, z);
1942 }
1943 ANGLE_CAPTURE(VertexAttrib3s, isCallValid, context, index, x, y, z);
1944 }
1945 else
1946 {
1947 GenerateContextLostErrorOnCurrentGlobalContext();
1948 }
1949 }
1950
GL_VertexAttrib3sv(GLuint index,const GLshort * v)1951 void GL_APIENTRY GL_VertexAttrib3sv(GLuint index, const GLshort *v)
1952 {
1953 Context *context = GetValidGlobalContext();
1954 EVENT(context, GLVertexAttrib3sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1955 CID(context), index, (uintptr_t)v);
1956
1957 if (context)
1958 {
1959 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1960 bool isCallValid =
1961 (context->skipValidation() ||
1962 ValidateVertexAttrib3sv(context, angle::EntryPoint::GLVertexAttrib3sv, index, v));
1963 if (isCallValid)
1964 {
1965 context->vertexAttrib3sv(index, v);
1966 }
1967 ANGLE_CAPTURE(VertexAttrib3sv, isCallValid, context, index, v);
1968 }
1969 else
1970 {
1971 GenerateContextLostErrorOnCurrentGlobalContext();
1972 }
1973 }
1974
GL_VertexAttrib4Nbv(GLuint index,const GLbyte * v)1975 void GL_APIENTRY GL_VertexAttrib4Nbv(GLuint index, const GLbyte *v)
1976 {
1977 Context *context = GetValidGlobalContext();
1978 EVENT(context, GLVertexAttrib4Nbv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
1979 CID(context), index, (uintptr_t)v);
1980
1981 if (context)
1982 {
1983 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1984 bool isCallValid =
1985 (context->skipValidation() ||
1986 ValidateVertexAttrib4Nbv(context, angle::EntryPoint::GLVertexAttrib4Nbv, index, v));
1987 if (isCallValid)
1988 {
1989 context->vertexAttrib4Nbv(index, v);
1990 }
1991 ANGLE_CAPTURE(VertexAttrib4Nbv, isCallValid, context, index, v);
1992 }
1993 else
1994 {
1995 GenerateContextLostErrorOnCurrentGlobalContext();
1996 }
1997 }
1998
GL_VertexAttrib4Niv(GLuint index,const GLint * v)1999 void GL_APIENTRY GL_VertexAttrib4Niv(GLuint index, const GLint *v)
2000 {
2001 Context *context = GetValidGlobalContext();
2002 EVENT(context, GLVertexAttrib4Niv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2003 CID(context), index, (uintptr_t)v);
2004
2005 if (context)
2006 {
2007 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2008 bool isCallValid =
2009 (context->skipValidation() ||
2010 ValidateVertexAttrib4Niv(context, angle::EntryPoint::GLVertexAttrib4Niv, index, v));
2011 if (isCallValid)
2012 {
2013 context->vertexAttrib4Niv(index, v);
2014 }
2015 ANGLE_CAPTURE(VertexAttrib4Niv, isCallValid, context, index, v);
2016 }
2017 else
2018 {
2019 GenerateContextLostErrorOnCurrentGlobalContext();
2020 }
2021 }
2022
GL_VertexAttrib4Nsv(GLuint index,const GLshort * v)2023 void GL_APIENTRY GL_VertexAttrib4Nsv(GLuint index, const GLshort *v)
2024 {
2025 Context *context = GetValidGlobalContext();
2026 EVENT(context, GLVertexAttrib4Nsv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2027 CID(context), index, (uintptr_t)v);
2028
2029 if (context)
2030 {
2031 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2032 bool isCallValid =
2033 (context->skipValidation() ||
2034 ValidateVertexAttrib4Nsv(context, angle::EntryPoint::GLVertexAttrib4Nsv, index, v));
2035 if (isCallValid)
2036 {
2037 context->vertexAttrib4Nsv(index, v);
2038 }
2039 ANGLE_CAPTURE(VertexAttrib4Nsv, isCallValid, context, index, v);
2040 }
2041 else
2042 {
2043 GenerateContextLostErrorOnCurrentGlobalContext();
2044 }
2045 }
2046
GL_VertexAttrib4Nub(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)2047 void GL_APIENTRY GL_VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
2048 {
2049 Context *context = GetValidGlobalContext();
2050 EVENT(context, GLVertexAttrib4Nub, "context = %d, index = %u, x = %d, y = %d, z = %d, w = %d",
2051 CID(context), index, x, y, z, w);
2052
2053 if (context)
2054 {
2055 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2056 bool isCallValid = (context->skipValidation() ||
2057 ValidateVertexAttrib4Nub(context, angle::EntryPoint::GLVertexAttrib4Nub,
2058 index, x, y, z, w));
2059 if (isCallValid)
2060 {
2061 context->vertexAttrib4Nub(index, x, y, z, w);
2062 }
2063 ANGLE_CAPTURE(VertexAttrib4Nub, isCallValid, context, index, x, y, z, w);
2064 }
2065 else
2066 {
2067 GenerateContextLostErrorOnCurrentGlobalContext();
2068 }
2069 }
2070
GL_VertexAttrib4Nubv(GLuint index,const GLubyte * v)2071 void GL_APIENTRY GL_VertexAttrib4Nubv(GLuint index, const GLubyte *v)
2072 {
2073 Context *context = GetValidGlobalContext();
2074 EVENT(context, GLVertexAttrib4Nubv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2075 CID(context), index, (uintptr_t)v);
2076
2077 if (context)
2078 {
2079 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2080 bool isCallValid =
2081 (context->skipValidation() ||
2082 ValidateVertexAttrib4Nubv(context, angle::EntryPoint::GLVertexAttrib4Nubv, index, v));
2083 if (isCallValid)
2084 {
2085 context->vertexAttrib4Nubv(index, v);
2086 }
2087 ANGLE_CAPTURE(VertexAttrib4Nubv, isCallValid, context, index, v);
2088 }
2089 else
2090 {
2091 GenerateContextLostErrorOnCurrentGlobalContext();
2092 }
2093 }
2094
GL_VertexAttrib4Nuiv(GLuint index,const GLuint * v)2095 void GL_APIENTRY GL_VertexAttrib4Nuiv(GLuint index, const GLuint *v)
2096 {
2097 Context *context = GetValidGlobalContext();
2098 EVENT(context, GLVertexAttrib4Nuiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2099 CID(context), index, (uintptr_t)v);
2100
2101 if (context)
2102 {
2103 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2104 bool isCallValid =
2105 (context->skipValidation() ||
2106 ValidateVertexAttrib4Nuiv(context, angle::EntryPoint::GLVertexAttrib4Nuiv, index, v));
2107 if (isCallValid)
2108 {
2109 context->vertexAttrib4Nuiv(index, v);
2110 }
2111 ANGLE_CAPTURE(VertexAttrib4Nuiv, isCallValid, context, index, v);
2112 }
2113 else
2114 {
2115 GenerateContextLostErrorOnCurrentGlobalContext();
2116 }
2117 }
2118
GL_VertexAttrib4Nusv(GLuint index,const GLushort * v)2119 void GL_APIENTRY GL_VertexAttrib4Nusv(GLuint index, const GLushort *v)
2120 {
2121 Context *context = GetValidGlobalContext();
2122 EVENT(context, GLVertexAttrib4Nusv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2123 CID(context), index, (uintptr_t)v);
2124
2125 if (context)
2126 {
2127 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2128 bool isCallValid =
2129 (context->skipValidation() ||
2130 ValidateVertexAttrib4Nusv(context, angle::EntryPoint::GLVertexAttrib4Nusv, index, v));
2131 if (isCallValid)
2132 {
2133 context->vertexAttrib4Nusv(index, v);
2134 }
2135 ANGLE_CAPTURE(VertexAttrib4Nusv, isCallValid, context, index, v);
2136 }
2137 else
2138 {
2139 GenerateContextLostErrorOnCurrentGlobalContext();
2140 }
2141 }
2142
GL_VertexAttrib4bv(GLuint index,const GLbyte * v)2143 void GL_APIENTRY GL_VertexAttrib4bv(GLuint index, const GLbyte *v)
2144 {
2145 Context *context = GetValidGlobalContext();
2146 EVENT(context, GLVertexAttrib4bv, "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() ||
2154 ValidateVertexAttrib4bv(context, angle::EntryPoint::GLVertexAttrib4bv, index, v));
2155 if (isCallValid)
2156 {
2157 context->vertexAttrib4bv(index, v);
2158 }
2159 ANGLE_CAPTURE(VertexAttrib4bv, isCallValid, context, index, v);
2160 }
2161 else
2162 {
2163 GenerateContextLostErrorOnCurrentGlobalContext();
2164 }
2165 }
2166
GL_VertexAttrib4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)2167 void GL_APIENTRY GL_VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2168 {
2169 Context *context = GetValidGlobalContext();
2170 EVENT(context, GLVertexAttrib4d, "context = %d, index = %u, x = %f, y = %f, z = %f, w = %f",
2171 CID(context), index, x, y, z, w);
2172
2173 if (context)
2174 {
2175 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2176 bool isCallValid = (context->skipValidation() ||
2177 ValidateVertexAttrib4d(context, angle::EntryPoint::GLVertexAttrib4d,
2178 index, x, y, z, w));
2179 if (isCallValid)
2180 {
2181 context->vertexAttrib4d(index, x, y, z, w);
2182 }
2183 ANGLE_CAPTURE(VertexAttrib4d, isCallValid, context, index, x, y, z, w);
2184 }
2185 else
2186 {
2187 GenerateContextLostErrorOnCurrentGlobalContext();
2188 }
2189 }
2190
GL_VertexAttrib4dv(GLuint index,const GLdouble * v)2191 void GL_APIENTRY GL_VertexAttrib4dv(GLuint index, const GLdouble *v)
2192 {
2193 Context *context = GetValidGlobalContext();
2194 EVENT(context, GLVertexAttrib4dv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2195 CID(context), index, (uintptr_t)v);
2196
2197 if (context)
2198 {
2199 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2200 bool isCallValid =
2201 (context->skipValidation() ||
2202 ValidateVertexAttrib4dv(context, angle::EntryPoint::GLVertexAttrib4dv, index, v));
2203 if (isCallValid)
2204 {
2205 context->vertexAttrib4dv(index, v);
2206 }
2207 ANGLE_CAPTURE(VertexAttrib4dv, isCallValid, context, index, v);
2208 }
2209 else
2210 {
2211 GenerateContextLostErrorOnCurrentGlobalContext();
2212 }
2213 }
2214
GL_VertexAttrib4f(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)2215 void GL_APIENTRY GL_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2216 {
2217 Context *context = GetValidGlobalContext();
2218 EVENT(context, GLVertexAttrib4f, "context = %d, index = %u, x = %f, y = %f, z = %f, w = %f",
2219 CID(context), index, x, y, z, w);
2220
2221 if (context)
2222 {
2223 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2224 bool isCallValid = (context->skipValidation() ||
2225 ValidateVertexAttrib4f(context, angle::EntryPoint::GLVertexAttrib4f,
2226 index, x, y, z, w));
2227 if (isCallValid)
2228 {
2229 context->vertexAttrib4f(index, x, y, z, w);
2230 }
2231 ANGLE_CAPTURE(VertexAttrib4f, isCallValid, context, index, x, y, z, w);
2232 }
2233 else
2234 {
2235 GenerateContextLostErrorOnCurrentGlobalContext();
2236 }
2237 }
2238
GL_VertexAttrib4fv(GLuint index,const GLfloat * v)2239 void GL_APIENTRY GL_VertexAttrib4fv(GLuint index, const GLfloat *v)
2240 {
2241 Context *context = GetValidGlobalContext();
2242 EVENT(context, GLVertexAttrib4fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2243 CID(context), index, (uintptr_t)v);
2244
2245 if (context)
2246 {
2247 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2248 bool isCallValid =
2249 (context->skipValidation() ||
2250 ValidateVertexAttrib4fv(context, angle::EntryPoint::GLVertexAttrib4fv, index, v));
2251 if (isCallValid)
2252 {
2253 context->vertexAttrib4fv(index, v);
2254 }
2255 ANGLE_CAPTURE(VertexAttrib4fv, isCallValid, context, index, v);
2256 }
2257 else
2258 {
2259 GenerateContextLostErrorOnCurrentGlobalContext();
2260 }
2261 }
2262
GL_VertexAttrib4iv(GLuint index,const GLint * v)2263 void GL_APIENTRY GL_VertexAttrib4iv(GLuint index, const GLint *v)
2264 {
2265 Context *context = GetValidGlobalContext();
2266 EVENT(context, GLVertexAttrib4iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2267 CID(context), index, (uintptr_t)v);
2268
2269 if (context)
2270 {
2271 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2272 bool isCallValid =
2273 (context->skipValidation() ||
2274 ValidateVertexAttrib4iv(context, angle::EntryPoint::GLVertexAttrib4iv, index, v));
2275 if (isCallValid)
2276 {
2277 context->vertexAttrib4iv(index, v);
2278 }
2279 ANGLE_CAPTURE(VertexAttrib4iv, isCallValid, context, index, v);
2280 }
2281 else
2282 {
2283 GenerateContextLostErrorOnCurrentGlobalContext();
2284 }
2285 }
2286
GL_VertexAttrib4s(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)2287 void GL_APIENTRY GL_VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
2288 {
2289 Context *context = GetValidGlobalContext();
2290 EVENT(context, GLVertexAttrib4s, "context = %d, index = %u, x = %d, y = %d, z = %d, w = %d",
2291 CID(context), index, x, y, z, w);
2292
2293 if (context)
2294 {
2295 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2296 bool isCallValid = (context->skipValidation() ||
2297 ValidateVertexAttrib4s(context, angle::EntryPoint::GLVertexAttrib4s,
2298 index, x, y, z, w));
2299 if (isCallValid)
2300 {
2301 context->vertexAttrib4s(index, x, y, z, w);
2302 }
2303 ANGLE_CAPTURE(VertexAttrib4s, isCallValid, context, index, x, y, z, w);
2304 }
2305 else
2306 {
2307 GenerateContextLostErrorOnCurrentGlobalContext();
2308 }
2309 }
2310
GL_VertexAttrib4sv(GLuint index,const GLshort * v)2311 void GL_APIENTRY GL_VertexAttrib4sv(GLuint index, const GLshort *v)
2312 {
2313 Context *context = GetValidGlobalContext();
2314 EVENT(context, GLVertexAttrib4sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2315 CID(context), index, (uintptr_t)v);
2316
2317 if (context)
2318 {
2319 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2320 bool isCallValid =
2321 (context->skipValidation() ||
2322 ValidateVertexAttrib4sv(context, angle::EntryPoint::GLVertexAttrib4sv, index, v));
2323 if (isCallValid)
2324 {
2325 context->vertexAttrib4sv(index, v);
2326 }
2327 ANGLE_CAPTURE(VertexAttrib4sv, isCallValid, context, index, v);
2328 }
2329 else
2330 {
2331 GenerateContextLostErrorOnCurrentGlobalContext();
2332 }
2333 }
2334
GL_VertexAttrib4ubv(GLuint index,const GLubyte * v)2335 void GL_APIENTRY GL_VertexAttrib4ubv(GLuint index, const GLubyte *v)
2336 {
2337 Context *context = GetValidGlobalContext();
2338 EVENT(context, GLVertexAttrib4ubv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2339 CID(context), index, (uintptr_t)v);
2340
2341 if (context)
2342 {
2343 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2344 bool isCallValid =
2345 (context->skipValidation() ||
2346 ValidateVertexAttrib4ubv(context, angle::EntryPoint::GLVertexAttrib4ubv, index, v));
2347 if (isCallValid)
2348 {
2349 context->vertexAttrib4ubv(index, v);
2350 }
2351 ANGLE_CAPTURE(VertexAttrib4ubv, isCallValid, context, index, v);
2352 }
2353 else
2354 {
2355 GenerateContextLostErrorOnCurrentGlobalContext();
2356 }
2357 }
2358
GL_VertexAttrib4uiv(GLuint index,const GLuint * v)2359 void GL_APIENTRY GL_VertexAttrib4uiv(GLuint index, const GLuint *v)
2360 {
2361 Context *context = GetValidGlobalContext();
2362 EVENT(context, GLVertexAttrib4uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2363 CID(context), index, (uintptr_t)v);
2364
2365 if (context)
2366 {
2367 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2368 bool isCallValid =
2369 (context->skipValidation() ||
2370 ValidateVertexAttrib4uiv(context, angle::EntryPoint::GLVertexAttrib4uiv, index, v));
2371 if (isCallValid)
2372 {
2373 context->vertexAttrib4uiv(index, v);
2374 }
2375 ANGLE_CAPTURE(VertexAttrib4uiv, isCallValid, context, index, v);
2376 }
2377 else
2378 {
2379 GenerateContextLostErrorOnCurrentGlobalContext();
2380 }
2381 }
2382
GL_VertexAttrib4usv(GLuint index,const GLushort * v)2383 void GL_APIENTRY GL_VertexAttrib4usv(GLuint index, const GLushort *v)
2384 {
2385 Context *context = GetValidGlobalContext();
2386 EVENT(context, GLVertexAttrib4usv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2387 CID(context), index, (uintptr_t)v);
2388
2389 if (context)
2390 {
2391 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2392 bool isCallValid =
2393 (context->skipValidation() ||
2394 ValidateVertexAttrib4usv(context, angle::EntryPoint::GLVertexAttrib4usv, index, v));
2395 if (isCallValid)
2396 {
2397 context->vertexAttrib4usv(index, v);
2398 }
2399 ANGLE_CAPTURE(VertexAttrib4usv, isCallValid, context, index, v);
2400 }
2401 else
2402 {
2403 GenerateContextLostErrorOnCurrentGlobalContext();
2404 }
2405 }
2406
GL_VertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void * pointer)2407 void GL_APIENTRY GL_VertexAttribPointer(GLuint index,
2408 GLint size,
2409 GLenum type,
2410 GLboolean normalized,
2411 GLsizei stride,
2412 const void *pointer)
2413 {
2414 Context *context = GetValidGlobalContext();
2415 EVENT(context, GLVertexAttribPointer,
2416 "context = %d, index = %u, size = %d, type = %s, normalized = %s, stride = %d, pointer = "
2417 "0x%016" PRIxPTR "",
2418 CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
2419 GLbooleanToString(normalized), stride, (uintptr_t)pointer);
2420
2421 if (context)
2422 {
2423 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
2424 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2425 bool isCallValid =
2426 (context->skipValidation() ||
2427 ValidateVertexAttribPointer(context, angle::EntryPoint::GLVertexAttribPointer, index,
2428 size, typePacked, normalized, stride, pointer));
2429 if (isCallValid)
2430 {
2431 context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
2432 }
2433 ANGLE_CAPTURE(VertexAttribPointer, isCallValid, context, index, size, typePacked,
2434 normalized, stride, pointer);
2435 }
2436 else
2437 {
2438 GenerateContextLostErrorOnCurrentGlobalContext();
2439 }
2440 }
2441
2442 // GL 2.1
GL_UniformMatrix2x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2443 void GL_APIENTRY GL_UniformMatrix2x3fv(GLint location,
2444 GLsizei count,
2445 GLboolean transpose,
2446 const GLfloat *value)
2447 {
2448 Context *context = GetValidGlobalContext();
2449 EVENT(context, GLUniformMatrix2x3fv,
2450 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2451 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2452
2453 if (context)
2454 {
2455 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2456 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2457 bool isCallValid =
2458 (context->skipValidation() ||
2459 ValidateUniformMatrix2x3fv(context, angle::EntryPoint::GLUniformMatrix2x3fv,
2460 locationPacked, count, transpose, value));
2461 if (isCallValid)
2462 {
2463 context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
2464 }
2465 ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
2466 value);
2467 }
2468 else
2469 {
2470 GenerateContextLostErrorOnCurrentGlobalContext();
2471 }
2472 }
2473
GL_UniformMatrix2x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2474 void GL_APIENTRY GL_UniformMatrix2x4fv(GLint location,
2475 GLsizei count,
2476 GLboolean transpose,
2477 const GLfloat *value)
2478 {
2479 Context *context = GetValidGlobalContext();
2480 EVENT(context, GLUniformMatrix2x4fv,
2481 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2482 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2483
2484 if (context)
2485 {
2486 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2487 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2488 bool isCallValid =
2489 (context->skipValidation() ||
2490 ValidateUniformMatrix2x4fv(context, angle::EntryPoint::GLUniformMatrix2x4fv,
2491 locationPacked, count, transpose, value));
2492 if (isCallValid)
2493 {
2494 context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
2495 }
2496 ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
2497 value);
2498 }
2499 else
2500 {
2501 GenerateContextLostErrorOnCurrentGlobalContext();
2502 }
2503 }
2504
GL_UniformMatrix3x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2505 void GL_APIENTRY GL_UniformMatrix3x2fv(GLint location,
2506 GLsizei count,
2507 GLboolean transpose,
2508 const GLfloat *value)
2509 {
2510 Context *context = GetValidGlobalContext();
2511 EVENT(context, GLUniformMatrix3x2fv,
2512 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2513 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2514
2515 if (context)
2516 {
2517 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2518 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2519 bool isCallValid =
2520 (context->skipValidation() ||
2521 ValidateUniformMatrix3x2fv(context, angle::EntryPoint::GLUniformMatrix3x2fv,
2522 locationPacked, count, transpose, value));
2523 if (isCallValid)
2524 {
2525 context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
2526 }
2527 ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
2528 value);
2529 }
2530 else
2531 {
2532 GenerateContextLostErrorOnCurrentGlobalContext();
2533 }
2534 }
2535
GL_UniformMatrix3x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2536 void GL_APIENTRY GL_UniformMatrix3x4fv(GLint location,
2537 GLsizei count,
2538 GLboolean transpose,
2539 const GLfloat *value)
2540 {
2541 Context *context = GetValidGlobalContext();
2542 EVENT(context, GLUniformMatrix3x4fv,
2543 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2544 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2545
2546 if (context)
2547 {
2548 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2549 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2550 bool isCallValid =
2551 (context->skipValidation() ||
2552 ValidateUniformMatrix3x4fv(context, angle::EntryPoint::GLUniformMatrix3x4fv,
2553 locationPacked, count, transpose, value));
2554 if (isCallValid)
2555 {
2556 context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
2557 }
2558 ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
2559 value);
2560 }
2561 else
2562 {
2563 GenerateContextLostErrorOnCurrentGlobalContext();
2564 }
2565 }
2566
GL_UniformMatrix4x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2567 void GL_APIENTRY GL_UniformMatrix4x2fv(GLint location,
2568 GLsizei count,
2569 GLboolean transpose,
2570 const GLfloat *value)
2571 {
2572 Context *context = GetValidGlobalContext();
2573 EVENT(context, GLUniformMatrix4x2fv,
2574 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2575 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2576
2577 if (context)
2578 {
2579 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2580 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2581 bool isCallValid =
2582 (context->skipValidation() ||
2583 ValidateUniformMatrix4x2fv(context, angle::EntryPoint::GLUniformMatrix4x2fv,
2584 locationPacked, count, transpose, value));
2585 if (isCallValid)
2586 {
2587 context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
2588 }
2589 ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
2590 value);
2591 }
2592 else
2593 {
2594 GenerateContextLostErrorOnCurrentGlobalContext();
2595 }
2596 }
2597
GL_UniformMatrix4x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2598 void GL_APIENTRY GL_UniformMatrix4x3fv(GLint location,
2599 GLsizei count,
2600 GLboolean transpose,
2601 const GLfloat *value)
2602 {
2603 Context *context = GetValidGlobalContext();
2604 EVENT(context, GLUniformMatrix4x3fv,
2605 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2606 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2607
2608 if (context)
2609 {
2610 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2611 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2612 bool isCallValid =
2613 (context->skipValidation() ||
2614 ValidateUniformMatrix4x3fv(context, angle::EntryPoint::GLUniformMatrix4x3fv,
2615 locationPacked, count, transpose, value));
2616 if (isCallValid)
2617 {
2618 context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
2619 }
2620 ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
2621 value);
2622 }
2623 else
2624 {
2625 GenerateContextLostErrorOnCurrentGlobalContext();
2626 }
2627 }
2628
2629 } // extern "C"
2630