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