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_0_autogen.cpp:
9 // Defines the GL 2.0 entry points.
10
11 #include "libGL/entry_points_gl_2_0_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/entry_points_utils.h"
16 #include "libANGLE/gl_enum_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 namespace gl
29 {
AttachShader(GLuint program,GLuint shader)30 void GL_APIENTRY AttachShader(GLuint program, GLuint shader)
31 {
32 Context *context = GetValidGlobalContext();
33 EVENT("glAttachShader", "context = %d, GLuint program = %u, GLuint shader = %u", CID(context),
34 program, shader);
35
36 if (context)
37 {
38 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
39 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
40 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
41 bool isCallValid = (context->skipValidation() ||
42 ValidateAttachShader(context, programPacked, shaderPacked));
43 if (isCallValid)
44 {
45 context->attachShader(programPacked, shaderPacked);
46 }
47 ANGLE_CAPTURE(AttachShader, isCallValid, context, programPacked, shaderPacked);
48 }
49 }
50
BindAttribLocation(GLuint program,GLuint index,const GLchar * name)51 void GL_APIENTRY BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
52 {
53 Context *context = GetValidGlobalContext();
54 EVENT(
55 "glBindAttribLocation",
56 "context = %d, GLuint program = %u, GLuint index = %u, const GLchar *name = 0x%016" PRIxPTR
57 "",
58 CID(context), program, index, (uintptr_t)name);
59
60 if (context)
61 {
62 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
63 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
64 bool isCallValid = (context->skipValidation() ||
65 ValidateBindAttribLocation(context, programPacked, index, name));
66 if (isCallValid)
67 {
68 context->bindAttribLocation(programPacked, index, name);
69 }
70 ANGLE_CAPTURE(BindAttribLocation, isCallValid, context, programPacked, index, name);
71 }
72 }
73
BlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)74 void GL_APIENTRY BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
75 {
76 Context *context = GetValidGlobalContext();
77 EVENT("glBlendEquationSeparate", "context = %d, GLenum modeRGB = %s, GLenum modeAlpha = %s",
78 CID(context), GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
79 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
80
81 if (context)
82 {
83 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
84 bool isCallValid = (context->skipValidation() ||
85 ValidateBlendEquationSeparate(context, modeRGB, modeAlpha));
86 if (isCallValid)
87 {
88 context->blendEquationSeparate(modeRGB, modeAlpha);
89 }
90 ANGLE_CAPTURE(BlendEquationSeparate, isCallValid, context, modeRGB, modeAlpha);
91 }
92 }
93
CompileShader(GLuint shader)94 void GL_APIENTRY CompileShader(GLuint shader)
95 {
96 Context *context = GetValidGlobalContext();
97 EVENT("glCompileShader", "context = %d, GLuint shader = %u", CID(context), shader);
98
99 if (context)
100 {
101 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
102 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
103 bool isCallValid =
104 (context->skipValidation() || ValidateCompileShader(context, shaderPacked));
105 if (isCallValid)
106 {
107 context->compileShader(shaderPacked);
108 }
109 ANGLE_CAPTURE(CompileShader, isCallValid, context, shaderPacked);
110 }
111 }
112
CreateProgram()113 GLuint GL_APIENTRY CreateProgram()
114 {
115 Context *context = GetValidGlobalContext();
116 EVENT("glCreateProgram", "context = %d", CID(context));
117
118 GLuint returnValue;
119 if (context)
120 {
121 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
122 bool isCallValid = (context->skipValidation() || ValidateCreateProgram(context));
123 if (isCallValid)
124 {
125 returnValue = context->createProgram();
126 }
127 else
128 {
129 returnValue = GetDefaultReturnValue<EntryPoint::CreateProgram, GLuint>();
130 }
131 ANGLE_CAPTURE(CreateProgram, isCallValid, context, returnValue);
132 }
133 else
134 {
135 returnValue = GetDefaultReturnValue<EntryPoint::CreateProgram, GLuint>();
136 }
137 return returnValue;
138 }
139
CreateShader(GLenum type)140 GLuint GL_APIENTRY CreateShader(GLenum type)
141 {
142 Context *context = GetValidGlobalContext();
143 EVENT("glCreateShader", "context = %d, GLenum type = %s", CID(context),
144 GLenumToString(GLenumGroup::ShaderType, type));
145
146 GLuint returnValue;
147 if (context)
148 {
149 ShaderType typePacked = FromGL<ShaderType>(type);
150 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
151 bool isCallValid = (context->skipValidation() || ValidateCreateShader(context, typePacked));
152 if (isCallValid)
153 {
154 returnValue = context->createShader(typePacked);
155 }
156 else
157 {
158 returnValue = GetDefaultReturnValue<EntryPoint::CreateShader, GLuint>();
159 }
160 ANGLE_CAPTURE(CreateShader, isCallValid, context, typePacked, returnValue);
161 }
162 else
163 {
164 returnValue = GetDefaultReturnValue<EntryPoint::CreateShader, GLuint>();
165 }
166 return returnValue;
167 }
168
DeleteProgram(GLuint program)169 void GL_APIENTRY DeleteProgram(GLuint program)
170 {
171 Context *context = GetValidGlobalContext();
172 EVENT("glDeleteProgram", "context = %d, GLuint program = %u", CID(context), program);
173
174 if (context)
175 {
176 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
177 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
178 bool isCallValid =
179 (context->skipValidation() || ValidateDeleteProgram(context, programPacked));
180 if (isCallValid)
181 {
182 context->deleteProgram(programPacked);
183 }
184 ANGLE_CAPTURE(DeleteProgram, isCallValid, context, programPacked);
185 }
186 }
187
DeleteShader(GLuint shader)188 void GL_APIENTRY DeleteShader(GLuint shader)
189 {
190 Context *context = GetValidGlobalContext();
191 EVENT("glDeleteShader", "context = %d, GLuint shader = %u", CID(context), shader);
192
193 if (context)
194 {
195 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
196 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
197 bool isCallValid =
198 (context->skipValidation() || ValidateDeleteShader(context, shaderPacked));
199 if (isCallValid)
200 {
201 context->deleteShader(shaderPacked);
202 }
203 ANGLE_CAPTURE(DeleteShader, isCallValid, context, shaderPacked);
204 }
205 }
206
DetachShader(GLuint program,GLuint shader)207 void GL_APIENTRY DetachShader(GLuint program, GLuint shader)
208 {
209 Context *context = GetValidGlobalContext();
210 EVENT("glDetachShader", "context = %d, GLuint program = %u, GLuint shader = %u", CID(context),
211 program, shader);
212
213 if (context)
214 {
215 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
216 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
217 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
218 bool isCallValid = (context->skipValidation() ||
219 ValidateDetachShader(context, programPacked, shaderPacked));
220 if (isCallValid)
221 {
222 context->detachShader(programPacked, shaderPacked);
223 }
224 ANGLE_CAPTURE(DetachShader, isCallValid, context, programPacked, shaderPacked);
225 }
226 }
227
DisableVertexAttribArray(GLuint index)228 void GL_APIENTRY DisableVertexAttribArray(GLuint index)
229 {
230 Context *context = GetValidGlobalContext();
231 EVENT("glDisableVertexAttribArray", "context = %d, GLuint index = %u", CID(context), index);
232
233 if (context)
234 {
235 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
236 bool isCallValid =
237 (context->skipValidation() || ValidateDisableVertexAttribArray(context, index));
238 if (isCallValid)
239 {
240 context->disableVertexAttribArray(index);
241 }
242 ANGLE_CAPTURE(DisableVertexAttribArray, isCallValid, context, index);
243 }
244 }
245
DrawBuffers(GLsizei n,const GLenum * bufs)246 void GL_APIENTRY DrawBuffers(GLsizei n, const GLenum *bufs)
247 {
248 Context *context = GetValidGlobalContext();
249 EVENT("glDrawBuffers", "context = %d, GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR "",
250 CID(context), n, (uintptr_t)bufs);
251
252 if (context)
253 {
254 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
255 bool isCallValid = (context->skipValidation() || ValidateDrawBuffers(context, n, bufs));
256 if (isCallValid)
257 {
258 context->drawBuffers(n, bufs);
259 }
260 ANGLE_CAPTURE(DrawBuffers, isCallValid, context, n, bufs);
261 }
262 }
263
EnableVertexAttribArray(GLuint index)264 void GL_APIENTRY EnableVertexAttribArray(GLuint index)
265 {
266 Context *context = GetValidGlobalContext();
267 EVENT("glEnableVertexAttribArray", "context = %d, GLuint index = %u", CID(context), index);
268
269 if (context)
270 {
271 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
272 bool isCallValid =
273 (context->skipValidation() || ValidateEnableVertexAttribArray(context, index));
274 if (isCallValid)
275 {
276 context->enableVertexAttribArray(index);
277 }
278 ANGLE_CAPTURE(EnableVertexAttribArray, isCallValid, context, index);
279 }
280 }
281
GetActiveAttrib(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)282 void GL_APIENTRY GetActiveAttrib(GLuint program,
283 GLuint index,
284 GLsizei bufSize,
285 GLsizei *length,
286 GLint *size,
287 GLenum *type,
288 GLchar *name)
289 {
290 Context *context = GetValidGlobalContext();
291 EVENT("glGetActiveAttrib",
292 "context = %d, GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei "
293 "*length = 0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR
294 ", GLenum *type = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
295 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
296 (uintptr_t)type, (uintptr_t)name);
297
298 if (context)
299 {
300 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
301 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
302 bool isCallValid = (context->skipValidation() ||
303 ValidateGetActiveAttrib(context, programPacked, index, bufSize, length,
304 size, type, name));
305 if (isCallValid)
306 {
307 context->getActiveAttrib(programPacked, index, bufSize, length, size, type, name);
308 }
309 ANGLE_CAPTURE(GetActiveAttrib, isCallValid, context, programPacked, index, bufSize, length,
310 size, type, name);
311 }
312 }
313
GetActiveUniform(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)314 void GL_APIENTRY GetActiveUniform(GLuint program,
315 GLuint index,
316 GLsizei bufSize,
317 GLsizei *length,
318 GLint *size,
319 GLenum *type,
320 GLchar *name)
321 {
322 Context *context = GetValidGlobalContext();
323 EVENT("glGetActiveUniform",
324 "context = %d, GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei "
325 "*length = 0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR
326 ", GLenum *type = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
327 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
328 (uintptr_t)type, (uintptr_t)name);
329
330 if (context)
331 {
332 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
333 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
334 bool isCallValid = (context->skipValidation() ||
335 ValidateGetActiveUniform(context, programPacked, index, bufSize, length,
336 size, type, name));
337 if (isCallValid)
338 {
339 context->getActiveUniform(programPacked, index, bufSize, length, size, type, name);
340 }
341 ANGLE_CAPTURE(GetActiveUniform, isCallValid, context, programPacked, index, bufSize, length,
342 size, type, name);
343 }
344 }
345
GetAttachedShaders(GLuint program,GLsizei maxCount,GLsizei * count,GLuint * shaders)346 void GL_APIENTRY GetAttachedShaders(GLuint program,
347 GLsizei maxCount,
348 GLsizei *count,
349 GLuint *shaders)
350 {
351 Context *context = GetValidGlobalContext();
352 EVENT(
353 "glGetAttachedShaders",
354 "context = %d, GLuint program = %u, GLsizei maxCount = %d, GLsizei *count = 0x%016" PRIxPTR
355 ", GLuint *shaders = 0x%016" PRIxPTR "",
356 CID(context), program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
357
358 if (context)
359 {
360 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
361 ShaderProgramID *shadersPacked = FromGL<ShaderProgramID *>(shaders);
362 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
363 bool isCallValid =
364 (context->skipValidation() ||
365 ValidateGetAttachedShaders(context, programPacked, maxCount, count, shadersPacked));
366 if (isCallValid)
367 {
368 context->getAttachedShaders(programPacked, maxCount, count, shadersPacked);
369 }
370 ANGLE_CAPTURE(GetAttachedShaders, isCallValid, context, programPacked, maxCount, count,
371 shadersPacked);
372 }
373 }
374
GetAttribLocation(GLuint program,const GLchar * name)375 GLint GL_APIENTRY GetAttribLocation(GLuint program, const GLchar *name)
376 {
377 Context *context = GetValidGlobalContext();
378 EVENT("glGetAttribLocation",
379 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
380 program, (uintptr_t)name);
381
382 GLint returnValue;
383 if (context)
384 {
385 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
386 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
387 bool isCallValid =
388 (context->skipValidation() || ValidateGetAttribLocation(context, programPacked, name));
389 if (isCallValid)
390 {
391 returnValue = context->getAttribLocation(programPacked, name);
392 }
393 else
394 {
395 returnValue = GetDefaultReturnValue<EntryPoint::GetAttribLocation, GLint>();
396 }
397 ANGLE_CAPTURE(GetAttribLocation, isCallValid, context, programPacked, name, returnValue);
398 }
399 else
400 {
401 returnValue = GetDefaultReturnValue<EntryPoint::GetAttribLocation, GLint>();
402 }
403 return returnValue;
404 }
405
GetProgramInfoLog(GLuint program,GLsizei bufSize,GLsizei * length,GLchar * infoLog)406 void GL_APIENTRY GetProgramInfoLog(GLuint program,
407 GLsizei bufSize,
408 GLsizei *length,
409 GLchar *infoLog)
410 {
411 Context *context = GetValidGlobalContext();
412 EVENT(
413 "glGetProgramInfoLog",
414 "context = %d, GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
415 ", GLchar *infoLog = 0x%016" PRIxPTR "",
416 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
417
418 if (context)
419 {
420 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
421 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
422 bool isCallValid =
423 (context->skipValidation() ||
424 ValidateGetProgramInfoLog(context, programPacked, bufSize, length, infoLog));
425 if (isCallValid)
426 {
427 context->getProgramInfoLog(programPacked, bufSize, length, infoLog);
428 }
429 ANGLE_CAPTURE(GetProgramInfoLog, isCallValid, context, programPacked, bufSize, length,
430 infoLog);
431 }
432 }
433
GetProgramiv(GLuint program,GLenum pname,GLint * params)434 void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params)
435 {
436 Context *context = GetGlobalContext();
437 EVENT("glGetProgramiv",
438 "context = %d, GLuint program = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
439 CID(context), program, GLenumToString(GLenumGroup::ProgramPropertyARB, pname),
440 (uintptr_t)params);
441
442 if (context)
443 {
444 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
445 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
446 bool isCallValid = (context->skipValidation() ||
447 ValidateGetProgramiv(context, programPacked, pname, params));
448 if (isCallValid)
449 {
450 context->getProgramiv(programPacked, pname, params);
451 }
452 ANGLE_CAPTURE(GetProgramiv, isCallValid, context, programPacked, pname, params);
453 }
454 }
455
GetShaderInfoLog(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * infoLog)456 void GL_APIENTRY GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
457 {
458 Context *context = GetValidGlobalContext();
459 EVENT("glGetShaderInfoLog",
460 "context = %d, GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
461 ", GLchar *infoLog = 0x%016" PRIxPTR "",
462 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
463
464 if (context)
465 {
466 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
467 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
468 bool isCallValid =
469 (context->skipValidation() ||
470 ValidateGetShaderInfoLog(context, shaderPacked, bufSize, length, infoLog));
471 if (isCallValid)
472 {
473 context->getShaderInfoLog(shaderPacked, bufSize, length, infoLog);
474 }
475 ANGLE_CAPTURE(GetShaderInfoLog, isCallValid, context, shaderPacked, bufSize, length,
476 infoLog);
477 }
478 }
479
GetShaderSource(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source)480 void GL_APIENTRY GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
481 {
482 Context *context = GetValidGlobalContext();
483 EVENT("glGetShaderSource",
484 "context = %d, GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
485 ", GLchar *source = 0x%016" PRIxPTR "",
486 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
487
488 if (context)
489 {
490 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
491 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
492 bool isCallValid =
493 (context->skipValidation() ||
494 ValidateGetShaderSource(context, shaderPacked, bufSize, length, source));
495 if (isCallValid)
496 {
497 context->getShaderSource(shaderPacked, bufSize, length, source);
498 }
499 ANGLE_CAPTURE(GetShaderSource, isCallValid, context, shaderPacked, bufSize, length, source);
500 }
501 }
502
GetShaderiv(GLuint shader,GLenum pname,GLint * params)503 void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params)
504 {
505 Context *context = GetGlobalContext();
506 EVENT("glGetShaderiv",
507 "context = %d, GLuint shader = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
508 CID(context), shader, GLenumToString(GLenumGroup::ShaderParameterName, pname),
509 (uintptr_t)params);
510
511 if (context)
512 {
513 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
514 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
515 bool isCallValid = (context->skipValidation() ||
516 ValidateGetShaderiv(context, shaderPacked, pname, params));
517 if (isCallValid)
518 {
519 context->getShaderiv(shaderPacked, pname, params);
520 }
521 ANGLE_CAPTURE(GetShaderiv, isCallValid, context, shaderPacked, pname, params);
522 }
523 }
524
GetUniformLocation(GLuint program,const GLchar * name)525 GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name)
526 {
527 Context *context = GetValidGlobalContext();
528 EVENT("glGetUniformLocation",
529 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
530 program, (uintptr_t)name);
531
532 GLint returnValue;
533 if (context)
534 {
535 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
536 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
537 bool isCallValid =
538 (context->skipValidation() || ValidateGetUniformLocation(context, programPacked, name));
539 if (isCallValid)
540 {
541 returnValue = context->getUniformLocation(programPacked, name);
542 }
543 else
544 {
545 returnValue = GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
546 }
547 ANGLE_CAPTURE(GetUniformLocation, isCallValid, context, programPacked, name, returnValue);
548 }
549 else
550 {
551 returnValue = GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
552 }
553 return returnValue;
554 }
555
GetUniformfv(GLuint program,GLint location,GLfloat * params)556 void GL_APIENTRY GetUniformfv(GLuint program, GLint location, GLfloat *params)
557 {
558 Context *context = GetValidGlobalContext();
559 EVENT("glGetUniformfv",
560 "context = %d, GLuint program = %u, GLint location = %d, GLfloat *params = 0x%016" PRIxPTR
561 "",
562 CID(context), program, location, (uintptr_t)params);
563
564 if (context)
565 {
566 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
567 UniformLocation locationPacked = FromGL<UniformLocation>(location);
568 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
569 bool isCallValid = (context->skipValidation() ||
570 ValidateGetUniformfv(context, programPacked, locationPacked, params));
571 if (isCallValid)
572 {
573 context->getUniformfv(programPacked, locationPacked, params);
574 }
575 ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
576 }
577 }
578
GetUniformiv(GLuint program,GLint location,GLint * params)579 void GL_APIENTRY GetUniformiv(GLuint program, GLint location, GLint *params)
580 {
581 Context *context = GetValidGlobalContext();
582 EVENT("glGetUniformiv",
583 "context = %d, GLuint program = %u, GLint location = %d, GLint *params = 0x%016" PRIxPTR
584 "",
585 CID(context), program, location, (uintptr_t)params);
586
587 if (context)
588 {
589 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
590 UniformLocation locationPacked = FromGL<UniformLocation>(location);
591 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
592 bool isCallValid = (context->skipValidation() ||
593 ValidateGetUniformiv(context, programPacked, locationPacked, params));
594 if (isCallValid)
595 {
596 context->getUniformiv(programPacked, locationPacked, params);
597 }
598 ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
599 }
600 }
601
GetVertexAttribPointerv(GLuint index,GLenum pname,void ** pointer)602 void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
603 {
604 Context *context = GetValidGlobalContext();
605 EVENT("glGetVertexAttribPointerv",
606 "context = %d, GLuint index = %u, GLenum pname = %s, void **pointer = 0x%016" PRIxPTR "",
607 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname),
608 (uintptr_t)pointer);
609
610 if (context)
611 {
612 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
613 bool isCallValid = (context->skipValidation() ||
614 ValidateGetVertexAttribPointerv(context, index, pname, pointer));
615 if (isCallValid)
616 {
617 context->getVertexAttribPointerv(index, pname, pointer);
618 }
619 ANGLE_CAPTURE(GetVertexAttribPointerv, isCallValid, context, index, pname, pointer);
620 }
621 }
622
GetVertexAttribdv(GLuint index,GLenum pname,GLdouble * params)623 void GL_APIENTRY GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
624 {
625 Context *context = GetValidGlobalContext();
626 EVENT("glGetVertexAttribdv",
627 "context = %d, GLuint index = %u, GLenum pname = %s, GLdouble *params = 0x%016" PRIxPTR
628 "",
629 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
630
631 if (context)
632 {
633 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
634 bool isCallValid =
635 (context->skipValidation() || ValidateGetVertexAttribdv(context, index, pname, params));
636 if (isCallValid)
637 {
638 context->getVertexAttribdv(index, pname, params);
639 }
640 ANGLE_CAPTURE(GetVertexAttribdv, isCallValid, context, index, pname, params);
641 }
642 }
643
GetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)644 void GL_APIENTRY GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
645 {
646 Context *context = GetValidGlobalContext();
647 EVENT("glGetVertexAttribfv",
648 "context = %d, GLuint index = %u, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
649 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
650
651 if (context)
652 {
653 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
654 bool isCallValid =
655 (context->skipValidation() || ValidateGetVertexAttribfv(context, index, pname, params));
656 if (isCallValid)
657 {
658 context->getVertexAttribfv(index, pname, params);
659 }
660 ANGLE_CAPTURE(GetVertexAttribfv, isCallValid, context, index, pname, params);
661 }
662 }
663
GetVertexAttribiv(GLuint index,GLenum pname,GLint * params)664 void GL_APIENTRY GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
665 {
666 Context *context = GetValidGlobalContext();
667 EVENT("glGetVertexAttribiv",
668 "context = %d, GLuint index = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
669 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
670
671 if (context)
672 {
673 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
674 bool isCallValid =
675 (context->skipValidation() || ValidateGetVertexAttribiv(context, index, pname, params));
676 if (isCallValid)
677 {
678 context->getVertexAttribiv(index, pname, params);
679 }
680 ANGLE_CAPTURE(GetVertexAttribiv, isCallValid, context, index, pname, params);
681 }
682 }
683
IsProgram(GLuint program)684 GLboolean GL_APIENTRY IsProgram(GLuint program)
685 {
686 Context *context = GetValidGlobalContext();
687 EVENT("glIsProgram", "context = %d, GLuint program = %u", CID(context), program);
688
689 GLboolean returnValue;
690 if (context)
691 {
692 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
693 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
694 bool isCallValid = (context->skipValidation() || ValidateIsProgram(context, programPacked));
695 if (isCallValid)
696 {
697 returnValue = context->isProgram(programPacked);
698 }
699 else
700 {
701 returnValue = GetDefaultReturnValue<EntryPoint::IsProgram, GLboolean>();
702 }
703 ANGLE_CAPTURE(IsProgram, isCallValid, context, programPacked, returnValue);
704 }
705 else
706 {
707 returnValue = GetDefaultReturnValue<EntryPoint::IsProgram, GLboolean>();
708 }
709 return returnValue;
710 }
711
IsShader(GLuint shader)712 GLboolean GL_APIENTRY IsShader(GLuint shader)
713 {
714 Context *context = GetValidGlobalContext();
715 EVENT("glIsShader", "context = %d, GLuint shader = %u", CID(context), shader);
716
717 GLboolean returnValue;
718 if (context)
719 {
720 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
721 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
722 bool isCallValid = (context->skipValidation() || ValidateIsShader(context, shaderPacked));
723 if (isCallValid)
724 {
725 returnValue = context->isShader(shaderPacked);
726 }
727 else
728 {
729 returnValue = GetDefaultReturnValue<EntryPoint::IsShader, GLboolean>();
730 }
731 ANGLE_CAPTURE(IsShader, isCallValid, context, shaderPacked, returnValue);
732 }
733 else
734 {
735 returnValue = GetDefaultReturnValue<EntryPoint::IsShader, GLboolean>();
736 }
737 return returnValue;
738 }
739
LinkProgram(GLuint program)740 void GL_APIENTRY LinkProgram(GLuint program)
741 {
742 Context *context = GetValidGlobalContext();
743 EVENT("glLinkProgram", "context = %d, GLuint program = %u", CID(context), program);
744
745 if (context)
746 {
747 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
748 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
749 bool isCallValid =
750 (context->skipValidation() || ValidateLinkProgram(context, programPacked));
751 if (isCallValid)
752 {
753 context->linkProgram(programPacked);
754 }
755 ANGLE_CAPTURE(LinkProgram, isCallValid, context, programPacked);
756 }
757 }
758
ShaderSource(GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length)759 void GL_APIENTRY ShaderSource(GLuint shader,
760 GLsizei count,
761 const GLchar *const *string,
762 const GLint *length)
763 {
764 Context *context = GetValidGlobalContext();
765 EVENT("glShaderSource",
766 "context = %d, GLuint shader = %u, GLsizei count = %d, const GLchar *const*string = "
767 "0x%016" PRIxPTR ", const GLint *length = 0x%016" PRIxPTR "",
768 CID(context), shader, count, (uintptr_t)string, (uintptr_t)length);
769
770 if (context)
771 {
772 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
773 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
774 bool isCallValid = (context->skipValidation() ||
775 ValidateShaderSource(context, shaderPacked, count, string, length));
776 if (isCallValid)
777 {
778 context->shaderSource(shaderPacked, count, string, length);
779 }
780 ANGLE_CAPTURE(ShaderSource, isCallValid, context, shaderPacked, count, string, length);
781 }
782 }
783
StencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)784 void GL_APIENTRY StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
785 {
786 Context *context = GetValidGlobalContext();
787 EVENT("glStencilFuncSeparate",
788 "context = %d, GLenum face = %s, GLenum func = %s, GLint ref = %d, GLuint mask = %u",
789 CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face),
790 GLenumToString(GLenumGroup::StencilFunction, func), ref, mask);
791
792 if (context)
793 {
794 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
795 bool isCallValid = (context->skipValidation() ||
796 ValidateStencilFuncSeparate(context, face, func, ref, mask));
797 if (isCallValid)
798 {
799 context->stencilFuncSeparate(face, func, ref, mask);
800 }
801 ANGLE_CAPTURE(StencilFuncSeparate, isCallValid, context, face, func, ref, mask);
802 }
803 }
804
StencilMaskSeparate(GLenum face,GLuint mask)805 void GL_APIENTRY StencilMaskSeparate(GLenum face, GLuint mask)
806 {
807 Context *context = GetValidGlobalContext();
808 EVENT("glStencilMaskSeparate", "context = %d, GLenum face = %s, GLuint mask = %u", CID(context),
809 GLenumToString(GLenumGroup::StencilFaceDirection, face), mask);
810
811 if (context)
812 {
813 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
814 bool isCallValid =
815 (context->skipValidation() || ValidateStencilMaskSeparate(context, face, mask));
816 if (isCallValid)
817 {
818 context->stencilMaskSeparate(face, mask);
819 }
820 ANGLE_CAPTURE(StencilMaskSeparate, isCallValid, context, face, mask);
821 }
822 }
823
StencilOpSeparate(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass)824 void GL_APIENTRY StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
825 {
826 Context *context = GetValidGlobalContext();
827 EVENT(
828 "glStencilOpSeparate",
829 "context = %d, GLenum face = %s, GLenum sfail = %s, GLenum dpfail = %s, GLenum dppass = %s",
830 CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face),
831 GLenumToString(GLenumGroup::StencilOp, sfail),
832 GLenumToString(GLenumGroup::StencilOp, dpfail),
833 GLenumToString(GLenumGroup::StencilOp, dppass));
834
835 if (context)
836 {
837 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
838 bool isCallValid = (context->skipValidation() ||
839 ValidateStencilOpSeparate(context, face, sfail, dpfail, dppass));
840 if (isCallValid)
841 {
842 context->stencilOpSeparate(face, sfail, dpfail, dppass);
843 }
844 ANGLE_CAPTURE(StencilOpSeparate, isCallValid, context, face, sfail, dpfail, dppass);
845 }
846 }
847
Uniform1f(GLint location,GLfloat v0)848 void GL_APIENTRY Uniform1f(GLint location, GLfloat v0)
849 {
850 Context *context = GetValidGlobalContext();
851 EVENT("glUniform1f", "context = %d, GLint location = %d, GLfloat v0 = %f", CID(context),
852 location, v0);
853
854 if (context)
855 {
856 UniformLocation locationPacked = FromGL<UniformLocation>(location);
857 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
858 bool isCallValid =
859 (context->skipValidation() || ValidateUniform1f(context, locationPacked, v0));
860 if (isCallValid)
861 {
862 context->uniform1f(locationPacked, v0);
863 }
864 ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
865 }
866 }
867
Uniform1fv(GLint location,GLsizei count,const GLfloat * value)868 void GL_APIENTRY Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
869 {
870 Context *context = GetValidGlobalContext();
871 EVENT("glUniform1fv",
872 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
873 "0x%016" PRIxPTR "",
874 CID(context), location, count, (uintptr_t)value);
875
876 if (context)
877 {
878 UniformLocation locationPacked = FromGL<UniformLocation>(location);
879 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
880 bool isCallValid = (context->skipValidation() ||
881 ValidateUniform1fv(context, locationPacked, count, value));
882 if (isCallValid)
883 {
884 context->uniform1fv(locationPacked, count, value);
885 }
886 ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
887 }
888 }
889
Uniform1i(GLint location,GLint v0)890 void GL_APIENTRY Uniform1i(GLint location, GLint v0)
891 {
892 Context *context = GetValidGlobalContext();
893 EVENT("glUniform1i", "context = %d, GLint location = %d, GLint v0 = %d", CID(context), location,
894 v0);
895
896 if (context)
897 {
898 UniformLocation locationPacked = FromGL<UniformLocation>(location);
899 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
900 bool isCallValid =
901 (context->skipValidation() || ValidateUniform1i(context, locationPacked, v0));
902 if (isCallValid)
903 {
904 context->uniform1i(locationPacked, v0);
905 }
906 ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
907 }
908 }
909
Uniform1iv(GLint location,GLsizei count,const GLint * value)910 void GL_APIENTRY Uniform1iv(GLint location, GLsizei count, const GLint *value)
911 {
912 Context *context = GetValidGlobalContext();
913 EVENT(
914 "glUniform1iv",
915 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
916 "",
917 CID(context), location, count, (uintptr_t)value);
918
919 if (context)
920 {
921 UniformLocation locationPacked = FromGL<UniformLocation>(location);
922 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
923 bool isCallValid = (context->skipValidation() ||
924 ValidateUniform1iv(context, locationPacked, count, value));
925 if (isCallValid)
926 {
927 context->uniform1iv(locationPacked, count, value);
928 }
929 ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
930 }
931 }
932
Uniform2f(GLint location,GLfloat v0,GLfloat v1)933 void GL_APIENTRY Uniform2f(GLint location, GLfloat v0, GLfloat v1)
934 {
935 Context *context = GetValidGlobalContext();
936 EVENT("glUniform2f", "context = %d, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f",
937 CID(context), location, v0, v1);
938
939 if (context)
940 {
941 UniformLocation locationPacked = FromGL<UniformLocation>(location);
942 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
943 bool isCallValid =
944 (context->skipValidation() || ValidateUniform2f(context, locationPacked, v0, v1));
945 if (isCallValid)
946 {
947 context->uniform2f(locationPacked, v0, v1);
948 }
949 ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
950 }
951 }
952
Uniform2fv(GLint location,GLsizei count,const GLfloat * value)953 void GL_APIENTRY Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
954 {
955 Context *context = GetValidGlobalContext();
956 EVENT("glUniform2fv",
957 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
958 "0x%016" PRIxPTR "",
959 CID(context), location, count, (uintptr_t)value);
960
961 if (context)
962 {
963 UniformLocation locationPacked = FromGL<UniformLocation>(location);
964 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
965 bool isCallValid = (context->skipValidation() ||
966 ValidateUniform2fv(context, locationPacked, count, value));
967 if (isCallValid)
968 {
969 context->uniform2fv(locationPacked, count, value);
970 }
971 ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
972 }
973 }
974
Uniform2i(GLint location,GLint v0,GLint v1)975 void GL_APIENTRY Uniform2i(GLint location, GLint v0, GLint v1)
976 {
977 Context *context = GetValidGlobalContext();
978 EVENT("glUniform2i", "context = %d, GLint location = %d, GLint v0 = %d, GLint v1 = %d",
979 CID(context), location, v0, v1);
980
981 if (context)
982 {
983 UniformLocation locationPacked = FromGL<UniformLocation>(location);
984 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
985 bool isCallValid =
986 (context->skipValidation() || ValidateUniform2i(context, locationPacked, v0, v1));
987 if (isCallValid)
988 {
989 context->uniform2i(locationPacked, v0, v1);
990 }
991 ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
992 }
993 }
994
Uniform2iv(GLint location,GLsizei count,const GLint * value)995 void GL_APIENTRY Uniform2iv(GLint location, GLsizei count, const GLint *value)
996 {
997 Context *context = GetValidGlobalContext();
998 EVENT(
999 "glUniform2iv",
1000 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
1001 "",
1002 CID(context), location, count, (uintptr_t)value);
1003
1004 if (context)
1005 {
1006 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1007 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1008 bool isCallValid = (context->skipValidation() ||
1009 ValidateUniform2iv(context, locationPacked, count, value));
1010 if (isCallValid)
1011 {
1012 context->uniform2iv(locationPacked, count, value);
1013 }
1014 ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
1015 }
1016 }
1017
Uniform3f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2)1018 void GL_APIENTRY Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
1019 {
1020 Context *context = GetValidGlobalContext();
1021 EVENT("glUniform3f",
1022 "context = %d, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f",
1023 CID(context), location, v0, v1, v2);
1024
1025 if (context)
1026 {
1027 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1028 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1029 bool isCallValid =
1030 (context->skipValidation() || ValidateUniform3f(context, locationPacked, v0, v1, v2));
1031 if (isCallValid)
1032 {
1033 context->uniform3f(locationPacked, v0, v1, v2);
1034 }
1035 ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
1036 }
1037 }
1038
Uniform3fv(GLint location,GLsizei count,const GLfloat * value)1039 void GL_APIENTRY Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
1040 {
1041 Context *context = GetValidGlobalContext();
1042 EVENT("glUniform3fv",
1043 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
1044 "0x%016" PRIxPTR "",
1045 CID(context), location, count, (uintptr_t)value);
1046
1047 if (context)
1048 {
1049 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1050 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1051 bool isCallValid = (context->skipValidation() ||
1052 ValidateUniform3fv(context, locationPacked, count, value));
1053 if (isCallValid)
1054 {
1055 context->uniform3fv(locationPacked, count, value);
1056 }
1057 ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
1058 }
1059 }
1060
Uniform3i(GLint location,GLint v0,GLint v1,GLint v2)1061 void GL_APIENTRY Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
1062 {
1063 Context *context = GetValidGlobalContext();
1064 EVENT("glUniform3i",
1065 "context = %d, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d",
1066 CID(context), location, v0, v1, v2);
1067
1068 if (context)
1069 {
1070 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1071 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1072 bool isCallValid =
1073 (context->skipValidation() || ValidateUniform3i(context, locationPacked, v0, v1, v2));
1074 if (isCallValid)
1075 {
1076 context->uniform3i(locationPacked, v0, v1, v2);
1077 }
1078 ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
1079 }
1080 }
1081
Uniform3iv(GLint location,GLsizei count,const GLint * value)1082 void GL_APIENTRY Uniform3iv(GLint location, GLsizei count, const GLint *value)
1083 {
1084 Context *context = GetValidGlobalContext();
1085 EVENT(
1086 "glUniform3iv",
1087 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
1088 "",
1089 CID(context), location, count, (uintptr_t)value);
1090
1091 if (context)
1092 {
1093 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1094 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1095 bool isCallValid = (context->skipValidation() ||
1096 ValidateUniform3iv(context, locationPacked, count, value));
1097 if (isCallValid)
1098 {
1099 context->uniform3iv(locationPacked, count, value);
1100 }
1101 ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
1102 }
1103 }
1104
Uniform4f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)1105 void GL_APIENTRY Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
1106 {
1107 Context *context = GetValidGlobalContext();
1108 EVENT("glUniform4f",
1109 "context = %d, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f, "
1110 "GLfloat v3 = %f",
1111 CID(context), location, v0, v1, v2, v3);
1112
1113 if (context)
1114 {
1115 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1116 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1117 bool isCallValid = (context->skipValidation() ||
1118 ValidateUniform4f(context, locationPacked, v0, v1, v2, v3));
1119 if (isCallValid)
1120 {
1121 context->uniform4f(locationPacked, v0, v1, v2, v3);
1122 }
1123 ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
1124 }
1125 }
1126
Uniform4fv(GLint location,GLsizei count,const GLfloat * value)1127 void GL_APIENTRY Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
1128 {
1129 Context *context = GetValidGlobalContext();
1130 EVENT("glUniform4fv",
1131 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
1132 "0x%016" PRIxPTR "",
1133 CID(context), location, count, (uintptr_t)value);
1134
1135 if (context)
1136 {
1137 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1138 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1139 bool isCallValid = (context->skipValidation() ||
1140 ValidateUniform4fv(context, locationPacked, count, value));
1141 if (isCallValid)
1142 {
1143 context->uniform4fv(locationPacked, count, value);
1144 }
1145 ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
1146 }
1147 }
1148
Uniform4i(GLint location,GLint v0,GLint v1,GLint v2,GLint v3)1149 void GL_APIENTRY Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1150 {
1151 Context *context = GetValidGlobalContext();
1152 EVENT("glUniform4i",
1153 "context = %d, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, GLint "
1154 "v3 = %d",
1155 CID(context), location, v0, v1, v2, v3);
1156
1157 if (context)
1158 {
1159 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1160 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1161 bool isCallValid = (context->skipValidation() ||
1162 ValidateUniform4i(context, locationPacked, v0, v1, v2, v3));
1163 if (isCallValid)
1164 {
1165 context->uniform4i(locationPacked, v0, v1, v2, v3);
1166 }
1167 ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
1168 }
1169 }
1170
Uniform4iv(GLint location,GLsizei count,const GLint * value)1171 void GL_APIENTRY Uniform4iv(GLint location, GLsizei count, const GLint *value)
1172 {
1173 Context *context = GetValidGlobalContext();
1174 EVENT(
1175 "glUniform4iv",
1176 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
1177 "",
1178 CID(context), location, count, (uintptr_t)value);
1179
1180 if (context)
1181 {
1182 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1183 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1184 bool isCallValid = (context->skipValidation() ||
1185 ValidateUniform4iv(context, locationPacked, count, value));
1186 if (isCallValid)
1187 {
1188 context->uniform4iv(locationPacked, count, value);
1189 }
1190 ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
1191 }
1192 }
1193
UniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1194 void GL_APIENTRY UniformMatrix2fv(GLint location,
1195 GLsizei count,
1196 GLboolean transpose,
1197 const GLfloat *value)
1198 {
1199 Context *context = GetValidGlobalContext();
1200 EVENT("glUniformMatrix2fv",
1201 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
1202 "GLfloat *value = 0x%016" PRIxPTR "",
1203 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1204
1205 if (context)
1206 {
1207 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1208 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1209 bool isCallValid =
1210 (context->skipValidation() ||
1211 ValidateUniformMatrix2fv(context, locationPacked, count, transpose, value));
1212 if (isCallValid)
1213 {
1214 context->uniformMatrix2fv(locationPacked, count, transpose, value);
1215 }
1216 ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
1217 value);
1218 }
1219 }
1220
UniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1221 void GL_APIENTRY UniformMatrix3fv(GLint location,
1222 GLsizei count,
1223 GLboolean transpose,
1224 const GLfloat *value)
1225 {
1226 Context *context = GetValidGlobalContext();
1227 EVENT("glUniformMatrix3fv",
1228 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
1229 "GLfloat *value = 0x%016" PRIxPTR "",
1230 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1231
1232 if (context)
1233 {
1234 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1235 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1236 bool isCallValid =
1237 (context->skipValidation() ||
1238 ValidateUniformMatrix3fv(context, locationPacked, count, transpose, value));
1239 if (isCallValid)
1240 {
1241 context->uniformMatrix3fv(locationPacked, count, transpose, value);
1242 }
1243 ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
1244 value);
1245 }
1246 }
1247
UniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1248 void GL_APIENTRY UniformMatrix4fv(GLint location,
1249 GLsizei count,
1250 GLboolean transpose,
1251 const GLfloat *value)
1252 {
1253 Context *context = GetValidGlobalContext();
1254 EVENT("glUniformMatrix4fv",
1255 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
1256 "GLfloat *value = 0x%016" PRIxPTR "",
1257 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
1258
1259 if (context)
1260 {
1261 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1262 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1263 bool isCallValid =
1264 (context->skipValidation() ||
1265 ValidateUniformMatrix4fv(context, locationPacked, count, transpose, value));
1266 if (isCallValid)
1267 {
1268 context->uniformMatrix4fv(locationPacked, count, transpose, value);
1269 }
1270 ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
1271 value);
1272 }
1273 }
1274
UseProgram(GLuint program)1275 void GL_APIENTRY UseProgram(GLuint program)
1276 {
1277 Context *context = GetValidGlobalContext();
1278 EVENT("glUseProgram", "context = %d, GLuint program = %u", CID(context), program);
1279
1280 if (context)
1281 {
1282 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1283 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1284 bool isCallValid =
1285 (context->skipValidation() || ValidateUseProgram(context, programPacked));
1286 if (isCallValid)
1287 {
1288 context->useProgram(programPacked);
1289 }
1290 ANGLE_CAPTURE(UseProgram, isCallValid, context, programPacked);
1291 }
1292 }
1293
ValidateProgram(GLuint program)1294 void GL_APIENTRY ValidateProgram(GLuint program)
1295 {
1296 Context *context = GetValidGlobalContext();
1297 EVENT("glValidateProgram", "context = %d, GLuint program = %u", CID(context), program);
1298
1299 if (context)
1300 {
1301 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1302 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1303 bool isCallValid =
1304 (context->skipValidation() || ValidateValidateProgram(context, programPacked));
1305 if (isCallValid)
1306 {
1307 context->validateProgram(programPacked);
1308 }
1309 ANGLE_CAPTURE(ValidateProgram, isCallValid, context, programPacked);
1310 }
1311 }
1312
VertexAttrib1d(GLuint index,GLdouble x)1313 void GL_APIENTRY VertexAttrib1d(GLuint index, GLdouble x)
1314 {
1315 Context *context = GetValidGlobalContext();
1316 EVENT("glVertexAttrib1d", "context = %d, GLuint index = %u, GLdouble x = %f", CID(context),
1317 index, x);
1318
1319 if (context)
1320 {
1321 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1322 bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1d(context, index, x));
1323 if (isCallValid)
1324 {
1325 context->vertexAttrib1d(index, x);
1326 }
1327 ANGLE_CAPTURE(VertexAttrib1d, isCallValid, context, index, x);
1328 }
1329 }
1330
VertexAttrib1dv(GLuint index,const GLdouble * v)1331 void GL_APIENTRY VertexAttrib1dv(GLuint index, const GLdouble *v)
1332 {
1333 Context *context = GetValidGlobalContext();
1334 EVENT("glVertexAttrib1dv",
1335 "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
1336 index, (uintptr_t)v);
1337
1338 if (context)
1339 {
1340 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1341 bool isCallValid =
1342 (context->skipValidation() || ValidateVertexAttrib1dv(context, index, v));
1343 if (isCallValid)
1344 {
1345 context->vertexAttrib1dv(index, v);
1346 }
1347 ANGLE_CAPTURE(VertexAttrib1dv, isCallValid, context, index, v);
1348 }
1349 }
1350
VertexAttrib1f(GLuint index,GLfloat x)1351 void GL_APIENTRY VertexAttrib1f(GLuint index, GLfloat x)
1352 {
1353 Context *context = GetValidGlobalContext();
1354 EVENT("glVertexAttrib1f", "context = %d, GLuint index = %u, GLfloat x = %f", CID(context),
1355 index, x);
1356
1357 if (context)
1358 {
1359 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1360 bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1f(context, index, x));
1361 if (isCallValid)
1362 {
1363 context->vertexAttrib1f(index, x);
1364 }
1365 ANGLE_CAPTURE(VertexAttrib1f, isCallValid, context, index, x);
1366 }
1367 }
1368
VertexAttrib1fv(GLuint index,const GLfloat * v)1369 void GL_APIENTRY VertexAttrib1fv(GLuint index, const GLfloat *v)
1370 {
1371 Context *context = GetValidGlobalContext();
1372 EVENT("glVertexAttrib1fv",
1373 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
1374 index, (uintptr_t)v);
1375
1376 if (context)
1377 {
1378 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1379 bool isCallValid =
1380 (context->skipValidation() || ValidateVertexAttrib1fv(context, index, v));
1381 if (isCallValid)
1382 {
1383 context->vertexAttrib1fv(index, v);
1384 }
1385 ANGLE_CAPTURE(VertexAttrib1fv, isCallValid, context, index, v);
1386 }
1387 }
1388
VertexAttrib1s(GLuint index,GLshort x)1389 void GL_APIENTRY VertexAttrib1s(GLuint index, GLshort x)
1390 {
1391 Context *context = GetValidGlobalContext();
1392 EVENT("glVertexAttrib1s", "context = %d, GLuint index = %u, GLshort x = %d", CID(context),
1393 index, x);
1394
1395 if (context)
1396 {
1397 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1398 bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1s(context, index, x));
1399 if (isCallValid)
1400 {
1401 context->vertexAttrib1s(index, x);
1402 }
1403 ANGLE_CAPTURE(VertexAttrib1s, isCallValid, context, index, x);
1404 }
1405 }
1406
VertexAttrib1sv(GLuint index,const GLshort * v)1407 void GL_APIENTRY VertexAttrib1sv(GLuint index, const GLshort *v)
1408 {
1409 Context *context = GetValidGlobalContext();
1410 EVENT("glVertexAttrib1sv",
1411 "context = %d, GLuint index = %u, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
1412 index, (uintptr_t)v);
1413
1414 if (context)
1415 {
1416 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1417 bool isCallValid =
1418 (context->skipValidation() || ValidateVertexAttrib1sv(context, index, v));
1419 if (isCallValid)
1420 {
1421 context->vertexAttrib1sv(index, v);
1422 }
1423 ANGLE_CAPTURE(VertexAttrib1sv, isCallValid, context, index, v);
1424 }
1425 }
1426
VertexAttrib2d(GLuint index,GLdouble x,GLdouble y)1427 void GL_APIENTRY VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
1428 {
1429 Context *context = GetValidGlobalContext();
1430 EVENT("glVertexAttrib2d", "context = %d, GLuint index = %u, GLdouble x = %f, GLdouble y = %f",
1431 CID(context), index, x, y);
1432
1433 if (context)
1434 {
1435 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1436 bool isCallValid =
1437 (context->skipValidation() || ValidateVertexAttrib2d(context, index, x, y));
1438 if (isCallValid)
1439 {
1440 context->vertexAttrib2d(index, x, y);
1441 }
1442 ANGLE_CAPTURE(VertexAttrib2d, isCallValid, context, index, x, y);
1443 }
1444 }
1445
VertexAttrib2dv(GLuint index,const GLdouble * v)1446 void GL_APIENTRY VertexAttrib2dv(GLuint index, const GLdouble *v)
1447 {
1448 Context *context = GetValidGlobalContext();
1449 EVENT("glVertexAttrib2dv",
1450 "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
1451 index, (uintptr_t)v);
1452
1453 if (context)
1454 {
1455 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1456 bool isCallValid =
1457 (context->skipValidation() || ValidateVertexAttrib2dv(context, index, v));
1458 if (isCallValid)
1459 {
1460 context->vertexAttrib2dv(index, v);
1461 }
1462 ANGLE_CAPTURE(VertexAttrib2dv, isCallValid, context, index, v);
1463 }
1464 }
1465
VertexAttrib2f(GLuint index,GLfloat x,GLfloat y)1466 void GL_APIENTRY VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
1467 {
1468 Context *context = GetValidGlobalContext();
1469 EVENT("glVertexAttrib2f", "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f",
1470 CID(context), index, x, y);
1471
1472 if (context)
1473 {
1474 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1475 bool isCallValid =
1476 (context->skipValidation() || ValidateVertexAttrib2f(context, index, x, y));
1477 if (isCallValid)
1478 {
1479 context->vertexAttrib2f(index, x, y);
1480 }
1481 ANGLE_CAPTURE(VertexAttrib2f, isCallValid, context, index, x, y);
1482 }
1483 }
1484
VertexAttrib2fv(GLuint index,const GLfloat * v)1485 void GL_APIENTRY VertexAttrib2fv(GLuint index, const GLfloat *v)
1486 {
1487 Context *context = GetValidGlobalContext();
1488 EVENT("glVertexAttrib2fv",
1489 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
1490 index, (uintptr_t)v);
1491
1492 if (context)
1493 {
1494 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1495 bool isCallValid =
1496 (context->skipValidation() || ValidateVertexAttrib2fv(context, index, v));
1497 if (isCallValid)
1498 {
1499 context->vertexAttrib2fv(index, v);
1500 }
1501 ANGLE_CAPTURE(VertexAttrib2fv, isCallValid, context, index, v);
1502 }
1503 }
1504
VertexAttrib2s(GLuint index,GLshort x,GLshort y)1505 void GL_APIENTRY VertexAttrib2s(GLuint index, GLshort x, GLshort y)
1506 {
1507 Context *context = GetValidGlobalContext();
1508 EVENT("glVertexAttrib2s", "context = %d, GLuint index = %u, GLshort x = %d, GLshort y = %d",
1509 CID(context), index, x, y);
1510
1511 if (context)
1512 {
1513 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1514 bool isCallValid =
1515 (context->skipValidation() || ValidateVertexAttrib2s(context, index, x, y));
1516 if (isCallValid)
1517 {
1518 context->vertexAttrib2s(index, x, y);
1519 }
1520 ANGLE_CAPTURE(VertexAttrib2s, isCallValid, context, index, x, y);
1521 }
1522 }
1523
VertexAttrib2sv(GLuint index,const GLshort * v)1524 void GL_APIENTRY VertexAttrib2sv(GLuint index, const GLshort *v)
1525 {
1526 Context *context = GetValidGlobalContext();
1527 EVENT("glVertexAttrib2sv",
1528 "context = %d, GLuint index = %u, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
1529 index, (uintptr_t)v);
1530
1531 if (context)
1532 {
1533 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1534 bool isCallValid =
1535 (context->skipValidation() || ValidateVertexAttrib2sv(context, index, v));
1536 if (isCallValid)
1537 {
1538 context->vertexAttrib2sv(index, v);
1539 }
1540 ANGLE_CAPTURE(VertexAttrib2sv, isCallValid, context, index, v);
1541 }
1542 }
1543
VertexAttrib3d(GLuint index,GLdouble x,GLdouble y,GLdouble z)1544 void GL_APIENTRY VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1545 {
1546 Context *context = GetValidGlobalContext();
1547 EVENT("glVertexAttrib3d",
1548 "context = %d, GLuint index = %u, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f",
1549 CID(context), index, x, y, z);
1550
1551 if (context)
1552 {
1553 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1554 bool isCallValid =
1555 (context->skipValidation() || ValidateVertexAttrib3d(context, index, x, y, z));
1556 if (isCallValid)
1557 {
1558 context->vertexAttrib3d(index, x, y, z);
1559 }
1560 ANGLE_CAPTURE(VertexAttrib3d, isCallValid, context, index, x, y, z);
1561 }
1562 }
1563
VertexAttrib3dv(GLuint index,const GLdouble * v)1564 void GL_APIENTRY VertexAttrib3dv(GLuint index, const GLdouble *v)
1565 {
1566 Context *context = GetValidGlobalContext();
1567 EVENT("glVertexAttrib3dv",
1568 "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
1569 index, (uintptr_t)v);
1570
1571 if (context)
1572 {
1573 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1574 bool isCallValid =
1575 (context->skipValidation() || ValidateVertexAttrib3dv(context, index, v));
1576 if (isCallValid)
1577 {
1578 context->vertexAttrib3dv(index, v);
1579 }
1580 ANGLE_CAPTURE(VertexAttrib3dv, isCallValid, context, index, v);
1581 }
1582 }
1583
VertexAttrib3f(GLuint index,GLfloat x,GLfloat y,GLfloat z)1584 void GL_APIENTRY VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
1585 {
1586 Context *context = GetValidGlobalContext();
1587 EVENT("glVertexAttrib3f",
1588 "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f",
1589 CID(context), index, x, y, z);
1590
1591 if (context)
1592 {
1593 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1594 bool isCallValid =
1595 (context->skipValidation() || ValidateVertexAttrib3f(context, index, x, y, z));
1596 if (isCallValid)
1597 {
1598 context->vertexAttrib3f(index, x, y, z);
1599 }
1600 ANGLE_CAPTURE(VertexAttrib3f, isCallValid, context, index, x, y, z);
1601 }
1602 }
1603
VertexAttrib3fv(GLuint index,const GLfloat * v)1604 void GL_APIENTRY VertexAttrib3fv(GLuint index, const GLfloat *v)
1605 {
1606 Context *context = GetValidGlobalContext();
1607 EVENT("glVertexAttrib3fv",
1608 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
1609 index, (uintptr_t)v);
1610
1611 if (context)
1612 {
1613 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1614 bool isCallValid =
1615 (context->skipValidation() || ValidateVertexAttrib3fv(context, index, v));
1616 if (isCallValid)
1617 {
1618 context->vertexAttrib3fv(index, v);
1619 }
1620 ANGLE_CAPTURE(VertexAttrib3fv, isCallValid, context, index, v);
1621 }
1622 }
1623
VertexAttrib3s(GLuint index,GLshort x,GLshort y,GLshort z)1624 void GL_APIENTRY VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
1625 {
1626 Context *context = GetValidGlobalContext();
1627 EVENT("glVertexAttrib3s",
1628 "context = %d, GLuint index = %u, GLshort x = %d, GLshort y = %d, GLshort z = %d",
1629 CID(context), index, x, y, z);
1630
1631 if (context)
1632 {
1633 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1634 bool isCallValid =
1635 (context->skipValidation() || ValidateVertexAttrib3s(context, index, x, y, z));
1636 if (isCallValid)
1637 {
1638 context->vertexAttrib3s(index, x, y, z);
1639 }
1640 ANGLE_CAPTURE(VertexAttrib3s, isCallValid, context, index, x, y, z);
1641 }
1642 }
1643
VertexAttrib3sv(GLuint index,const GLshort * v)1644 void GL_APIENTRY VertexAttrib3sv(GLuint index, const GLshort *v)
1645 {
1646 Context *context = GetValidGlobalContext();
1647 EVENT("glVertexAttrib3sv",
1648 "context = %d, GLuint index = %u, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
1649 index, (uintptr_t)v);
1650
1651 if (context)
1652 {
1653 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1654 bool isCallValid =
1655 (context->skipValidation() || ValidateVertexAttrib3sv(context, index, v));
1656 if (isCallValid)
1657 {
1658 context->vertexAttrib3sv(index, v);
1659 }
1660 ANGLE_CAPTURE(VertexAttrib3sv, isCallValid, context, index, v);
1661 }
1662 }
1663
VertexAttrib4Nbv(GLuint index,const GLbyte * v)1664 void GL_APIENTRY VertexAttrib4Nbv(GLuint index, const GLbyte *v)
1665 {
1666 Context *context = GetValidGlobalContext();
1667 EVENT("glVertexAttrib4Nbv",
1668 "context = %d, GLuint index = %u, const GLbyte *v = 0x%016" PRIxPTR "", CID(context),
1669 index, (uintptr_t)v);
1670
1671 if (context)
1672 {
1673 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1674 bool isCallValid =
1675 (context->skipValidation() || ValidateVertexAttrib4Nbv(context, index, v));
1676 if (isCallValid)
1677 {
1678 context->vertexAttrib4Nbv(index, v);
1679 }
1680 ANGLE_CAPTURE(VertexAttrib4Nbv, isCallValid, context, index, v);
1681 }
1682 }
1683
VertexAttrib4Niv(GLuint index,const GLint * v)1684 void GL_APIENTRY VertexAttrib4Niv(GLuint index, const GLint *v)
1685 {
1686 Context *context = GetValidGlobalContext();
1687 EVENT("glVertexAttrib4Niv",
1688 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
1689 index, (uintptr_t)v);
1690
1691 if (context)
1692 {
1693 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1694 bool isCallValid =
1695 (context->skipValidation() || ValidateVertexAttrib4Niv(context, index, v));
1696 if (isCallValid)
1697 {
1698 context->vertexAttrib4Niv(index, v);
1699 }
1700 ANGLE_CAPTURE(VertexAttrib4Niv, isCallValid, context, index, v);
1701 }
1702 }
1703
VertexAttrib4Nsv(GLuint index,const GLshort * v)1704 void GL_APIENTRY VertexAttrib4Nsv(GLuint index, const GLshort *v)
1705 {
1706 Context *context = GetValidGlobalContext();
1707 EVENT("glVertexAttrib4Nsv",
1708 "context = %d, GLuint index = %u, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
1709 index, (uintptr_t)v);
1710
1711 if (context)
1712 {
1713 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1714 bool isCallValid =
1715 (context->skipValidation() || ValidateVertexAttrib4Nsv(context, index, v));
1716 if (isCallValid)
1717 {
1718 context->vertexAttrib4Nsv(index, v);
1719 }
1720 ANGLE_CAPTURE(VertexAttrib4Nsv, isCallValid, context, index, v);
1721 }
1722 }
1723
VertexAttrib4Nub(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)1724 void GL_APIENTRY VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
1725 {
1726 Context *context = GetValidGlobalContext();
1727 EVENT("glVertexAttrib4Nub",
1728 "context = %d, GLuint index = %u, GLubyte x = %d, GLubyte y = %d, GLubyte z = %d, "
1729 "GLubyte w = %d",
1730 CID(context), index, x, y, z, w);
1731
1732 if (context)
1733 {
1734 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1735 bool isCallValid =
1736 (context->skipValidation() || ValidateVertexAttrib4Nub(context, index, x, y, z, w));
1737 if (isCallValid)
1738 {
1739 context->vertexAttrib4Nub(index, x, y, z, w);
1740 }
1741 ANGLE_CAPTURE(VertexAttrib4Nub, isCallValid, context, index, x, y, z, w);
1742 }
1743 }
1744
VertexAttrib4Nubv(GLuint index,const GLubyte * v)1745 void GL_APIENTRY VertexAttrib4Nubv(GLuint index, const GLubyte *v)
1746 {
1747 Context *context = GetValidGlobalContext();
1748 EVENT("glVertexAttrib4Nubv",
1749 "context = %d, GLuint index = %u, const GLubyte *v = 0x%016" PRIxPTR "", CID(context),
1750 index, (uintptr_t)v);
1751
1752 if (context)
1753 {
1754 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1755 bool isCallValid =
1756 (context->skipValidation() || ValidateVertexAttrib4Nubv(context, index, v));
1757 if (isCallValid)
1758 {
1759 context->vertexAttrib4Nubv(index, v);
1760 }
1761 ANGLE_CAPTURE(VertexAttrib4Nubv, isCallValid, context, index, v);
1762 }
1763 }
1764
VertexAttrib4Nuiv(GLuint index,const GLuint * v)1765 void GL_APIENTRY VertexAttrib4Nuiv(GLuint index, const GLuint *v)
1766 {
1767 Context *context = GetValidGlobalContext();
1768 EVENT("glVertexAttrib4Nuiv",
1769 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
1770 index, (uintptr_t)v);
1771
1772 if (context)
1773 {
1774 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1775 bool isCallValid =
1776 (context->skipValidation() || ValidateVertexAttrib4Nuiv(context, index, v));
1777 if (isCallValid)
1778 {
1779 context->vertexAttrib4Nuiv(index, v);
1780 }
1781 ANGLE_CAPTURE(VertexAttrib4Nuiv, isCallValid, context, index, v);
1782 }
1783 }
1784
VertexAttrib4Nusv(GLuint index,const GLushort * v)1785 void GL_APIENTRY VertexAttrib4Nusv(GLuint index, const GLushort *v)
1786 {
1787 Context *context = GetValidGlobalContext();
1788 EVENT("glVertexAttrib4Nusv",
1789 "context = %d, GLuint index = %u, const GLushort *v = 0x%016" PRIxPTR "", CID(context),
1790 index, (uintptr_t)v);
1791
1792 if (context)
1793 {
1794 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1795 bool isCallValid =
1796 (context->skipValidation() || ValidateVertexAttrib4Nusv(context, index, v));
1797 if (isCallValid)
1798 {
1799 context->vertexAttrib4Nusv(index, v);
1800 }
1801 ANGLE_CAPTURE(VertexAttrib4Nusv, isCallValid, context, index, v);
1802 }
1803 }
1804
VertexAttrib4bv(GLuint index,const GLbyte * v)1805 void GL_APIENTRY VertexAttrib4bv(GLuint index, const GLbyte *v)
1806 {
1807 Context *context = GetValidGlobalContext();
1808 EVENT("glVertexAttrib4bv",
1809 "context = %d, GLuint index = %u, const GLbyte *v = 0x%016" PRIxPTR "", CID(context),
1810 index, (uintptr_t)v);
1811
1812 if (context)
1813 {
1814 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1815 bool isCallValid =
1816 (context->skipValidation() || ValidateVertexAttrib4bv(context, index, v));
1817 if (isCallValid)
1818 {
1819 context->vertexAttrib4bv(index, v);
1820 }
1821 ANGLE_CAPTURE(VertexAttrib4bv, isCallValid, context, index, v);
1822 }
1823 }
1824
VertexAttrib4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)1825 void GL_APIENTRY VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1826 {
1827 Context *context = GetValidGlobalContext();
1828 EVENT("glVertexAttrib4d",
1829 "context = %d, GLuint index = %u, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, "
1830 "GLdouble w = %f",
1831 CID(context), index, x, y, z, w);
1832
1833 if (context)
1834 {
1835 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1836 bool isCallValid =
1837 (context->skipValidation() || ValidateVertexAttrib4d(context, index, x, y, z, w));
1838 if (isCallValid)
1839 {
1840 context->vertexAttrib4d(index, x, y, z, w);
1841 }
1842 ANGLE_CAPTURE(VertexAttrib4d, isCallValid, context, index, x, y, z, w);
1843 }
1844 }
1845
VertexAttrib4dv(GLuint index,const GLdouble * v)1846 void GL_APIENTRY VertexAttrib4dv(GLuint index, const GLdouble *v)
1847 {
1848 Context *context = GetValidGlobalContext();
1849 EVENT("glVertexAttrib4dv",
1850 "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
1851 index, (uintptr_t)v);
1852
1853 if (context)
1854 {
1855 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1856 bool isCallValid =
1857 (context->skipValidation() || ValidateVertexAttrib4dv(context, index, v));
1858 if (isCallValid)
1859 {
1860 context->vertexAttrib4dv(index, v);
1861 }
1862 ANGLE_CAPTURE(VertexAttrib4dv, isCallValid, context, index, v);
1863 }
1864 }
1865
VertexAttrib4f(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)1866 void GL_APIENTRY VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1867 {
1868 Context *context = GetValidGlobalContext();
1869 EVENT("glVertexAttrib4f",
1870 "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, "
1871 "GLfloat w = %f",
1872 CID(context), index, x, y, z, w);
1873
1874 if (context)
1875 {
1876 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1877 bool isCallValid =
1878 (context->skipValidation() || ValidateVertexAttrib4f(context, index, x, y, z, w));
1879 if (isCallValid)
1880 {
1881 context->vertexAttrib4f(index, x, y, z, w);
1882 }
1883 ANGLE_CAPTURE(VertexAttrib4f, isCallValid, context, index, x, y, z, w);
1884 }
1885 }
1886
VertexAttrib4fv(GLuint index,const GLfloat * v)1887 void GL_APIENTRY VertexAttrib4fv(GLuint index, const GLfloat *v)
1888 {
1889 Context *context = GetValidGlobalContext();
1890 EVENT("glVertexAttrib4fv",
1891 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
1892 index, (uintptr_t)v);
1893
1894 if (context)
1895 {
1896 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1897 bool isCallValid =
1898 (context->skipValidation() || ValidateVertexAttrib4fv(context, index, v));
1899 if (isCallValid)
1900 {
1901 context->vertexAttrib4fv(index, v);
1902 }
1903 ANGLE_CAPTURE(VertexAttrib4fv, isCallValid, context, index, v);
1904 }
1905 }
1906
VertexAttrib4iv(GLuint index,const GLint * v)1907 void GL_APIENTRY VertexAttrib4iv(GLuint index, const GLint *v)
1908 {
1909 Context *context = GetValidGlobalContext();
1910 EVENT("glVertexAttrib4iv",
1911 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
1912 index, (uintptr_t)v);
1913
1914 if (context)
1915 {
1916 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1917 bool isCallValid =
1918 (context->skipValidation() || ValidateVertexAttrib4iv(context, index, v));
1919 if (isCallValid)
1920 {
1921 context->vertexAttrib4iv(index, v);
1922 }
1923 ANGLE_CAPTURE(VertexAttrib4iv, isCallValid, context, index, v);
1924 }
1925 }
1926
VertexAttrib4s(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)1927 void GL_APIENTRY VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
1928 {
1929 Context *context = GetValidGlobalContext();
1930 EVENT("glVertexAttrib4s",
1931 "context = %d, GLuint index = %u, GLshort x = %d, GLshort y = %d, GLshort z = %d, "
1932 "GLshort w = %d",
1933 CID(context), index, x, y, z, w);
1934
1935 if (context)
1936 {
1937 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1938 bool isCallValid =
1939 (context->skipValidation() || ValidateVertexAttrib4s(context, index, x, y, z, w));
1940 if (isCallValid)
1941 {
1942 context->vertexAttrib4s(index, x, y, z, w);
1943 }
1944 ANGLE_CAPTURE(VertexAttrib4s, isCallValid, context, index, x, y, z, w);
1945 }
1946 }
1947
VertexAttrib4sv(GLuint index,const GLshort * v)1948 void GL_APIENTRY VertexAttrib4sv(GLuint index, const GLshort *v)
1949 {
1950 Context *context = GetValidGlobalContext();
1951 EVENT("glVertexAttrib4sv",
1952 "context = %d, GLuint index = %u, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
1953 index, (uintptr_t)v);
1954
1955 if (context)
1956 {
1957 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1958 bool isCallValid =
1959 (context->skipValidation() || ValidateVertexAttrib4sv(context, index, v));
1960 if (isCallValid)
1961 {
1962 context->vertexAttrib4sv(index, v);
1963 }
1964 ANGLE_CAPTURE(VertexAttrib4sv, isCallValid, context, index, v);
1965 }
1966 }
1967
VertexAttrib4ubv(GLuint index,const GLubyte * v)1968 void GL_APIENTRY VertexAttrib4ubv(GLuint index, const GLubyte *v)
1969 {
1970 Context *context = GetValidGlobalContext();
1971 EVENT("glVertexAttrib4ubv",
1972 "context = %d, GLuint index = %u, const GLubyte *v = 0x%016" PRIxPTR "", CID(context),
1973 index, (uintptr_t)v);
1974
1975 if (context)
1976 {
1977 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1978 bool isCallValid =
1979 (context->skipValidation() || ValidateVertexAttrib4ubv(context, index, v));
1980 if (isCallValid)
1981 {
1982 context->vertexAttrib4ubv(index, v);
1983 }
1984 ANGLE_CAPTURE(VertexAttrib4ubv, isCallValid, context, index, v);
1985 }
1986 }
1987
VertexAttrib4uiv(GLuint index,const GLuint * v)1988 void GL_APIENTRY VertexAttrib4uiv(GLuint index, const GLuint *v)
1989 {
1990 Context *context = GetValidGlobalContext();
1991 EVENT("glVertexAttrib4uiv",
1992 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
1993 index, (uintptr_t)v);
1994
1995 if (context)
1996 {
1997 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1998 bool isCallValid =
1999 (context->skipValidation() || ValidateVertexAttrib4uiv(context, index, v));
2000 if (isCallValid)
2001 {
2002 context->vertexAttrib4uiv(index, v);
2003 }
2004 ANGLE_CAPTURE(VertexAttrib4uiv, isCallValid, context, index, v);
2005 }
2006 }
2007
VertexAttrib4usv(GLuint index,const GLushort * v)2008 void GL_APIENTRY VertexAttrib4usv(GLuint index, const GLushort *v)
2009 {
2010 Context *context = GetValidGlobalContext();
2011 EVENT("glVertexAttrib4usv",
2012 "context = %d, GLuint index = %u, const GLushort *v = 0x%016" PRIxPTR "", CID(context),
2013 index, (uintptr_t)v);
2014
2015 if (context)
2016 {
2017 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2018 bool isCallValid =
2019 (context->skipValidation() || ValidateVertexAttrib4usv(context, index, v));
2020 if (isCallValid)
2021 {
2022 context->vertexAttrib4usv(index, v);
2023 }
2024 ANGLE_CAPTURE(VertexAttrib4usv, isCallValid, context, index, v);
2025 }
2026 }
2027
VertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void * pointer)2028 void GL_APIENTRY VertexAttribPointer(GLuint index,
2029 GLint size,
2030 GLenum type,
2031 GLboolean normalized,
2032 GLsizei stride,
2033 const void *pointer)
2034 {
2035 Context *context = GetValidGlobalContext();
2036 EVENT("glVertexAttribPointer",
2037 "context = %d, GLuint index = %u, GLint size = %d, GLenum type = %s, GLboolean "
2038 "normalized = %s, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR "",
2039 CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
2040 GLbooleanToString(normalized), stride, (uintptr_t)pointer);
2041
2042 if (context)
2043 {
2044 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
2045 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2046 bool isCallValid = (context->skipValidation() ||
2047 ValidateVertexAttribPointer(context, index, size, typePacked,
2048 normalized, stride, pointer));
2049 if (isCallValid)
2050 {
2051 context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
2052 }
2053 ANGLE_CAPTURE(VertexAttribPointer, isCallValid, context, index, size, typePacked,
2054 normalized, stride, pointer);
2055 }
2056 }
2057 } // namespace gl
2058