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_3_0_autogen.cpp:
9 // Defines the GL 3.0 entry points.
10
11 #include "libGL/entry_points_gl_3_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/validationGL3_autogen.h"
26 #include "libGLESv2/global_state.h"
27
28 namespace gl
29 {
BeginConditionalRender(GLuint id,GLenum mode)30 void GL_APIENTRY BeginConditionalRender(GLuint id, GLenum mode)
31 {
32 Context *context = GetValidGlobalContext();
33 EVENT("glBeginConditionalRender", "context = %d, GLuint id = %u, GLenum mode = %s",
34 CID(context), id, GLenumToString(GLenumGroup::TypeEnum, mode));
35
36 if (context)
37 {
38 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
39 bool isCallValid =
40 (context->skipValidation() || ValidateBeginConditionalRender(context, id, mode));
41 if (isCallValid)
42 {
43 context->beginConditionalRender(id, mode);
44 }
45 ANGLE_CAPTURE(BeginConditionalRender, isCallValid, context, id, mode);
46 }
47 }
48
BeginTransformFeedback(GLenum primitiveMode)49 void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode)
50 {
51 Context *context = GetValidGlobalContext();
52 EVENT("glBeginTransformFeedback", "context = %d, GLenum primitiveMode = %s", CID(context),
53 GLenumToString(GLenumGroup::PrimitiveType, primitiveMode));
54
55 if (context)
56 {
57 PrimitiveMode primitiveModePacked = FromGL<PrimitiveMode>(primitiveMode);
58 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
59 bool isCallValid = (context->skipValidation() ||
60 ValidateBeginTransformFeedback(context, primitiveModePacked));
61 if (isCallValid)
62 {
63 context->beginTransformFeedback(primitiveModePacked);
64 }
65 ANGLE_CAPTURE(BeginTransformFeedback, isCallValid, context, primitiveModePacked);
66 }
67 }
68
BindBufferBase(GLenum target,GLuint index,GLuint buffer)69 void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
70 {
71 Context *context = GetValidGlobalContext();
72 EVENT("glBindBufferBase",
73 "context = %d, GLenum target = %s, GLuint index = %u, GLuint buffer = %u", CID(context),
74 GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer);
75
76 if (context)
77 {
78 BufferBinding targetPacked = FromGL<BufferBinding>(target);
79 BufferID bufferPacked = FromGL<BufferID>(buffer);
80 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
81 bool isCallValid = (context->skipValidation() ||
82 ValidateBindBufferBase(context, targetPacked, index, bufferPacked));
83 if (isCallValid)
84 {
85 context->bindBufferBase(targetPacked, index, bufferPacked);
86 }
87 ANGLE_CAPTURE(BindBufferBase, isCallValid, context, targetPacked, index, bufferPacked);
88 }
89 }
90
91 void GL_APIENTRY
BindBufferRange(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size)92 BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
93 {
94 Context *context = GetValidGlobalContext();
95 EVENT("glBindBufferRange",
96 "context = %d, GLenum target = %s, GLuint index = %u, GLuint buffer = %u, GLintptr "
97 "offset = %llu, GLsizeiptr size = %llu",
98 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer,
99 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
100
101 if (context)
102 {
103 BufferBinding targetPacked = FromGL<BufferBinding>(target);
104 BufferID bufferPacked = FromGL<BufferID>(buffer);
105 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
106 bool isCallValid =
107 (context->skipValidation() ||
108 ValidateBindBufferRange(context, targetPacked, index, bufferPacked, offset, size));
109 if (isCallValid)
110 {
111 context->bindBufferRange(targetPacked, index, bufferPacked, offset, size);
112 }
113 ANGLE_CAPTURE(BindBufferRange, isCallValid, context, targetPacked, index, bufferPacked,
114 offset, size);
115 }
116 }
117
BindFragDataLocation(GLuint program,GLuint color,const GLchar * name)118 void GL_APIENTRY BindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
119 {
120 Context *context = GetValidGlobalContext();
121 EVENT(
122 "glBindFragDataLocation",
123 "context = %d, GLuint program = %u, GLuint color = %u, const GLchar *name = 0x%016" PRIxPTR
124 "",
125 CID(context), program, color, (uintptr_t)name);
126
127 if (context)
128 {
129 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
130 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
131 bool isCallValid = (context->skipValidation() ||
132 ValidateBindFragDataLocation(context, programPacked, color, name));
133 if (isCallValid)
134 {
135 context->bindFragDataLocation(programPacked, color, name);
136 }
137 ANGLE_CAPTURE(BindFragDataLocation, isCallValid, context, programPacked, color, name);
138 }
139 }
140
BindFramebuffer(GLenum target,GLuint framebuffer)141 void GL_APIENTRY BindFramebuffer(GLenum target, GLuint framebuffer)
142 {
143 Context *context = GetValidGlobalContext();
144 EVENT("glBindFramebuffer", "context = %d, GLenum target = %s, GLuint framebuffer = %u",
145 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer);
146
147 if (context)
148 {
149 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
150 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
151 bool isCallValid = (context->skipValidation() ||
152 ValidateBindFramebuffer(context, target, framebufferPacked));
153 if (isCallValid)
154 {
155 context->bindFramebuffer(target, framebufferPacked);
156 }
157 ANGLE_CAPTURE(BindFramebuffer, isCallValid, context, target, framebufferPacked);
158 }
159 }
160
BindRenderbuffer(GLenum target,GLuint renderbuffer)161 void GL_APIENTRY BindRenderbuffer(GLenum target, GLuint renderbuffer)
162 {
163 Context *context = GetValidGlobalContext();
164 EVENT("glBindRenderbuffer", "context = %d, GLenum target = %s, GLuint renderbuffer = %u",
165 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer);
166
167 if (context)
168 {
169 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
170 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
171 bool isCallValid = (context->skipValidation() ||
172 ValidateBindRenderbuffer(context, target, renderbufferPacked));
173 if (isCallValid)
174 {
175 context->bindRenderbuffer(target, renderbufferPacked);
176 }
177 ANGLE_CAPTURE(BindRenderbuffer, isCallValid, context, target, renderbufferPacked);
178 }
179 }
180
BindVertexArray(GLuint array)181 void GL_APIENTRY BindVertexArray(GLuint array)
182 {
183 Context *context = GetValidGlobalContext();
184 EVENT("glBindVertexArray", "context = %d, GLuint array = %u", CID(context), array);
185
186 if (context)
187 {
188 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
189 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
190 bool isCallValid =
191 (context->skipValidation() || ValidateBindVertexArray(context, arrayPacked));
192 if (isCallValid)
193 {
194 context->bindVertexArray(arrayPacked);
195 }
196 ANGLE_CAPTURE(BindVertexArray, isCallValid, context, arrayPacked);
197 }
198 }
199
BlitFramebuffer(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)200 void GL_APIENTRY BlitFramebuffer(GLint srcX0,
201 GLint srcY0,
202 GLint srcX1,
203 GLint srcY1,
204 GLint dstX0,
205 GLint dstY0,
206 GLint dstX1,
207 GLint dstY1,
208 GLbitfield mask,
209 GLenum filter)
210 {
211 Context *context = GetValidGlobalContext();
212 EVENT("glBlitFramebuffer",
213 "context = %d, GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
214 "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask "
215 "= %s, GLenum filter = %s",
216 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
217 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
218 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
219
220 if (context)
221 {
222 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
223 bool isCallValid = (context->skipValidation() ||
224 ValidateBlitFramebuffer(context, srcX0, srcY0, srcX1, srcY1, dstX0,
225 dstY0, dstX1, dstY1, mask, filter));
226 if (isCallValid)
227 {
228 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
229 filter);
230 }
231 ANGLE_CAPTURE(BlitFramebuffer, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
232 dstY0, dstX1, dstY1, mask, filter);
233 }
234 }
235
CheckFramebufferStatus(GLenum target)236 GLenum GL_APIENTRY CheckFramebufferStatus(GLenum target)
237 {
238 Context *context = GetValidGlobalContext();
239 EVENT("glCheckFramebufferStatus", "context = %d, GLenum target = %s", CID(context),
240 GLenumToString(GLenumGroup::FramebufferTarget, target));
241
242 GLenum returnValue;
243 if (context)
244 {
245 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
246 bool isCallValid =
247 (context->skipValidation() || ValidateCheckFramebufferStatus(context, target));
248 if (isCallValid)
249 {
250 returnValue = context->checkFramebufferStatus(target);
251 }
252 else
253 {
254 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatus, GLenum>();
255 }
256 ANGLE_CAPTURE(CheckFramebufferStatus, isCallValid, context, target, returnValue);
257 }
258 else
259 {
260 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatus, GLenum>();
261 }
262 return returnValue;
263 }
264
ClampColor(GLenum target,GLenum clamp)265 void GL_APIENTRY ClampColor(GLenum target, GLenum clamp)
266 {
267 Context *context = GetValidGlobalContext();
268 EVENT("glClampColor", "context = %d, GLenum target = %s, GLenum clamp = %s", CID(context),
269 GLenumToString(GLenumGroup::DefaultGroup, target),
270 GLenumToString(GLenumGroup::DefaultGroup, clamp));
271
272 if (context)
273 {
274 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
275 bool isCallValid =
276 (context->skipValidation() || ValidateClampColor(context, target, clamp));
277 if (isCallValid)
278 {
279 context->clampColor(target, clamp);
280 }
281 ANGLE_CAPTURE(ClampColor, isCallValid, context, target, clamp);
282 }
283 }
284
ClearBufferfi(GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil)285 void GL_APIENTRY ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
286 {
287 Context *context = GetValidGlobalContext();
288 EVENT("glClearBufferfi",
289 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, GLfloat depth = %f, GLint "
290 "stencil = %d",
291 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, depth, stencil);
292
293 if (context)
294 {
295 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
296 bool isCallValid = (context->skipValidation() ||
297 ValidateClearBufferfi(context, buffer, drawbuffer, depth, stencil));
298 if (isCallValid)
299 {
300 context->clearBufferfi(buffer, drawbuffer, depth, stencil);
301 }
302 ANGLE_CAPTURE(ClearBufferfi, isCallValid, context, buffer, drawbuffer, depth, stencil);
303 }
304 }
305
ClearBufferfv(GLenum buffer,GLint drawbuffer,const GLfloat * value)306 void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
307 {
308 Context *context = GetValidGlobalContext();
309 EVENT("glClearBufferfv",
310 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, const GLfloat *value = "
311 "0x%016" PRIxPTR "",
312 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
313
314 if (context)
315 {
316 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
317 bool isCallValid = (context->skipValidation() ||
318 ValidateClearBufferfv(context, buffer, drawbuffer, value));
319 if (isCallValid)
320 {
321 context->clearBufferfv(buffer, drawbuffer, value);
322 }
323 ANGLE_CAPTURE(ClearBufferfv, isCallValid, context, buffer, drawbuffer, value);
324 }
325 }
326
ClearBufferiv(GLenum buffer,GLint drawbuffer,const GLint * value)327 void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
328 {
329 Context *context = GetValidGlobalContext();
330 EVENT("glClearBufferiv",
331 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, const GLint *value = "
332 "0x%016" PRIxPTR "",
333 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
334
335 if (context)
336 {
337 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
338 bool isCallValid = (context->skipValidation() ||
339 ValidateClearBufferiv(context, buffer, drawbuffer, value));
340 if (isCallValid)
341 {
342 context->clearBufferiv(buffer, drawbuffer, value);
343 }
344 ANGLE_CAPTURE(ClearBufferiv, isCallValid, context, buffer, drawbuffer, value);
345 }
346 }
347
ClearBufferuiv(GLenum buffer,GLint drawbuffer,const GLuint * value)348 void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
349 {
350 Context *context = GetValidGlobalContext();
351 EVENT("glClearBufferuiv",
352 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, const GLuint *value = "
353 "0x%016" PRIxPTR "",
354 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
355
356 if (context)
357 {
358 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
359 bool isCallValid = (context->skipValidation() ||
360 ValidateClearBufferuiv(context, buffer, drawbuffer, value));
361 if (isCallValid)
362 {
363 context->clearBufferuiv(buffer, drawbuffer, value);
364 }
365 ANGLE_CAPTURE(ClearBufferuiv, isCallValid, context, buffer, drawbuffer, value);
366 }
367 }
368
ColorMaski(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)369 void GL_APIENTRY ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
370 {
371 Context *context = GetValidGlobalContext();
372 EVENT("glColorMaski",
373 "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
374 "GLboolean a = %s",
375 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
376 GLbooleanToString(a));
377
378 if (context)
379 {
380 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
381 bool isCallValid =
382 (context->skipValidation() || ValidateColorMaski(context, index, r, g, b, a));
383 if (isCallValid)
384 {
385 context->colorMaski(index, r, g, b, a);
386 }
387 ANGLE_CAPTURE(ColorMaski, isCallValid, context, index, r, g, b, a);
388 }
389 }
390
DeleteFramebuffers(GLsizei n,const GLuint * framebuffers)391 void GL_APIENTRY DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
392 {
393 Context *context = GetValidGlobalContext();
394 EVENT("glDeleteFramebuffers",
395 "context = %d, GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR "",
396 CID(context), n, (uintptr_t)framebuffers);
397
398 if (context)
399 {
400 const FramebufferID *framebuffersPacked = FromGL<const FramebufferID *>(framebuffers);
401 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
402 bool isCallValid = (context->skipValidation() ||
403 ValidateDeleteFramebuffers(context, n, framebuffersPacked));
404 if (isCallValid)
405 {
406 context->deleteFramebuffers(n, framebuffersPacked);
407 }
408 ANGLE_CAPTURE(DeleteFramebuffers, isCallValid, context, n, framebuffersPacked);
409 }
410 }
411
DeleteRenderbuffers(GLsizei n,const GLuint * renderbuffers)412 void GL_APIENTRY DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
413 {
414 Context *context = GetValidGlobalContext();
415 EVENT("glDeleteRenderbuffers",
416 "context = %d, GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR "",
417 CID(context), n, (uintptr_t)renderbuffers);
418
419 if (context)
420 {
421 const RenderbufferID *renderbuffersPacked = FromGL<const RenderbufferID *>(renderbuffers);
422 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
423 bool isCallValid = (context->skipValidation() ||
424 ValidateDeleteRenderbuffers(context, n, renderbuffersPacked));
425 if (isCallValid)
426 {
427 context->deleteRenderbuffers(n, renderbuffersPacked);
428 }
429 ANGLE_CAPTURE(DeleteRenderbuffers, isCallValid, context, n, renderbuffersPacked);
430 }
431 }
432
DeleteVertexArrays(GLsizei n,const GLuint * arrays)433 void GL_APIENTRY DeleteVertexArrays(GLsizei n, const GLuint *arrays)
434 {
435 Context *context = GetValidGlobalContext();
436 EVENT("glDeleteVertexArrays",
437 "context = %d, GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR "", CID(context), n,
438 (uintptr_t)arrays);
439
440 if (context)
441 {
442 const VertexArrayID *arraysPacked = FromGL<const VertexArrayID *>(arrays);
443 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
444 bool isCallValid =
445 (context->skipValidation() || ValidateDeleteVertexArrays(context, n, arraysPacked));
446 if (isCallValid)
447 {
448 context->deleteVertexArrays(n, arraysPacked);
449 }
450 ANGLE_CAPTURE(DeleteVertexArrays, isCallValid, context, n, arraysPacked);
451 }
452 }
453
Disablei(GLenum target,GLuint index)454 void GL_APIENTRY Disablei(GLenum target, GLuint index)
455 {
456 Context *context = GetValidGlobalContext();
457 EVENT("glDisablei", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
458 GLenumToString(GLenumGroup::EnableCap, target), index);
459
460 if (context)
461 {
462 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
463 bool isCallValid = (context->skipValidation() || ValidateDisablei(context, target, index));
464 if (isCallValid)
465 {
466 context->disablei(target, index);
467 }
468 ANGLE_CAPTURE(Disablei, isCallValid, context, target, index);
469 }
470 }
471
Enablei(GLenum target,GLuint index)472 void GL_APIENTRY Enablei(GLenum target, GLuint index)
473 {
474 Context *context = GetValidGlobalContext();
475 EVENT("glEnablei", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
476 GLenumToString(GLenumGroup::EnableCap, target), index);
477
478 if (context)
479 {
480 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
481 bool isCallValid = (context->skipValidation() || ValidateEnablei(context, target, index));
482 if (isCallValid)
483 {
484 context->enablei(target, index);
485 }
486 ANGLE_CAPTURE(Enablei, isCallValid, context, target, index);
487 }
488 }
489
EndConditionalRender()490 void GL_APIENTRY EndConditionalRender()
491 {
492 Context *context = GetValidGlobalContext();
493 EVENT("glEndConditionalRender", "context = %d", CID(context));
494
495 if (context)
496 {
497 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
498 bool isCallValid = (context->skipValidation() || ValidateEndConditionalRender(context));
499 if (isCallValid)
500 {
501 context->endConditionalRender();
502 }
503 ANGLE_CAPTURE(EndConditionalRender, isCallValid, context);
504 }
505 }
506
EndTransformFeedback()507 void GL_APIENTRY EndTransformFeedback()
508 {
509 Context *context = GetValidGlobalContext();
510 EVENT("glEndTransformFeedback", "context = %d", CID(context));
511
512 if (context)
513 {
514 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
515 bool isCallValid = (context->skipValidation() || ValidateEndTransformFeedback(context));
516 if (isCallValid)
517 {
518 context->endTransformFeedback();
519 }
520 ANGLE_CAPTURE(EndTransformFeedback, isCallValid, context);
521 }
522 }
523
FlushMappedBufferRange(GLenum target,GLintptr offset,GLsizeiptr length)524 void GL_APIENTRY FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
525 {
526 Context *context = GetValidGlobalContext();
527 EVENT("glFlushMappedBufferRange",
528 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu",
529 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
530 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
531
532 if (context)
533 {
534 BufferBinding targetPacked = FromGL<BufferBinding>(target);
535 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
536 bool isCallValid = (context->skipValidation() ||
537 ValidateFlushMappedBufferRange(context, targetPacked, offset, length));
538 if (isCallValid)
539 {
540 context->flushMappedBufferRange(targetPacked, offset, length);
541 }
542 ANGLE_CAPTURE(FlushMappedBufferRange, isCallValid, context, targetPacked, offset, length);
543 }
544 }
545
FramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)546 void GL_APIENTRY FramebufferRenderbuffer(GLenum target,
547 GLenum attachment,
548 GLenum renderbuffertarget,
549 GLuint renderbuffer)
550 {
551 Context *context = GetValidGlobalContext();
552 EVENT("glFramebufferRenderbuffer",
553 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum renderbuffertarget = "
554 "%s, GLuint renderbuffer = %u",
555 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
556 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
557 GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer);
558
559 if (context)
560 {
561 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
562 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
563 bool isCallValid =
564 (context->skipValidation() ||
565 ValidateFramebufferRenderbuffer(context, target, attachment, renderbuffertarget,
566 renderbufferPacked));
567 if (isCallValid)
568 {
569 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
570 renderbufferPacked);
571 }
572 ANGLE_CAPTURE(FramebufferRenderbuffer, isCallValid, context, target, attachment,
573 renderbuffertarget, renderbufferPacked);
574 }
575 }
576
FramebufferTexture1D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)577 void GL_APIENTRY FramebufferTexture1D(GLenum target,
578 GLenum attachment,
579 GLenum textarget,
580 GLuint texture,
581 GLint level)
582 {
583 Context *context = GetValidGlobalContext();
584 EVENT("glFramebufferTexture1D",
585 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
586 "texture = %u, GLint level = %d",
587 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
588 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
589 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
590
591 if (context)
592 {
593 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
594 TextureID texturePacked = FromGL<TextureID>(texture);
595 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
596 bool isCallValid = (context->skipValidation() ||
597 ValidateFramebufferTexture1D(context, target, attachment,
598 textargetPacked, texturePacked, level));
599 if (isCallValid)
600 {
601 context->framebufferTexture1D(target, attachment, textargetPacked, texturePacked,
602 level);
603 }
604 ANGLE_CAPTURE(FramebufferTexture1D, isCallValid, context, target, attachment,
605 textargetPacked, texturePacked, level);
606 }
607 }
608
FramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)609 void GL_APIENTRY FramebufferTexture2D(GLenum target,
610 GLenum attachment,
611 GLenum textarget,
612 GLuint texture,
613 GLint level)
614 {
615 Context *context = GetValidGlobalContext();
616 EVENT("glFramebufferTexture2D",
617 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
618 "texture = %u, GLint level = %d",
619 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
620 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
621 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
622
623 if (context)
624 {
625 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
626 TextureID texturePacked = FromGL<TextureID>(texture);
627 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
628 bool isCallValid = (context->skipValidation() ||
629 ValidateFramebufferTexture2D(context, target, attachment,
630 textargetPacked, texturePacked, level));
631 if (isCallValid)
632 {
633 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
634 level);
635 }
636 ANGLE_CAPTURE(FramebufferTexture2D, isCallValid, context, target, attachment,
637 textargetPacked, texturePacked, level);
638 }
639 }
640
FramebufferTexture3D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)641 void GL_APIENTRY FramebufferTexture3D(GLenum target,
642 GLenum attachment,
643 GLenum textarget,
644 GLuint texture,
645 GLint level,
646 GLint zoffset)
647 {
648 Context *context = GetValidGlobalContext();
649 EVENT("glFramebufferTexture3D",
650 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
651 "texture = %u, GLint level = %d, GLint zoffset = %d",
652 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
653 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
654 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset);
655
656 if (context)
657 {
658 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
659 TextureID texturePacked = FromGL<TextureID>(texture);
660 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
661 bool isCallValid =
662 (context->skipValidation() ||
663 ValidateFramebufferTexture3D(context, target, attachment, textargetPacked,
664 texturePacked, level, zoffset));
665 if (isCallValid)
666 {
667 context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
668 zoffset);
669 }
670 ANGLE_CAPTURE(FramebufferTexture3D, isCallValid, context, target, attachment,
671 textargetPacked, texturePacked, level, zoffset);
672 }
673 }
674
675 void GL_APIENTRY
FramebufferTextureLayer(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)676 FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
677 {
678 Context *context = GetValidGlobalContext();
679 EVENT("glFramebufferTextureLayer",
680 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
681 "level = %d, GLint layer = %d",
682 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
683 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level, layer);
684
685 if (context)
686 {
687 TextureID texturePacked = FromGL<TextureID>(texture);
688 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
689 bool isCallValid = (context->skipValidation() ||
690 ValidateFramebufferTextureLayer(context, target, attachment,
691 texturePacked, level, layer));
692 if (isCallValid)
693 {
694 context->framebufferTextureLayer(target, attachment, texturePacked, level, layer);
695 }
696 ANGLE_CAPTURE(FramebufferTextureLayer, isCallValid, context, target, attachment,
697 texturePacked, level, layer);
698 }
699 }
700
GenFramebuffers(GLsizei n,GLuint * framebuffers)701 void GL_APIENTRY GenFramebuffers(GLsizei n, GLuint *framebuffers)
702 {
703 Context *context = GetValidGlobalContext();
704 EVENT("glGenFramebuffers",
705 "context = %d, GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR "", CID(context), n,
706 (uintptr_t)framebuffers);
707
708 if (context)
709 {
710 FramebufferID *framebuffersPacked = FromGL<FramebufferID *>(framebuffers);
711 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
712 bool isCallValid =
713 (context->skipValidation() || ValidateGenFramebuffers(context, n, framebuffersPacked));
714 if (isCallValid)
715 {
716 context->genFramebuffers(n, framebuffersPacked);
717 }
718 ANGLE_CAPTURE(GenFramebuffers, isCallValid, context, n, framebuffersPacked);
719 }
720 }
721
GenRenderbuffers(GLsizei n,GLuint * renderbuffers)722 void GL_APIENTRY GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
723 {
724 Context *context = GetValidGlobalContext();
725 EVENT("glGenRenderbuffers",
726 "context = %d, GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR "", CID(context),
727 n, (uintptr_t)renderbuffers);
728
729 if (context)
730 {
731 RenderbufferID *renderbuffersPacked = FromGL<RenderbufferID *>(renderbuffers);
732 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
733 bool isCallValid = (context->skipValidation() ||
734 ValidateGenRenderbuffers(context, n, renderbuffersPacked));
735 if (isCallValid)
736 {
737 context->genRenderbuffers(n, renderbuffersPacked);
738 }
739 ANGLE_CAPTURE(GenRenderbuffers, isCallValid, context, n, renderbuffersPacked);
740 }
741 }
742
GenVertexArrays(GLsizei n,GLuint * arrays)743 void GL_APIENTRY GenVertexArrays(GLsizei n, GLuint *arrays)
744 {
745 Context *context = GetValidGlobalContext();
746 EVENT("glGenVertexArrays", "context = %d, GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR "",
747 CID(context), n, (uintptr_t)arrays);
748
749 if (context)
750 {
751 VertexArrayID *arraysPacked = FromGL<VertexArrayID *>(arrays);
752 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
753 bool isCallValid =
754 (context->skipValidation() || ValidateGenVertexArrays(context, n, arraysPacked));
755 if (isCallValid)
756 {
757 context->genVertexArrays(n, arraysPacked);
758 }
759 ANGLE_CAPTURE(GenVertexArrays, isCallValid, context, n, arraysPacked);
760 }
761 }
762
GenerateMipmap(GLenum target)763 void GL_APIENTRY GenerateMipmap(GLenum target)
764 {
765 Context *context = GetValidGlobalContext();
766 EVENT("glGenerateMipmap", "context = %d, GLenum target = %s", CID(context),
767 GLenumToString(GLenumGroup::TextureTarget, target));
768
769 if (context)
770 {
771 TextureType targetPacked = FromGL<TextureType>(target);
772 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
773 bool isCallValid =
774 (context->skipValidation() || ValidateGenerateMipmap(context, targetPacked));
775 if (isCallValid)
776 {
777 context->generateMipmap(targetPacked);
778 }
779 ANGLE_CAPTURE(GenerateMipmap, isCallValid, context, targetPacked);
780 }
781 }
782
GetBooleani_v(GLenum target,GLuint index,GLboolean * data)783 void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
784 {
785 Context *context = GetValidGlobalContext();
786 EVENT(
787 "glGetBooleani_v",
788 "context = %d, GLenum target = %s, GLuint index = %u, GLboolean *data = 0x%016" PRIxPTR "",
789 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, (uintptr_t)data);
790
791 if (context)
792 {
793 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
794 bool isCallValid =
795 (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data));
796 if (isCallValid)
797 {
798 context->getBooleani_v(target, index, data);
799 }
800 ANGLE_CAPTURE(GetBooleani_v, isCallValid, context, target, index, data);
801 }
802 }
803
GetFragDataLocation(GLuint program,const GLchar * name)804 GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name)
805 {
806 Context *context = GetValidGlobalContext();
807 EVENT("glGetFragDataLocation",
808 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
809 program, (uintptr_t)name);
810
811 GLint returnValue;
812 if (context)
813 {
814 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
815 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
816 bool isCallValid = (context->skipValidation() ||
817 ValidateGetFragDataLocation(context, programPacked, name));
818 if (isCallValid)
819 {
820 returnValue = context->getFragDataLocation(programPacked, name);
821 }
822 else
823 {
824 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataLocation, GLint>();
825 }
826 ANGLE_CAPTURE(GetFragDataLocation, isCallValid, context, programPacked, name, returnValue);
827 }
828 else
829 {
830 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataLocation, GLint>();
831 }
832 return returnValue;
833 }
834
GetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint * params)835 void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target,
836 GLenum attachment,
837 GLenum pname,
838 GLint *params)
839 {
840 Context *context = GetValidGlobalContext();
841 EVENT("glGetFramebufferAttachmentParameteriv",
842 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLint "
843 "*params = 0x%016" PRIxPTR "",
844 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
845 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
846 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
847 (uintptr_t)params);
848
849 if (context)
850 {
851 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
852 bool isCallValid =
853 (context->skipValidation() || ValidateGetFramebufferAttachmentParameteriv(
854 context, target, attachment, pname, params));
855 if (isCallValid)
856 {
857 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
858 }
859 ANGLE_CAPTURE(GetFramebufferAttachmentParameteriv, isCallValid, context, target, attachment,
860 pname, params);
861 }
862 }
863
GetIntegeri_v(GLenum target,GLuint index,GLint * data)864 void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint *data)
865 {
866 Context *context = GetValidGlobalContext();
867 EVENT("glGetIntegeri_v",
868 "context = %d, GLenum target = %s, GLuint index = %u, GLint *data = 0x%016" PRIxPTR "",
869 CID(context), GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
870
871 if (context)
872 {
873 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
874 bool isCallValid =
875 (context->skipValidation() || ValidateGetIntegeri_v(context, target, index, data));
876 if (isCallValid)
877 {
878 context->getIntegeri_v(target, index, data);
879 }
880 ANGLE_CAPTURE(GetIntegeri_v, isCallValid, context, target, index, data);
881 }
882 }
883
GetRenderbufferParameteriv(GLenum target,GLenum pname,GLint * params)884 void GL_APIENTRY GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
885 {
886 Context *context = GetValidGlobalContext();
887 EVENT("glGetRenderbufferParameteriv",
888 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
889 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
890 GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params);
891
892 if (context)
893 {
894 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
895 bool isCallValid = (context->skipValidation() ||
896 ValidateGetRenderbufferParameteriv(context, target, pname, params));
897 if (isCallValid)
898 {
899 context->getRenderbufferParameteriv(target, pname, params);
900 }
901 ANGLE_CAPTURE(GetRenderbufferParameteriv, isCallValid, context, target, pname, params);
902 }
903 }
904
GetStringi(GLenum name,GLuint index)905 const GLubyte *GL_APIENTRY GetStringi(GLenum name, GLuint index)
906 {
907 Context *context = GetValidGlobalContext();
908 EVENT("glGetStringi", "context = %d, GLenum name = %s, GLuint index = %u", CID(context),
909 GLenumToString(GLenumGroup::StringName, name), index);
910
911 const GLubyte *returnValue;
912 if (context)
913 {
914 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
915 bool isCallValid = (context->skipValidation() || ValidateGetStringi(context, name, index));
916 if (isCallValid)
917 {
918 returnValue = context->getStringi(name, index);
919 }
920 else
921 {
922 returnValue = GetDefaultReturnValue<EntryPoint::GetStringi, const GLubyte *>();
923 }
924 ANGLE_CAPTURE(GetStringi, isCallValid, context, name, index, returnValue);
925 }
926 else
927 {
928 returnValue = GetDefaultReturnValue<EntryPoint::GetStringi, const GLubyte *>();
929 }
930 return returnValue;
931 }
932
GetTexParameterIiv(GLenum target,GLenum pname,GLint * params)933 void GL_APIENTRY GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
934 {
935 Context *context = GetValidGlobalContext();
936 EVENT("glGetTexParameterIiv",
937 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
938 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
939 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
940
941 if (context)
942 {
943 TextureType targetPacked = FromGL<TextureType>(target);
944 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
945 bool isCallValid = (context->skipValidation() ||
946 ValidateGetTexParameterIiv(context, targetPacked, pname, params));
947 if (isCallValid)
948 {
949 context->getTexParameterIiv(targetPacked, pname, params);
950 }
951 ANGLE_CAPTURE(GetTexParameterIiv, isCallValid, context, targetPacked, pname, params);
952 }
953 }
954
GetTexParameterIuiv(GLenum target,GLenum pname,GLuint * params)955 void GL_APIENTRY GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
956 {
957 Context *context = GetValidGlobalContext();
958 EVENT("glGetTexParameterIuiv",
959 "context = %d, GLenum target = %s, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
960 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
961 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
962
963 if (context)
964 {
965 TextureType targetPacked = FromGL<TextureType>(target);
966 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
967 bool isCallValid = (context->skipValidation() ||
968 ValidateGetTexParameterIuiv(context, targetPacked, pname, params));
969 if (isCallValid)
970 {
971 context->getTexParameterIuiv(targetPacked, pname, params);
972 }
973 ANGLE_CAPTURE(GetTexParameterIuiv, isCallValid, context, targetPacked, pname, params);
974 }
975 }
976
GetTransformFeedbackVarying(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLsizei * size,GLenum * type,GLchar * name)977 void GL_APIENTRY GetTransformFeedbackVarying(GLuint program,
978 GLuint index,
979 GLsizei bufSize,
980 GLsizei *length,
981 GLsizei *size,
982 GLenum *type,
983 GLchar *name)
984 {
985 Context *context = GetValidGlobalContext();
986 EVENT("glGetTransformFeedbackVarying",
987 "context = %d, GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei "
988 "*length = 0x%016" PRIxPTR ", GLsizei *size = 0x%016" PRIxPTR
989 ", GLenum *type = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
990 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
991 (uintptr_t)type, (uintptr_t)name);
992
993 if (context)
994 {
995 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
996 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
997 bool isCallValid = (context->skipValidation() ||
998 ValidateGetTransformFeedbackVarying(context, programPacked, index,
999 bufSize, length, size, type, name));
1000 if (isCallValid)
1001 {
1002 context->getTransformFeedbackVarying(programPacked, index, bufSize, length, size, type,
1003 name);
1004 }
1005 ANGLE_CAPTURE(GetTransformFeedbackVarying, isCallValid, context, programPacked, index,
1006 bufSize, length, size, type, name);
1007 }
1008 }
1009
GetUniformuiv(GLuint program,GLint location,GLuint * params)1010 void GL_APIENTRY GetUniformuiv(GLuint program, GLint location, GLuint *params)
1011 {
1012 Context *context = GetValidGlobalContext();
1013 EVENT("glGetUniformuiv",
1014 "context = %d, GLuint program = %u, GLint location = %d, GLuint *params = 0x%016" PRIxPTR
1015 "",
1016 CID(context), program, location, (uintptr_t)params);
1017
1018 if (context)
1019 {
1020 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1021 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1022 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1023 bool isCallValid = (context->skipValidation() ||
1024 ValidateGetUniformuiv(context, programPacked, locationPacked, params));
1025 if (isCallValid)
1026 {
1027 context->getUniformuiv(programPacked, locationPacked, params);
1028 }
1029 ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, locationPacked, params);
1030 }
1031 }
1032
GetVertexAttribIiv(GLuint index,GLenum pname,GLint * params)1033 void GL_APIENTRY GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
1034 {
1035 Context *context = GetValidGlobalContext();
1036 EVENT("glGetVertexAttribIiv",
1037 "context = %d, GLuint index = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
1038 CID(context), index, GLenumToString(GLenumGroup::VertexAttribEnum, pname),
1039 (uintptr_t)params);
1040
1041 if (context)
1042 {
1043 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1044 bool isCallValid = (context->skipValidation() ||
1045 ValidateGetVertexAttribIiv(context, index, pname, params));
1046 if (isCallValid)
1047 {
1048 context->getVertexAttribIiv(index, pname, params);
1049 }
1050 ANGLE_CAPTURE(GetVertexAttribIiv, isCallValid, context, index, pname, params);
1051 }
1052 }
1053
GetVertexAttribIuiv(GLuint index,GLenum pname,GLuint * params)1054 void GL_APIENTRY GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
1055 {
1056 Context *context = GetValidGlobalContext();
1057 EVENT("glGetVertexAttribIuiv",
1058 "context = %d, GLuint index = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
1059 CID(context), index, GLenumToString(GLenumGroup::VertexAttribEnum, pname),
1060 (uintptr_t)params);
1061
1062 if (context)
1063 {
1064 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1065 bool isCallValid = (context->skipValidation() ||
1066 ValidateGetVertexAttribIuiv(context, index, pname, params));
1067 if (isCallValid)
1068 {
1069 context->getVertexAttribIuiv(index, pname, params);
1070 }
1071 ANGLE_CAPTURE(GetVertexAttribIuiv, isCallValid, context, index, pname, params);
1072 }
1073 }
1074
IsEnabledi(GLenum target,GLuint index)1075 GLboolean GL_APIENTRY IsEnabledi(GLenum target, GLuint index)
1076 {
1077 Context *context = GetValidGlobalContext();
1078 EVENT("glIsEnabledi", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
1079 GLenumToString(GLenumGroup::EnableCap, target), index);
1080
1081 GLboolean returnValue;
1082 if (context)
1083 {
1084 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1085 bool isCallValid =
1086 (context->skipValidation() || ValidateIsEnabledi(context, target, index));
1087 if (isCallValid)
1088 {
1089 returnValue = context->isEnabledi(target, index);
1090 }
1091 else
1092 {
1093 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabledi, GLboolean>();
1094 }
1095 ANGLE_CAPTURE(IsEnabledi, isCallValid, context, target, index, returnValue);
1096 }
1097 else
1098 {
1099 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabledi, GLboolean>();
1100 }
1101 return returnValue;
1102 }
1103
IsFramebuffer(GLuint framebuffer)1104 GLboolean GL_APIENTRY IsFramebuffer(GLuint framebuffer)
1105 {
1106 Context *context = GetValidGlobalContext();
1107 EVENT("glIsFramebuffer", "context = %d, GLuint framebuffer = %u", CID(context), framebuffer);
1108
1109 GLboolean returnValue;
1110 if (context)
1111 {
1112 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
1113 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1114 bool isCallValid =
1115 (context->skipValidation() || ValidateIsFramebuffer(context, framebufferPacked));
1116 if (isCallValid)
1117 {
1118 returnValue = context->isFramebuffer(framebufferPacked);
1119 }
1120 else
1121 {
1122 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebuffer, GLboolean>();
1123 }
1124 ANGLE_CAPTURE(IsFramebuffer, isCallValid, context, framebufferPacked, returnValue);
1125 }
1126 else
1127 {
1128 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebuffer, GLboolean>();
1129 }
1130 return returnValue;
1131 }
1132
IsRenderbuffer(GLuint renderbuffer)1133 GLboolean GL_APIENTRY IsRenderbuffer(GLuint renderbuffer)
1134 {
1135 Context *context = GetValidGlobalContext();
1136 EVENT("glIsRenderbuffer", "context = %d, GLuint renderbuffer = %u", CID(context), renderbuffer);
1137
1138 GLboolean returnValue;
1139 if (context)
1140 {
1141 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
1142 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1143 bool isCallValid =
1144 (context->skipValidation() || ValidateIsRenderbuffer(context, renderbufferPacked));
1145 if (isCallValid)
1146 {
1147 returnValue = context->isRenderbuffer(renderbufferPacked);
1148 }
1149 else
1150 {
1151 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbuffer, GLboolean>();
1152 }
1153 ANGLE_CAPTURE(IsRenderbuffer, isCallValid, context, renderbufferPacked, returnValue);
1154 }
1155 else
1156 {
1157 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbuffer, GLboolean>();
1158 }
1159 return returnValue;
1160 }
1161
IsVertexArray(GLuint array)1162 GLboolean GL_APIENTRY IsVertexArray(GLuint array)
1163 {
1164 Context *context = GetValidGlobalContext();
1165 EVENT("glIsVertexArray", "context = %d, GLuint array = %u", CID(context), array);
1166
1167 GLboolean returnValue;
1168 if (context)
1169 {
1170 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
1171 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1172 bool isCallValid =
1173 (context->skipValidation() || ValidateIsVertexArray(context, arrayPacked));
1174 if (isCallValid)
1175 {
1176 returnValue = context->isVertexArray(arrayPacked);
1177 }
1178 else
1179 {
1180 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArray, GLboolean>();
1181 }
1182 ANGLE_CAPTURE(IsVertexArray, isCallValid, context, arrayPacked, returnValue);
1183 }
1184 else
1185 {
1186 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArray, GLboolean>();
1187 }
1188 return returnValue;
1189 }
1190
MapBufferRange(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)1191 void *GL_APIENTRY MapBufferRange(GLenum target,
1192 GLintptr offset,
1193 GLsizeiptr length,
1194 GLbitfield access)
1195 {
1196 Context *context = GetValidGlobalContext();
1197 EVENT("glMapBufferRange",
1198 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu, "
1199 "GLbitfield access = %s",
1200 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
1201 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
1202 GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
1203
1204 void *returnValue;
1205 if (context)
1206 {
1207 BufferBinding targetPacked = FromGL<BufferBinding>(target);
1208 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1209 bool isCallValid = (context->skipValidation() ||
1210 ValidateMapBufferRange(context, targetPacked, offset, length, access));
1211 if (isCallValid)
1212 {
1213 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
1214 }
1215 else
1216 {
1217 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRange, void *>();
1218 }
1219 ANGLE_CAPTURE(MapBufferRange, isCallValid, context, targetPacked, offset, length, access,
1220 returnValue);
1221 }
1222 else
1223 {
1224 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRange, void *>();
1225 }
1226 return returnValue;
1227 }
1228
RenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)1229 void GL_APIENTRY RenderbufferStorage(GLenum target,
1230 GLenum internalformat,
1231 GLsizei width,
1232 GLsizei height)
1233 {
1234 Context *context = GetValidGlobalContext();
1235 EVENT("glRenderbufferStorage",
1236 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLsizei width = %d, "
1237 "GLsizei height = %d",
1238 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
1239 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
1240
1241 if (context)
1242 {
1243 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1244 bool isCallValid =
1245 (context->skipValidation() ||
1246 ValidateRenderbufferStorage(context, target, internalformat, width, height));
1247 if (isCallValid)
1248 {
1249 context->renderbufferStorage(target, internalformat, width, height);
1250 }
1251 ANGLE_CAPTURE(RenderbufferStorage, isCallValid, context, target, internalformat, width,
1252 height);
1253 }
1254 }
1255
RenderbufferStorageMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)1256 void GL_APIENTRY RenderbufferStorageMultisample(GLenum target,
1257 GLsizei samples,
1258 GLenum internalformat,
1259 GLsizei width,
1260 GLsizei height)
1261 {
1262 Context *context = GetValidGlobalContext();
1263 EVENT("glRenderbufferStorageMultisample",
1264 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
1265 "GLsizei width = %d, GLsizei height = %d",
1266 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
1267 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
1268
1269 if (context)
1270 {
1271 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1272 bool isCallValid = (context->skipValidation() ||
1273 ValidateRenderbufferStorageMultisample(context, target, samples,
1274 internalformat, width, height));
1275 if (isCallValid)
1276 {
1277 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
1278 }
1279 ANGLE_CAPTURE(RenderbufferStorageMultisample, isCallValid, context, target, samples,
1280 internalformat, width, height);
1281 }
1282 }
1283
TexParameterIiv(GLenum target,GLenum pname,const GLint * params)1284 void GL_APIENTRY TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
1285 {
1286 Context *context = GetValidGlobalContext();
1287 EVENT(
1288 "glTexParameterIiv",
1289 "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
1290 "",
1291 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
1292 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
1293
1294 if (context)
1295 {
1296 TextureType targetPacked = FromGL<TextureType>(target);
1297 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1298 bool isCallValid = (context->skipValidation() ||
1299 ValidateTexParameterIiv(context, targetPacked, pname, params));
1300 if (isCallValid)
1301 {
1302 context->texParameterIiv(targetPacked, pname, params);
1303 }
1304 ANGLE_CAPTURE(TexParameterIiv, isCallValid, context, targetPacked, pname, params);
1305 }
1306 }
1307
TexParameterIuiv(GLenum target,GLenum pname,const GLuint * params)1308 void GL_APIENTRY TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
1309 {
1310 Context *context = GetValidGlobalContext();
1311 EVENT(
1312 "glTexParameterIuiv",
1313 "context = %d, GLenum target = %s, GLenum pname = %s, const GLuint *params = 0x%016" PRIxPTR
1314 "",
1315 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
1316 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
1317
1318 if (context)
1319 {
1320 TextureType targetPacked = FromGL<TextureType>(target);
1321 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1322 bool isCallValid = (context->skipValidation() ||
1323 ValidateTexParameterIuiv(context, targetPacked, pname, params));
1324 if (isCallValid)
1325 {
1326 context->texParameterIuiv(targetPacked, pname, params);
1327 }
1328 ANGLE_CAPTURE(TexParameterIuiv, isCallValid, context, targetPacked, pname, params);
1329 }
1330 }
1331
TransformFeedbackVaryings(GLuint program,GLsizei count,const GLchar * const * varyings,GLenum bufferMode)1332 void GL_APIENTRY TransformFeedbackVaryings(GLuint program,
1333 GLsizei count,
1334 const GLchar *const *varyings,
1335 GLenum bufferMode)
1336 {
1337 Context *context = GetValidGlobalContext();
1338 EVENT("glTransformFeedbackVaryings",
1339 "context = %d, GLuint program = %u, GLsizei count = %d, const GLchar *const*varyings = "
1340 "0x%016" PRIxPTR ", GLenum bufferMode = %s",
1341 CID(context), program, count, (uintptr_t)varyings,
1342 GLenumToString(GLenumGroup::DefaultGroup, bufferMode));
1343
1344 if (context)
1345 {
1346 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1347 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1348 bool isCallValid =
1349 (context->skipValidation() || ValidateTransformFeedbackVaryings(
1350 context, programPacked, count, varyings, bufferMode));
1351 if (isCallValid)
1352 {
1353 context->transformFeedbackVaryings(programPacked, count, varyings, bufferMode);
1354 }
1355 ANGLE_CAPTURE(TransformFeedbackVaryings, isCallValid, context, programPacked, count,
1356 varyings, bufferMode);
1357 }
1358 }
1359
Uniform1ui(GLint location,GLuint v0)1360 void GL_APIENTRY Uniform1ui(GLint location, GLuint v0)
1361 {
1362 Context *context = GetValidGlobalContext();
1363 EVENT("glUniform1ui", "context = %d, GLint location = %d, GLuint v0 = %u", CID(context),
1364 location, v0);
1365
1366 if (context)
1367 {
1368 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1369 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1370 bool isCallValid =
1371 (context->skipValidation() || ValidateUniform1ui(context, locationPacked, v0));
1372 if (isCallValid)
1373 {
1374 context->uniform1ui(locationPacked, v0);
1375 }
1376 ANGLE_CAPTURE(Uniform1ui, isCallValid, context, locationPacked, v0);
1377 }
1378 }
1379
Uniform1uiv(GLint location,GLsizei count,const GLuint * value)1380 void GL_APIENTRY Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
1381 {
1382 Context *context = GetValidGlobalContext();
1383 EVENT("glUniform1uiv",
1384 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
1385 "0x%016" PRIxPTR "",
1386 CID(context), location, count, (uintptr_t)value);
1387
1388 if (context)
1389 {
1390 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1391 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1392 bool isCallValid = (context->skipValidation() ||
1393 ValidateUniform1uiv(context, locationPacked, count, value));
1394 if (isCallValid)
1395 {
1396 context->uniform1uiv(locationPacked, count, value);
1397 }
1398 ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, locationPacked, count, value);
1399 }
1400 }
1401
Uniform2ui(GLint location,GLuint v0,GLuint v1)1402 void GL_APIENTRY Uniform2ui(GLint location, GLuint v0, GLuint v1)
1403 {
1404 Context *context = GetValidGlobalContext();
1405 EVENT("glUniform2ui", "context = %d, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u",
1406 CID(context), location, v0, v1);
1407
1408 if (context)
1409 {
1410 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1411 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1412 bool isCallValid =
1413 (context->skipValidation() || ValidateUniform2ui(context, locationPacked, v0, v1));
1414 if (isCallValid)
1415 {
1416 context->uniform2ui(locationPacked, v0, v1);
1417 }
1418 ANGLE_CAPTURE(Uniform2ui, isCallValid, context, locationPacked, v0, v1);
1419 }
1420 }
1421
Uniform2uiv(GLint location,GLsizei count,const GLuint * value)1422 void GL_APIENTRY Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
1423 {
1424 Context *context = GetValidGlobalContext();
1425 EVENT("glUniform2uiv",
1426 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
1427 "0x%016" PRIxPTR "",
1428 CID(context), location, count, (uintptr_t)value);
1429
1430 if (context)
1431 {
1432 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1433 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1434 bool isCallValid = (context->skipValidation() ||
1435 ValidateUniform2uiv(context, locationPacked, count, value));
1436 if (isCallValid)
1437 {
1438 context->uniform2uiv(locationPacked, count, value);
1439 }
1440 ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, locationPacked, count, value);
1441 }
1442 }
1443
Uniform3ui(GLint location,GLuint v0,GLuint v1,GLuint v2)1444 void GL_APIENTRY Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1445 {
1446 Context *context = GetValidGlobalContext();
1447 EVENT("glUniform3ui",
1448 "context = %d, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u",
1449 CID(context), location, v0, v1, v2);
1450
1451 if (context)
1452 {
1453 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1454 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1455 bool isCallValid =
1456 (context->skipValidation() || ValidateUniform3ui(context, locationPacked, v0, v1, v2));
1457 if (isCallValid)
1458 {
1459 context->uniform3ui(locationPacked, v0, v1, v2);
1460 }
1461 ANGLE_CAPTURE(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2);
1462 }
1463 }
1464
Uniform3uiv(GLint location,GLsizei count,const GLuint * value)1465 void GL_APIENTRY Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
1466 {
1467 Context *context = GetValidGlobalContext();
1468 EVENT("glUniform3uiv",
1469 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
1470 "0x%016" PRIxPTR "",
1471 CID(context), location, count, (uintptr_t)value);
1472
1473 if (context)
1474 {
1475 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1476 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1477 bool isCallValid = (context->skipValidation() ||
1478 ValidateUniform3uiv(context, locationPacked, count, value));
1479 if (isCallValid)
1480 {
1481 context->uniform3uiv(locationPacked, count, value);
1482 }
1483 ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, locationPacked, count, value);
1484 }
1485 }
1486
Uniform4ui(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)1487 void GL_APIENTRY Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1488 {
1489 Context *context = GetValidGlobalContext();
1490 EVENT("glUniform4ui",
1491 "context = %d, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u, "
1492 "GLuint v3 = %u",
1493 CID(context), location, v0, v1, v2, v3);
1494
1495 if (context)
1496 {
1497 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1498 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1499 bool isCallValid = (context->skipValidation() ||
1500 ValidateUniform4ui(context, locationPacked, v0, v1, v2, v3));
1501 if (isCallValid)
1502 {
1503 context->uniform4ui(locationPacked, v0, v1, v2, v3);
1504 }
1505 ANGLE_CAPTURE(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3);
1506 }
1507 }
1508
Uniform4uiv(GLint location,GLsizei count,const GLuint * value)1509 void GL_APIENTRY Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
1510 {
1511 Context *context = GetValidGlobalContext();
1512 EVENT("glUniform4uiv",
1513 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
1514 "0x%016" PRIxPTR "",
1515 CID(context), location, count, (uintptr_t)value);
1516
1517 if (context)
1518 {
1519 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1520 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1521 bool isCallValid = (context->skipValidation() ||
1522 ValidateUniform4uiv(context, locationPacked, count, value));
1523 if (isCallValid)
1524 {
1525 context->uniform4uiv(locationPacked, count, value);
1526 }
1527 ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, locationPacked, count, value);
1528 }
1529 }
1530
VertexAttribI1i(GLuint index,GLint x)1531 void GL_APIENTRY VertexAttribI1i(GLuint index, GLint x)
1532 {
1533 Context *context = GetValidGlobalContext();
1534 EVENT("glVertexAttribI1i", "context = %d, GLuint index = %u, GLint x = %d", CID(context), index,
1535 x);
1536
1537 if (context)
1538 {
1539 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1540 bool isCallValid =
1541 (context->skipValidation() || ValidateVertexAttribI1i(context, index, x));
1542 if (isCallValid)
1543 {
1544 context->vertexAttribI1i(index, x);
1545 }
1546 ANGLE_CAPTURE(VertexAttribI1i, isCallValid, context, index, x);
1547 }
1548 }
1549
VertexAttribI1iv(GLuint index,const GLint * v)1550 void GL_APIENTRY VertexAttribI1iv(GLuint index, const GLint *v)
1551 {
1552 Context *context = GetValidGlobalContext();
1553 EVENT("glVertexAttribI1iv",
1554 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
1555 index, (uintptr_t)v);
1556
1557 if (context)
1558 {
1559 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1560 bool isCallValid =
1561 (context->skipValidation() || ValidateVertexAttribI1iv(context, index, v));
1562 if (isCallValid)
1563 {
1564 context->vertexAttribI1iv(index, v);
1565 }
1566 ANGLE_CAPTURE(VertexAttribI1iv, isCallValid, context, index, v);
1567 }
1568 }
1569
VertexAttribI1ui(GLuint index,GLuint x)1570 void GL_APIENTRY VertexAttribI1ui(GLuint index, GLuint x)
1571 {
1572 Context *context = GetValidGlobalContext();
1573 EVENT("glVertexAttribI1ui", "context = %d, GLuint index = %u, GLuint x = %u", CID(context),
1574 index, x);
1575
1576 if (context)
1577 {
1578 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1579 bool isCallValid =
1580 (context->skipValidation() || ValidateVertexAttribI1ui(context, index, x));
1581 if (isCallValid)
1582 {
1583 context->vertexAttribI1ui(index, x);
1584 }
1585 ANGLE_CAPTURE(VertexAttribI1ui, isCallValid, context, index, x);
1586 }
1587 }
1588
VertexAttribI1uiv(GLuint index,const GLuint * v)1589 void GL_APIENTRY VertexAttribI1uiv(GLuint index, const GLuint *v)
1590 {
1591 Context *context = GetValidGlobalContext();
1592 EVENT("glVertexAttribI1uiv",
1593 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
1594 index, (uintptr_t)v);
1595
1596 if (context)
1597 {
1598 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1599 bool isCallValid =
1600 (context->skipValidation() || ValidateVertexAttribI1uiv(context, index, v));
1601 if (isCallValid)
1602 {
1603 context->vertexAttribI1uiv(index, v);
1604 }
1605 ANGLE_CAPTURE(VertexAttribI1uiv, isCallValid, context, index, v);
1606 }
1607 }
1608
VertexAttribI2i(GLuint index,GLint x,GLint y)1609 void GL_APIENTRY VertexAttribI2i(GLuint index, GLint x, GLint y)
1610 {
1611 Context *context = GetValidGlobalContext();
1612 EVENT("glVertexAttribI2i", "context = %d, GLuint index = %u, GLint x = %d, GLint y = %d",
1613 CID(context), index, x, y);
1614
1615 if (context)
1616 {
1617 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1618 bool isCallValid =
1619 (context->skipValidation() || ValidateVertexAttribI2i(context, index, x, y));
1620 if (isCallValid)
1621 {
1622 context->vertexAttribI2i(index, x, y);
1623 }
1624 ANGLE_CAPTURE(VertexAttribI2i, isCallValid, context, index, x, y);
1625 }
1626 }
1627
VertexAttribI2iv(GLuint index,const GLint * v)1628 void GL_APIENTRY VertexAttribI2iv(GLuint index, const GLint *v)
1629 {
1630 Context *context = GetValidGlobalContext();
1631 EVENT("glVertexAttribI2iv",
1632 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
1633 index, (uintptr_t)v);
1634
1635 if (context)
1636 {
1637 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1638 bool isCallValid =
1639 (context->skipValidation() || ValidateVertexAttribI2iv(context, index, v));
1640 if (isCallValid)
1641 {
1642 context->vertexAttribI2iv(index, v);
1643 }
1644 ANGLE_CAPTURE(VertexAttribI2iv, isCallValid, context, index, v);
1645 }
1646 }
1647
VertexAttribI2ui(GLuint index,GLuint x,GLuint y)1648 void GL_APIENTRY VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
1649 {
1650 Context *context = GetValidGlobalContext();
1651 EVENT("glVertexAttribI2ui", "context = %d, GLuint index = %u, GLuint x = %u, GLuint y = %u",
1652 CID(context), index, x, y);
1653
1654 if (context)
1655 {
1656 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1657 bool isCallValid =
1658 (context->skipValidation() || ValidateVertexAttribI2ui(context, index, x, y));
1659 if (isCallValid)
1660 {
1661 context->vertexAttribI2ui(index, x, y);
1662 }
1663 ANGLE_CAPTURE(VertexAttribI2ui, isCallValid, context, index, x, y);
1664 }
1665 }
1666
VertexAttribI2uiv(GLuint index,const GLuint * v)1667 void GL_APIENTRY VertexAttribI2uiv(GLuint index, const GLuint *v)
1668 {
1669 Context *context = GetValidGlobalContext();
1670 EVENT("glVertexAttribI2uiv",
1671 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
1672 index, (uintptr_t)v);
1673
1674 if (context)
1675 {
1676 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1677 bool isCallValid =
1678 (context->skipValidation() || ValidateVertexAttribI2uiv(context, index, v));
1679 if (isCallValid)
1680 {
1681 context->vertexAttribI2uiv(index, v);
1682 }
1683 ANGLE_CAPTURE(VertexAttribI2uiv, isCallValid, context, index, v);
1684 }
1685 }
1686
VertexAttribI3i(GLuint index,GLint x,GLint y,GLint z)1687 void GL_APIENTRY VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
1688 {
1689 Context *context = GetValidGlobalContext();
1690 EVENT("glVertexAttribI3i",
1691 "context = %d, GLuint index = %u, GLint x = %d, GLint y = %d, GLint z = %d", CID(context),
1692 index, x, y, z);
1693
1694 if (context)
1695 {
1696 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1697 bool isCallValid =
1698 (context->skipValidation() || ValidateVertexAttribI3i(context, index, x, y, z));
1699 if (isCallValid)
1700 {
1701 context->vertexAttribI3i(index, x, y, z);
1702 }
1703 ANGLE_CAPTURE(VertexAttribI3i, isCallValid, context, index, x, y, z);
1704 }
1705 }
1706
VertexAttribI3iv(GLuint index,const GLint * v)1707 void GL_APIENTRY VertexAttribI3iv(GLuint index, const GLint *v)
1708 {
1709 Context *context = GetValidGlobalContext();
1710 EVENT("glVertexAttribI3iv",
1711 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
1712 index, (uintptr_t)v);
1713
1714 if (context)
1715 {
1716 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1717 bool isCallValid =
1718 (context->skipValidation() || ValidateVertexAttribI3iv(context, index, v));
1719 if (isCallValid)
1720 {
1721 context->vertexAttribI3iv(index, v);
1722 }
1723 ANGLE_CAPTURE(VertexAttribI3iv, isCallValid, context, index, v);
1724 }
1725 }
1726
VertexAttribI3ui(GLuint index,GLuint x,GLuint y,GLuint z)1727 void GL_APIENTRY VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
1728 {
1729 Context *context = GetValidGlobalContext();
1730 EVENT("glVertexAttribI3ui",
1731 "context = %d, GLuint index = %u, GLuint x = %u, GLuint y = %u, GLuint z = %u",
1732 CID(context), index, x, y, z);
1733
1734 if (context)
1735 {
1736 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1737 bool isCallValid =
1738 (context->skipValidation() || ValidateVertexAttribI3ui(context, index, x, y, z));
1739 if (isCallValid)
1740 {
1741 context->vertexAttribI3ui(index, x, y, z);
1742 }
1743 ANGLE_CAPTURE(VertexAttribI3ui, isCallValid, context, index, x, y, z);
1744 }
1745 }
1746
VertexAttribI3uiv(GLuint index,const GLuint * v)1747 void GL_APIENTRY VertexAttribI3uiv(GLuint index, const GLuint *v)
1748 {
1749 Context *context = GetValidGlobalContext();
1750 EVENT("glVertexAttribI3uiv",
1751 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
1752 index, (uintptr_t)v);
1753
1754 if (context)
1755 {
1756 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1757 bool isCallValid =
1758 (context->skipValidation() || ValidateVertexAttribI3uiv(context, index, v));
1759 if (isCallValid)
1760 {
1761 context->vertexAttribI3uiv(index, v);
1762 }
1763 ANGLE_CAPTURE(VertexAttribI3uiv, isCallValid, context, index, v);
1764 }
1765 }
1766
VertexAttribI4bv(GLuint index,const GLbyte * v)1767 void GL_APIENTRY VertexAttribI4bv(GLuint index, const GLbyte *v)
1768 {
1769 Context *context = GetValidGlobalContext();
1770 EVENT("glVertexAttribI4bv",
1771 "context = %d, GLuint index = %u, const GLbyte *v = 0x%016" PRIxPTR "", CID(context),
1772 index, (uintptr_t)v);
1773
1774 if (context)
1775 {
1776 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1777 bool isCallValid =
1778 (context->skipValidation() || ValidateVertexAttribI4bv(context, index, v));
1779 if (isCallValid)
1780 {
1781 context->vertexAttribI4bv(index, v);
1782 }
1783 ANGLE_CAPTURE(VertexAttribI4bv, isCallValid, context, index, v);
1784 }
1785 }
1786
VertexAttribI4i(GLuint index,GLint x,GLint y,GLint z,GLint w)1787 void GL_APIENTRY VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1788 {
1789 Context *context = GetValidGlobalContext();
1790 EVENT("glVertexAttribI4i",
1791 "context = %d, GLuint index = %u, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d",
1792 CID(context), index, x, y, z, w);
1793
1794 if (context)
1795 {
1796 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1797 bool isCallValid =
1798 (context->skipValidation() || ValidateVertexAttribI4i(context, index, x, y, z, w));
1799 if (isCallValid)
1800 {
1801 context->vertexAttribI4i(index, x, y, z, w);
1802 }
1803 ANGLE_CAPTURE(VertexAttribI4i, isCallValid, context, index, x, y, z, w);
1804 }
1805 }
1806
VertexAttribI4iv(GLuint index,const GLint * v)1807 void GL_APIENTRY VertexAttribI4iv(GLuint index, const GLint *v)
1808 {
1809 Context *context = GetValidGlobalContext();
1810 EVENT("glVertexAttribI4iv",
1811 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
1812 index, (uintptr_t)v);
1813
1814 if (context)
1815 {
1816 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1817 bool isCallValid =
1818 (context->skipValidation() || ValidateVertexAttribI4iv(context, index, v));
1819 if (isCallValid)
1820 {
1821 context->vertexAttribI4iv(index, v);
1822 }
1823 ANGLE_CAPTURE(VertexAttribI4iv, isCallValid, context, index, v);
1824 }
1825 }
1826
VertexAttribI4sv(GLuint index,const GLshort * v)1827 void GL_APIENTRY VertexAttribI4sv(GLuint index, const GLshort *v)
1828 {
1829 Context *context = GetValidGlobalContext();
1830 EVENT("glVertexAttribI4sv",
1831 "context = %d, GLuint index = %u, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
1832 index, (uintptr_t)v);
1833
1834 if (context)
1835 {
1836 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1837 bool isCallValid =
1838 (context->skipValidation() || ValidateVertexAttribI4sv(context, index, v));
1839 if (isCallValid)
1840 {
1841 context->vertexAttribI4sv(index, v);
1842 }
1843 ANGLE_CAPTURE(VertexAttribI4sv, isCallValid, context, index, v);
1844 }
1845 }
1846
VertexAttribI4ubv(GLuint index,const GLubyte * v)1847 void GL_APIENTRY VertexAttribI4ubv(GLuint index, const GLubyte *v)
1848 {
1849 Context *context = GetValidGlobalContext();
1850 EVENT("glVertexAttribI4ubv",
1851 "context = %d, GLuint index = %u, const GLubyte *v = 0x%016" PRIxPTR "", CID(context),
1852 index, (uintptr_t)v);
1853
1854 if (context)
1855 {
1856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1857 bool isCallValid =
1858 (context->skipValidation() || ValidateVertexAttribI4ubv(context, index, v));
1859 if (isCallValid)
1860 {
1861 context->vertexAttribI4ubv(index, v);
1862 }
1863 ANGLE_CAPTURE(VertexAttribI4ubv, isCallValid, context, index, v);
1864 }
1865 }
1866
VertexAttribI4ui(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)1867 void GL_APIENTRY VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
1868 {
1869 Context *context = GetValidGlobalContext();
1870 EVENT("glVertexAttribI4ui",
1871 "context = %d, GLuint index = %u, GLuint x = %u, GLuint y = %u, GLuint z = %u, GLuint w "
1872 "= %u",
1873 CID(context), index, x, y, z, w);
1874
1875 if (context)
1876 {
1877 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1878 bool isCallValid =
1879 (context->skipValidation() || ValidateVertexAttribI4ui(context, index, x, y, z, w));
1880 if (isCallValid)
1881 {
1882 context->vertexAttribI4ui(index, x, y, z, w);
1883 }
1884 ANGLE_CAPTURE(VertexAttribI4ui, isCallValid, context, index, x, y, z, w);
1885 }
1886 }
1887
VertexAttribI4uiv(GLuint index,const GLuint * v)1888 void GL_APIENTRY VertexAttribI4uiv(GLuint index, const GLuint *v)
1889 {
1890 Context *context = GetValidGlobalContext();
1891 EVENT("glVertexAttribI4uiv",
1892 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
1893 index, (uintptr_t)v);
1894
1895 if (context)
1896 {
1897 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1898 bool isCallValid =
1899 (context->skipValidation() || ValidateVertexAttribI4uiv(context, index, v));
1900 if (isCallValid)
1901 {
1902 context->vertexAttribI4uiv(index, v);
1903 }
1904 ANGLE_CAPTURE(VertexAttribI4uiv, isCallValid, context, index, v);
1905 }
1906 }
1907
VertexAttribI4usv(GLuint index,const GLushort * v)1908 void GL_APIENTRY VertexAttribI4usv(GLuint index, const GLushort *v)
1909 {
1910 Context *context = GetValidGlobalContext();
1911 EVENT("glVertexAttribI4usv",
1912 "context = %d, GLuint index = %u, const GLushort *v = 0x%016" PRIxPTR "", CID(context),
1913 index, (uintptr_t)v);
1914
1915 if (context)
1916 {
1917 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1918 bool isCallValid =
1919 (context->skipValidation() || ValidateVertexAttribI4usv(context, index, v));
1920 if (isCallValid)
1921 {
1922 context->vertexAttribI4usv(index, v);
1923 }
1924 ANGLE_CAPTURE(VertexAttribI4usv, isCallValid, context, index, v);
1925 }
1926 }
1927
1928 void GL_APIENTRY
VertexAttribIPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const void * pointer)1929 VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
1930 {
1931 Context *context = GetValidGlobalContext();
1932 EVENT("glVertexAttribIPointer",
1933 "context = %d, GLuint index = %u, GLint size = %d, GLenum type = %s, GLsizei stride = "
1934 "%d, const void *pointer = 0x%016" PRIxPTR "",
1935 CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
1936 stride, (uintptr_t)pointer);
1937
1938 if (context)
1939 {
1940 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
1941 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1942 bool isCallValid =
1943 (context->skipValidation() ||
1944 ValidateVertexAttribIPointer(context, index, size, typePacked, stride, pointer));
1945 if (isCallValid)
1946 {
1947 context->vertexAttribIPointer(index, size, typePacked, stride, pointer);
1948 }
1949 ANGLE_CAPTURE(VertexAttribIPointer, isCallValid, context, index, size, typePacked, stride,
1950 pointer);
1951 }
1952 }
1953 } // namespace gl
1954