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