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_gles_3_0_autogen.cpp:
9 // Defines the GLES 3.0 entry points.
10
11 #include "libGLESv2/entry_points_gles_3_0_autogen.h"
12
13 #include "common/entry_points_enum_autogen.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/Context.inl.h"
16 #include "libANGLE/capture/capture_gles_3_0_autogen.h"
17 #include "libANGLE/capture/gl_enum_utils.h"
18 #include "libANGLE/entry_points_utils.h"
19 #include "libANGLE/validationES3.h"
20 #include "libGLESv2/global_state.h"
21
22 using namespace gl;
23
24 extern "C" {
GL_BeginQuery(GLenum target,GLuint id)25 void GL_APIENTRY GL_BeginQuery(GLenum target, GLuint id)
26 {
27 Context *context = GetValidGlobalContext();
28 EVENT(context, GLBeginQuery, "context = %d, target = %s, id = %u", CID(context),
29 GLenumToString(GLenumGroup::QueryTarget, target), id);
30
31 if (context)
32 {
33 QueryType targetPacked = PackParam<QueryType>(target);
34 QueryID idPacked = PackParam<QueryID>(id);
35 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
36 bool isCallValid =
37 (context->skipValidation() ||
38 ValidateBeginQuery(context, angle::EntryPoint::GLBeginQuery, targetPacked, idPacked));
39 if (isCallValid)
40 {
41 context->beginQuery(targetPacked, idPacked);
42 }
43 ANGLE_CAPTURE(BeginQuery, isCallValid, context, targetPacked, idPacked);
44 }
45 else
46 {
47 GenerateContextLostErrorOnCurrentGlobalContext();
48 }
49 }
50
GL_BeginTransformFeedback(GLenum primitiveMode)51 void GL_APIENTRY GL_BeginTransformFeedback(GLenum primitiveMode)
52 {
53 Context *context = GetValidGlobalContext();
54 EVENT(context, GLBeginTransformFeedback, "context = %d, primitiveMode = %s", CID(context),
55 GLenumToString(GLenumGroup::PrimitiveType, primitiveMode));
56
57 if (context)
58 {
59 PrimitiveMode primitiveModePacked = PackParam<PrimitiveMode>(primitiveMode);
60 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
61 bool isCallValid =
62 (context->skipValidation() ||
63 ValidateBeginTransformFeedback(context, angle::EntryPoint::GLBeginTransformFeedback,
64 primitiveModePacked));
65 if (isCallValid)
66 {
67 context->beginTransformFeedback(primitiveModePacked);
68 }
69 ANGLE_CAPTURE(BeginTransformFeedback, isCallValid, context, primitiveModePacked);
70 }
71 else
72 {
73 GenerateContextLostErrorOnCurrentGlobalContext();
74 }
75 }
76
GL_BindBufferBase(GLenum target,GLuint index,GLuint buffer)77 void GL_APIENTRY GL_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
78 {
79 Context *context = GetValidGlobalContext();
80 EVENT(context, GLBindBufferBase, "context = %d, target = %s, index = %u, buffer = %u",
81 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer);
82
83 if (context)
84 {
85 BufferBinding targetPacked = PackParam<BufferBinding>(target);
86 BufferID bufferPacked = PackParam<BufferID>(buffer);
87 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
88 bool isCallValid = (context->skipValidation() ||
89 ValidateBindBufferBase(context, angle::EntryPoint::GLBindBufferBase,
90 targetPacked, index, bufferPacked));
91 if (isCallValid)
92 {
93 context->bindBufferBase(targetPacked, index, bufferPacked);
94 }
95 ANGLE_CAPTURE(BindBufferBase, isCallValid, context, targetPacked, index, bufferPacked);
96 }
97 else
98 {
99 GenerateContextLostErrorOnCurrentGlobalContext();
100 }
101 }
102
103 void GL_APIENTRY
GL_BindBufferRange(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size)104 GL_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
105 {
106 Context *context = GetValidGlobalContext();
107 EVENT(context, GLBindBufferRange,
108 "context = %d, target = %s, index = %u, buffer = %u, offset = %llu, size = %llu",
109 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer,
110 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
111
112 if (context)
113 {
114 BufferBinding targetPacked = PackParam<BufferBinding>(target);
115 BufferID bufferPacked = PackParam<BufferID>(buffer);
116 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
117 bool isCallValid =
118 (context->skipValidation() ||
119 ValidateBindBufferRange(context, angle::EntryPoint::GLBindBufferRange, targetPacked,
120 index, bufferPacked, offset, size));
121 if (isCallValid)
122 {
123 context->bindBufferRange(targetPacked, index, bufferPacked, offset, size);
124 }
125 ANGLE_CAPTURE(BindBufferRange, isCallValid, context, targetPacked, index, bufferPacked,
126 offset, size);
127 }
128 else
129 {
130 GenerateContextLostErrorOnCurrentGlobalContext();
131 }
132 }
133
GL_BindSampler(GLuint unit,GLuint sampler)134 void GL_APIENTRY GL_BindSampler(GLuint unit, GLuint sampler)
135 {
136 Context *context = GetValidGlobalContext();
137 EVENT(context, GLBindSampler, "context = %d, unit = %u, sampler = %u", CID(context), unit,
138 sampler);
139
140 if (context)
141 {
142 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
143 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
144 bool isCallValid =
145 (context->skipValidation() ||
146 ValidateBindSampler(context, angle::EntryPoint::GLBindSampler, unit, samplerPacked));
147 if (isCallValid)
148 {
149 context->bindSampler(unit, samplerPacked);
150 }
151 ANGLE_CAPTURE(BindSampler, isCallValid, context, unit, samplerPacked);
152 }
153 else
154 {
155 GenerateContextLostErrorOnCurrentGlobalContext();
156 }
157 }
158
GL_BindTransformFeedback(GLenum target,GLuint id)159 void GL_APIENTRY GL_BindTransformFeedback(GLenum target, GLuint id)
160 {
161 Context *context = GetValidGlobalContext();
162 EVENT(context, GLBindTransformFeedback, "context = %d, target = %s, id = %u", CID(context),
163 GLenumToString(GLenumGroup::BindTransformFeedbackTarget, target), id);
164
165 if (context)
166 {
167 TransformFeedbackID idPacked = PackParam<TransformFeedbackID>(id);
168 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
169 bool isCallValid =
170 (context->skipValidation() ||
171 ValidateBindTransformFeedback(context, angle::EntryPoint::GLBindTransformFeedback,
172 target, idPacked));
173 if (isCallValid)
174 {
175 context->bindTransformFeedback(target, idPacked);
176 }
177 ANGLE_CAPTURE(BindTransformFeedback, isCallValid, context, target, idPacked);
178 }
179 else
180 {
181 GenerateContextLostErrorOnCurrentGlobalContext();
182 }
183 }
184
GL_BindVertexArray(GLuint array)185 void GL_APIENTRY GL_BindVertexArray(GLuint array)
186 {
187 Context *context = GetValidGlobalContext();
188 EVENT(context, GLBindVertexArray, "context = %d, array = %u", CID(context), array);
189
190 if (context)
191 {
192 VertexArrayID arrayPacked = PackParam<VertexArrayID>(array);
193 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
194 bool isCallValid =
195 (context->skipValidation() ||
196 ValidateBindVertexArray(context, angle::EntryPoint::GLBindVertexArray, arrayPacked));
197 if (isCallValid)
198 {
199 context->bindVertexArray(arrayPacked);
200 }
201 ANGLE_CAPTURE(BindVertexArray, isCallValid, context, arrayPacked);
202 }
203 else
204 {
205 GenerateContextLostErrorOnCurrentGlobalContext();
206 }
207 }
208
GL_BlitFramebuffer(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)209 void GL_APIENTRY GL_BlitFramebuffer(GLint srcX0,
210 GLint srcY0,
211 GLint srcX1,
212 GLint srcY1,
213 GLint dstX0,
214 GLint dstY0,
215 GLint dstX1,
216 GLint dstY1,
217 GLbitfield mask,
218 GLenum filter)
219 {
220 Context *context = GetValidGlobalContext();
221 EVENT(context, GLBlitFramebuffer,
222 "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
223 "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
224 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
225 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
226 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
227
228 if (context)
229 {
230 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
231 bool isCallValid =
232 (context->skipValidation() ||
233 ValidateBlitFramebuffer(context, angle::EntryPoint::GLBlitFramebuffer, srcX0, srcY0,
234 srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
235 if (isCallValid)
236 {
237 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
238 filter);
239 }
240 ANGLE_CAPTURE(BlitFramebuffer, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
241 dstY0, dstX1, dstY1, mask, filter);
242 }
243 else
244 {
245 GenerateContextLostErrorOnCurrentGlobalContext();
246 }
247 }
248
GL_ClearBufferfi(GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil)249 void GL_APIENTRY GL_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
250 {
251 Context *context = GetValidGlobalContext();
252 EVENT(context, GLClearBufferfi,
253 "context = %d, buffer = %s, drawbuffer = %d, depth = %f, stencil = %d", CID(context),
254 GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, depth, stencil);
255
256 if (context)
257 {
258 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
259 bool isCallValid = (context->skipValidation() ||
260 ValidateClearBufferfi(context, angle::EntryPoint::GLClearBufferfi,
261 buffer, drawbuffer, depth, stencil));
262 if (isCallValid)
263 {
264 context->clearBufferfi(buffer, drawbuffer, depth, stencil);
265 }
266 ANGLE_CAPTURE(ClearBufferfi, isCallValid, context, buffer, drawbuffer, depth, stencil);
267 }
268 else
269 {
270 GenerateContextLostErrorOnCurrentGlobalContext();
271 }
272 }
273
GL_ClearBufferfv(GLenum buffer,GLint drawbuffer,const GLfloat * value)274 void GL_APIENTRY GL_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
275 {
276 Context *context = GetValidGlobalContext();
277 EVENT(context, GLClearBufferfv,
278 "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context),
279 GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
280
281 if (context)
282 {
283 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
284 bool isCallValid = (context->skipValidation() ||
285 ValidateClearBufferfv(context, angle::EntryPoint::GLClearBufferfv,
286 buffer, drawbuffer, value));
287 if (isCallValid)
288 {
289 context->clearBufferfv(buffer, drawbuffer, value);
290 }
291 ANGLE_CAPTURE(ClearBufferfv, isCallValid, context, buffer, drawbuffer, value);
292 }
293 else
294 {
295 GenerateContextLostErrorOnCurrentGlobalContext();
296 }
297 }
298
GL_ClearBufferiv(GLenum buffer,GLint drawbuffer,const GLint * value)299 void GL_APIENTRY GL_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
300 {
301 Context *context = GetValidGlobalContext();
302 EVENT(context, GLClearBufferiv,
303 "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context),
304 GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
305
306 if (context)
307 {
308 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
309 bool isCallValid = (context->skipValidation() ||
310 ValidateClearBufferiv(context, angle::EntryPoint::GLClearBufferiv,
311 buffer, drawbuffer, value));
312 if (isCallValid)
313 {
314 context->clearBufferiv(buffer, drawbuffer, value);
315 }
316 ANGLE_CAPTURE(ClearBufferiv, isCallValid, context, buffer, drawbuffer, value);
317 }
318 else
319 {
320 GenerateContextLostErrorOnCurrentGlobalContext();
321 }
322 }
323
GL_ClearBufferuiv(GLenum buffer,GLint drawbuffer,const GLuint * value)324 void GL_APIENTRY GL_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
325 {
326 Context *context = GetValidGlobalContext();
327 EVENT(context, GLClearBufferuiv,
328 "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context),
329 GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
330
331 if (context)
332 {
333 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
334 bool isCallValid = (context->skipValidation() ||
335 ValidateClearBufferuiv(context, angle::EntryPoint::GLClearBufferuiv,
336 buffer, drawbuffer, value));
337 if (isCallValid)
338 {
339 context->clearBufferuiv(buffer, drawbuffer, value);
340 }
341 ANGLE_CAPTURE(ClearBufferuiv, isCallValid, context, buffer, drawbuffer, value);
342 }
343 else
344 {
345 GenerateContextLostErrorOnCurrentGlobalContext();
346 }
347 }
348
GL_ClientWaitSync(GLsync sync,GLbitfield flags,GLuint64 timeout)349 GLenum GL_APIENTRY GL_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
350 {
351 Context *context = GetValidGlobalContext();
352 EVENT(context, GLClientWaitSync,
353 "context = %d, sync = 0x%016" PRIxPTR ", flags = %s, timeout = %llu", CID(context),
354 (uintptr_t)sync, GLbitfieldToString(GLenumGroup::SyncObjectMask, flags).c_str(),
355 static_cast<unsigned long long>(timeout));
356
357 GLenum returnValue;
358 if (context)
359 {
360 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
361 bool isCallValid = (context->skipValidation() ||
362 ValidateClientWaitSync(context, angle::EntryPoint::GLClientWaitSync,
363 sync, flags, timeout));
364 if (isCallValid)
365 {
366 returnValue = context->clientWaitSync(sync, flags, timeout);
367 }
368 else
369 {
370 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLClientWaitSync, GLenum>();
371 }
372 ANGLE_CAPTURE(ClientWaitSync, isCallValid, context, sync, flags, timeout, returnValue);
373 }
374 else
375 {
376 GenerateContextLostErrorOnCurrentGlobalContext();
377 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLClientWaitSync, GLenum>();
378 }
379 return returnValue;
380 }
381
GL_CompressedTexImage3D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)382 void GL_APIENTRY GL_CompressedTexImage3D(GLenum target,
383 GLint level,
384 GLenum internalformat,
385 GLsizei width,
386 GLsizei height,
387 GLsizei depth,
388 GLint border,
389 GLsizei imageSize,
390 const void *data)
391 {
392 Context *context = GetValidGlobalContext();
393 EVENT(context, GLCompressedTexImage3D,
394 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
395 "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "",
396 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
397 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
398 imageSize, (uintptr_t)data);
399
400 if (context)
401 {
402 TextureTarget targetPacked = PackParam<TextureTarget>(target);
403 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
404 bool isCallValid =
405 (context->skipValidation() ||
406 ValidateCompressedTexImage3D(context, angle::EntryPoint::GLCompressedTexImage3D,
407 targetPacked, level, internalformat, width, height, depth,
408 border, imageSize, data));
409 if (isCallValid)
410 {
411 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
412 border, imageSize, data);
413 }
414 ANGLE_CAPTURE(CompressedTexImage3D, isCallValid, context, targetPacked, level,
415 internalformat, width, height, depth, border, imageSize, data);
416 }
417 else
418 {
419 GenerateContextLostErrorOnCurrentGlobalContext();
420 }
421 }
422
GL_CompressedTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)423 void GL_APIENTRY GL_CompressedTexSubImage3D(GLenum target,
424 GLint level,
425 GLint xoffset,
426 GLint yoffset,
427 GLint zoffset,
428 GLsizei width,
429 GLsizei height,
430 GLsizei depth,
431 GLenum format,
432 GLsizei imageSize,
433 const void *data)
434 {
435 Context *context = GetValidGlobalContext();
436 EVENT(context, GLCompressedTexSubImage3D,
437 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
438 "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "",
439 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
440 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
441 imageSize, (uintptr_t)data);
442
443 if (context)
444 {
445 TextureTarget targetPacked = PackParam<TextureTarget>(target);
446 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
447 bool isCallValid =
448 (context->skipValidation() ||
449 ValidateCompressedTexSubImage3D(context, angle::EntryPoint::GLCompressedTexSubImage3D,
450 targetPacked, level, xoffset, yoffset, zoffset, width,
451 height, depth, format, imageSize, data));
452 if (isCallValid)
453 {
454 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
455 height, depth, format, imageSize, data);
456 }
457 ANGLE_CAPTURE(CompressedTexSubImage3D, isCallValid, context, targetPacked, level, xoffset,
458 yoffset, zoffset, width, height, depth, format, imageSize, data);
459 }
460 else
461 {
462 GenerateContextLostErrorOnCurrentGlobalContext();
463 }
464 }
465
GL_CopyBufferSubData(GLenum readTarget,GLenum writeTarget,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size)466 void GL_APIENTRY GL_CopyBufferSubData(GLenum readTarget,
467 GLenum writeTarget,
468 GLintptr readOffset,
469 GLintptr writeOffset,
470 GLsizeiptr size)
471 {
472 Context *context = GetValidGlobalContext();
473 EVENT(context, GLCopyBufferSubData,
474 "context = %d, readTarget = %s, writeTarget = %s, readOffset = %llu, writeOffset = %llu, "
475 "size = %llu",
476 CID(context), GLenumToString(GLenumGroup::CopyBufferSubDataTarget, readTarget),
477 GLenumToString(GLenumGroup::CopyBufferSubDataTarget, writeTarget),
478 static_cast<unsigned long long>(readOffset), static_cast<unsigned long long>(writeOffset),
479 static_cast<unsigned long long>(size));
480
481 if (context)
482 {
483 BufferBinding readTargetPacked = PackParam<BufferBinding>(readTarget);
484 BufferBinding writeTargetPacked = PackParam<BufferBinding>(writeTarget);
485 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
486 bool isCallValid = (context->skipValidation() ||
487 ValidateCopyBufferSubData(
488 context, angle::EntryPoint::GLCopyBufferSubData, readTargetPacked,
489 writeTargetPacked, readOffset, writeOffset, size));
490 if (isCallValid)
491 {
492 context->copyBufferSubData(readTargetPacked, writeTargetPacked, readOffset, writeOffset,
493 size);
494 }
495 ANGLE_CAPTURE(CopyBufferSubData, isCallValid, context, readTargetPacked, writeTargetPacked,
496 readOffset, writeOffset, size);
497 }
498 else
499 {
500 GenerateContextLostErrorOnCurrentGlobalContext();
501 }
502 }
503
GL_CopyTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)504 void GL_APIENTRY GL_CopyTexSubImage3D(GLenum target,
505 GLint level,
506 GLint xoffset,
507 GLint yoffset,
508 GLint zoffset,
509 GLint x,
510 GLint y,
511 GLsizei width,
512 GLsizei height)
513 {
514 Context *context = GetValidGlobalContext();
515 EVENT(context, GLCopyTexSubImage3D,
516 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = "
517 "%d, y = %d, width = %d, height = %d",
518 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
519 zoffset, x, y, width, height);
520
521 if (context)
522 {
523 TextureTarget targetPacked = PackParam<TextureTarget>(target);
524 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
525 bool isCallValid = (context->skipValidation() ||
526 ValidateCopyTexSubImage3D(
527 context, angle::EntryPoint::GLCopyTexSubImage3D, targetPacked,
528 level, xoffset, yoffset, zoffset, x, y, width, height));
529 if (isCallValid)
530 {
531 context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
532 height);
533 }
534 ANGLE_CAPTURE(CopyTexSubImage3D, isCallValid, context, targetPacked, level, xoffset,
535 yoffset, zoffset, x, y, width, height);
536 }
537 else
538 {
539 GenerateContextLostErrorOnCurrentGlobalContext();
540 }
541 }
542
GL_DeleteQueries(GLsizei n,const GLuint * ids)543 void GL_APIENTRY GL_DeleteQueries(GLsizei n, const GLuint *ids)
544 {
545 Context *context = GetValidGlobalContext();
546 EVENT(context, GLDeleteQueries, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context),
547 n, (uintptr_t)ids);
548
549 if (context)
550 {
551 const QueryID *idsPacked = PackParam<const QueryID *>(ids);
552 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
553 bool isCallValid =
554 (context->skipValidation() ||
555 ValidateDeleteQueries(context, angle::EntryPoint::GLDeleteQueries, n, idsPacked));
556 if (isCallValid)
557 {
558 context->deleteQueries(n, idsPacked);
559 }
560 ANGLE_CAPTURE(DeleteQueries, isCallValid, context, n, idsPacked);
561 }
562 else
563 {
564 GenerateContextLostErrorOnCurrentGlobalContext();
565 }
566 }
567
GL_DeleteSamplers(GLsizei count,const GLuint * samplers)568 void GL_APIENTRY GL_DeleteSamplers(GLsizei count, const GLuint *samplers)
569 {
570 Context *context = GetValidGlobalContext();
571 EVENT(context, GLDeleteSamplers, "context = %d, count = %d, samplers = 0x%016" PRIxPTR "",
572 CID(context), count, (uintptr_t)samplers);
573
574 if (context)
575 {
576 const SamplerID *samplersPacked = PackParam<const SamplerID *>(samplers);
577 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
578 bool isCallValid = (context->skipValidation() ||
579 ValidateDeleteSamplers(context, angle::EntryPoint::GLDeleteSamplers,
580 count, samplersPacked));
581 if (isCallValid)
582 {
583 context->deleteSamplers(count, samplersPacked);
584 }
585 ANGLE_CAPTURE(DeleteSamplers, isCallValid, context, count, samplersPacked);
586 }
587 else
588 {
589 GenerateContextLostErrorOnCurrentGlobalContext();
590 }
591 }
592
GL_DeleteSync(GLsync sync)593 void GL_APIENTRY GL_DeleteSync(GLsync sync)
594 {
595 Context *context = GetValidGlobalContext();
596 EVENT(context, GLDeleteSync, "context = %d, sync = 0x%016" PRIxPTR "", CID(context),
597 (uintptr_t)sync);
598
599 if (context)
600 {
601 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
602 bool isCallValid = (context->skipValidation() ||
603 ValidateDeleteSync(context, angle::EntryPoint::GLDeleteSync, sync));
604 if (isCallValid)
605 {
606 context->deleteSync(sync);
607 }
608 ANGLE_CAPTURE(DeleteSync, isCallValid, context, sync);
609 }
610 else
611 {
612 GenerateContextLostErrorOnCurrentGlobalContext();
613 }
614 }
615
GL_DeleteTransformFeedbacks(GLsizei n,const GLuint * ids)616 void GL_APIENTRY GL_DeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
617 {
618 Context *context = GetValidGlobalContext();
619 EVENT(context, GLDeleteTransformFeedbacks, "context = %d, n = %d, ids = 0x%016" PRIxPTR "",
620 CID(context), n, (uintptr_t)ids);
621
622 if (context)
623 {
624 const TransformFeedbackID *idsPacked = PackParam<const TransformFeedbackID *>(ids);
625 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
626 bool isCallValid =
627 (context->skipValidation() ||
628 ValidateDeleteTransformFeedbacks(
629 context, angle::EntryPoint::GLDeleteTransformFeedbacks, n, idsPacked));
630 if (isCallValid)
631 {
632 context->deleteTransformFeedbacks(n, idsPacked);
633 }
634 ANGLE_CAPTURE(DeleteTransformFeedbacks, isCallValid, context, n, idsPacked);
635 }
636 else
637 {
638 GenerateContextLostErrorOnCurrentGlobalContext();
639 }
640 }
641
GL_DeleteVertexArrays(GLsizei n,const GLuint * arrays)642 void GL_APIENTRY GL_DeleteVertexArrays(GLsizei n, const GLuint *arrays)
643 {
644 Context *context = GetValidGlobalContext();
645 EVENT(context, GLDeleteVertexArrays, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
646 CID(context), n, (uintptr_t)arrays);
647
648 if (context)
649 {
650 const VertexArrayID *arraysPacked = PackParam<const VertexArrayID *>(arrays);
651 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
652 bool isCallValid = (context->skipValidation() ||
653 ValidateDeleteVertexArrays(
654 context, angle::EntryPoint::GLDeleteVertexArrays, n, arraysPacked));
655 if (isCallValid)
656 {
657 context->deleteVertexArrays(n, arraysPacked);
658 }
659 ANGLE_CAPTURE(DeleteVertexArrays, isCallValid, context, n, arraysPacked);
660 }
661 else
662 {
663 GenerateContextLostErrorOnCurrentGlobalContext();
664 }
665 }
666
GL_DrawArraysInstanced(GLenum mode,GLint first,GLsizei count,GLsizei instancecount)667 void GL_APIENTRY GL_DrawArraysInstanced(GLenum mode,
668 GLint first,
669 GLsizei count,
670 GLsizei instancecount)
671 {
672 Context *context = GetValidGlobalContext();
673 EVENT(context, GLDrawArraysInstanced,
674 "context = %d, mode = %s, first = %d, count = %d, instancecount = %d", CID(context),
675 GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, instancecount);
676
677 if (context)
678 {
679 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
680 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
681 bool isCallValid =
682 (context->skipValidation() ||
683 ValidateDrawArraysInstanced(context, angle::EntryPoint::GLDrawArraysInstanced,
684 modePacked, first, count, instancecount));
685 if (isCallValid)
686 {
687 context->drawArraysInstanced(modePacked, first, count, instancecount);
688 }
689 ANGLE_CAPTURE(DrawArraysInstanced, isCallValid, context, modePacked, first, count,
690 instancecount);
691 }
692 else
693 {
694 GenerateContextLostErrorOnCurrentGlobalContext();
695 }
696 }
697
GL_DrawBuffers(GLsizei n,const GLenum * bufs)698 void GL_APIENTRY GL_DrawBuffers(GLsizei n, const GLenum *bufs)
699 {
700 Context *context = GetValidGlobalContext();
701 EVENT(context, GLDrawBuffers, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context), n,
702 (uintptr_t)bufs);
703
704 if (context)
705 {
706 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
707 bool isCallValid =
708 (context->skipValidation() ||
709 ValidateDrawBuffers(context, angle::EntryPoint::GLDrawBuffers, n, bufs));
710 if (isCallValid)
711 {
712 context->drawBuffers(n, bufs);
713 }
714 ANGLE_CAPTURE(DrawBuffers, isCallValid, context, n, bufs);
715 }
716 else
717 {
718 GenerateContextLostErrorOnCurrentGlobalContext();
719 }
720 }
721
GL_DrawElementsInstanced(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount)722 void GL_APIENTRY GL_DrawElementsInstanced(GLenum mode,
723 GLsizei count,
724 GLenum type,
725 const void *indices,
726 GLsizei instancecount)
727 {
728 Context *context = GetValidGlobalContext();
729 EVENT(context, GLDrawElementsInstanced,
730 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
731 ", instancecount = %d",
732 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
733 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount);
734
735 if (context)
736 {
737 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
738 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
739 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
740 bool isCallValid =
741 (context->skipValidation() ||
742 ValidateDrawElementsInstanced(context, angle::EntryPoint::GLDrawElementsInstanced,
743 modePacked, count, typePacked, indices, instancecount));
744 if (isCallValid)
745 {
746 context->drawElementsInstanced(modePacked, count, typePacked, indices, instancecount);
747 }
748 ANGLE_CAPTURE(DrawElementsInstanced, isCallValid, context, modePacked, count, typePacked,
749 indices, instancecount);
750 }
751 else
752 {
753 GenerateContextLostErrorOnCurrentGlobalContext();
754 }
755 }
756
GL_DrawRangeElements(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices)757 void GL_APIENTRY GL_DrawRangeElements(GLenum mode,
758 GLuint start,
759 GLuint end,
760 GLsizei count,
761 GLenum type,
762 const void *indices)
763 {
764 Context *context = GetValidGlobalContext();
765 EVENT(context, GLDrawRangeElements,
766 "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
767 "0x%016" PRIxPTR "",
768 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
769 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices);
770
771 if (context)
772 {
773 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
774 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
775 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
776 bool isCallValid =
777 (context->skipValidation() ||
778 ValidateDrawRangeElements(context, angle::EntryPoint::GLDrawRangeElements, modePacked,
779 start, end, count, typePacked, indices));
780 if (isCallValid)
781 {
782 context->drawRangeElements(modePacked, start, end, count, typePacked, indices);
783 }
784 ANGLE_CAPTURE(DrawRangeElements, isCallValid, context, modePacked, start, end, count,
785 typePacked, indices);
786 }
787 else
788 {
789 GenerateContextLostErrorOnCurrentGlobalContext();
790 }
791 }
792
GL_EndQuery(GLenum target)793 void GL_APIENTRY GL_EndQuery(GLenum target)
794 {
795 Context *context = GetValidGlobalContext();
796 EVENT(context, GLEndQuery, "context = %d, target = %s", CID(context),
797 GLenumToString(GLenumGroup::QueryTarget, target));
798
799 if (context)
800 {
801 QueryType targetPacked = PackParam<QueryType>(target);
802 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
803 bool isCallValid = (context->skipValidation() ||
804 ValidateEndQuery(context, angle::EntryPoint::GLEndQuery, targetPacked));
805 if (isCallValid)
806 {
807 context->endQuery(targetPacked);
808 }
809 ANGLE_CAPTURE(EndQuery, isCallValid, context, targetPacked);
810 }
811 else
812 {
813 GenerateContextLostErrorOnCurrentGlobalContext();
814 }
815 }
816
GL_EndTransformFeedback()817 void GL_APIENTRY GL_EndTransformFeedback()
818 {
819 Context *context = GetValidGlobalContext();
820 EVENT(context, GLEndTransformFeedback, "context = %d", CID(context));
821
822 if (context)
823 {
824 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
825 bool isCallValid =
826 (context->skipValidation() ||
827 ValidateEndTransformFeedback(context, angle::EntryPoint::GLEndTransformFeedback));
828 if (isCallValid)
829 {
830 context->endTransformFeedback();
831 }
832 ANGLE_CAPTURE(EndTransformFeedback, isCallValid, context);
833 }
834 else
835 {
836 GenerateContextLostErrorOnCurrentGlobalContext();
837 }
838 }
839
GL_FenceSync(GLenum condition,GLbitfield flags)840 GLsync GL_APIENTRY GL_FenceSync(GLenum condition, GLbitfield flags)
841 {
842 Context *context = GetValidGlobalContext();
843 EVENT(context, GLFenceSync, "context = %d, condition = %s, flags = %s", CID(context),
844 GLenumToString(GLenumGroup::SyncCondition, condition),
845 GLbitfieldToString(GLenumGroup::DefaultGroup, flags).c_str());
846
847 GLsync returnValue;
848 if (context)
849 {
850 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
851 bool isCallValid =
852 (context->skipValidation() ||
853 ValidateFenceSync(context, angle::EntryPoint::GLFenceSync, condition, flags));
854 if (isCallValid)
855 {
856 returnValue = context->fenceSync(condition, flags);
857 }
858 else
859 {
860 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLFenceSync, GLsync>();
861 }
862 ANGLE_CAPTURE(FenceSync, isCallValid, context, condition, flags, returnValue);
863 }
864 else
865 {
866 GenerateContextLostErrorOnCurrentGlobalContext();
867 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLFenceSync, GLsync>();
868 }
869 return returnValue;
870 }
871
GL_FlushMappedBufferRange(GLenum target,GLintptr offset,GLsizeiptr length)872 void GL_APIENTRY GL_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
873 {
874 Context *context = GetValidGlobalContext();
875 EVENT(context, GLFlushMappedBufferRange,
876 "context = %d, target = %s, offset = %llu, length = %llu", CID(context),
877 GLenumToString(GLenumGroup::BufferTargetARB, target),
878 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
879
880 if (context)
881 {
882 BufferBinding targetPacked = PackParam<BufferBinding>(target);
883 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
884 bool isCallValid =
885 (context->skipValidation() ||
886 ValidateFlushMappedBufferRange(context, angle::EntryPoint::GLFlushMappedBufferRange,
887 targetPacked, offset, length));
888 if (isCallValid)
889 {
890 context->flushMappedBufferRange(targetPacked, offset, length);
891 }
892 ANGLE_CAPTURE(FlushMappedBufferRange, isCallValid, context, targetPacked, offset, length);
893 }
894 else
895 {
896 GenerateContextLostErrorOnCurrentGlobalContext();
897 }
898 }
899
GL_FramebufferTextureLayer(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)900 void GL_APIENTRY GL_FramebufferTextureLayer(GLenum target,
901 GLenum attachment,
902 GLuint texture,
903 GLint level,
904 GLint layer)
905 {
906 Context *context = GetValidGlobalContext();
907 EVENT(context, GLFramebufferTextureLayer,
908 "context = %d, target = %s, attachment = %s, texture = %u, level = %d, layer = %d",
909 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
910 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level, layer);
911
912 if (context)
913 {
914 TextureID texturePacked = PackParam<TextureID>(texture);
915 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
916 bool isCallValid =
917 (context->skipValidation() ||
918 ValidateFramebufferTextureLayer(context, angle::EntryPoint::GLFramebufferTextureLayer,
919 target, attachment, texturePacked, level, layer));
920 if (isCallValid)
921 {
922 context->framebufferTextureLayer(target, attachment, texturePacked, level, layer);
923 }
924 ANGLE_CAPTURE(FramebufferTextureLayer, isCallValid, context, target, attachment,
925 texturePacked, level, layer);
926 }
927 else
928 {
929 GenerateContextLostErrorOnCurrentGlobalContext();
930 }
931 }
932
GL_GenQueries(GLsizei n,GLuint * ids)933 void GL_APIENTRY GL_GenQueries(GLsizei n, GLuint *ids)
934 {
935 Context *context = GetValidGlobalContext();
936 EVENT(context, GLGenQueries, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context), n,
937 (uintptr_t)ids);
938
939 if (context)
940 {
941 QueryID *idsPacked = PackParam<QueryID *>(ids);
942 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
943 bool isCallValid =
944 (context->skipValidation() ||
945 ValidateGenQueries(context, angle::EntryPoint::GLGenQueries, n, idsPacked));
946 if (isCallValid)
947 {
948 context->genQueries(n, idsPacked);
949 }
950 ANGLE_CAPTURE(GenQueries, isCallValid, context, n, idsPacked);
951 }
952 else
953 {
954 GenerateContextLostErrorOnCurrentGlobalContext();
955 }
956 }
957
GL_GenSamplers(GLsizei count,GLuint * samplers)958 void GL_APIENTRY GL_GenSamplers(GLsizei count, GLuint *samplers)
959 {
960 Context *context = GetValidGlobalContext();
961 EVENT(context, GLGenSamplers, "context = %d, count = %d, samplers = 0x%016" PRIxPTR "",
962 CID(context), count, (uintptr_t)samplers);
963
964 if (context)
965 {
966 SamplerID *samplersPacked = PackParam<SamplerID *>(samplers);
967 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
968 bool isCallValid =
969 (context->skipValidation() ||
970 ValidateGenSamplers(context, angle::EntryPoint::GLGenSamplers, count, samplersPacked));
971 if (isCallValid)
972 {
973 context->genSamplers(count, samplersPacked);
974 }
975 ANGLE_CAPTURE(GenSamplers, isCallValid, context, count, samplersPacked);
976 }
977 else
978 {
979 GenerateContextLostErrorOnCurrentGlobalContext();
980 }
981 }
982
GL_GenTransformFeedbacks(GLsizei n,GLuint * ids)983 void GL_APIENTRY GL_GenTransformFeedbacks(GLsizei n, GLuint *ids)
984 {
985 Context *context = GetValidGlobalContext();
986 EVENT(context, GLGenTransformFeedbacks, "context = %d, n = %d, ids = 0x%016" PRIxPTR "",
987 CID(context), n, (uintptr_t)ids);
988
989 if (context)
990 {
991 TransformFeedbackID *idsPacked = PackParam<TransformFeedbackID *>(ids);
992 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
993 bool isCallValid = (context->skipValidation() ||
994 ValidateGenTransformFeedbacks(
995 context, angle::EntryPoint::GLGenTransformFeedbacks, n, idsPacked));
996 if (isCallValid)
997 {
998 context->genTransformFeedbacks(n, idsPacked);
999 }
1000 ANGLE_CAPTURE(GenTransformFeedbacks, isCallValid, context, n, idsPacked);
1001 }
1002 else
1003 {
1004 GenerateContextLostErrorOnCurrentGlobalContext();
1005 }
1006 }
1007
GL_GenVertexArrays(GLsizei n,GLuint * arrays)1008 void GL_APIENTRY GL_GenVertexArrays(GLsizei n, GLuint *arrays)
1009 {
1010 Context *context = GetValidGlobalContext();
1011 EVENT(context, GLGenVertexArrays, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
1012 CID(context), n, (uintptr_t)arrays);
1013
1014 if (context)
1015 {
1016 VertexArrayID *arraysPacked = PackParam<VertexArrayID *>(arrays);
1017 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1018 bool isCallValid = (context->skipValidation() ||
1019 ValidateGenVertexArrays(context, angle::EntryPoint::GLGenVertexArrays,
1020 n, arraysPacked));
1021 if (isCallValid)
1022 {
1023 context->genVertexArrays(n, arraysPacked);
1024 }
1025 ANGLE_CAPTURE(GenVertexArrays, isCallValid, context, n, arraysPacked);
1026 }
1027 else
1028 {
1029 GenerateContextLostErrorOnCurrentGlobalContext();
1030 }
1031 }
1032
GL_GetActiveUniformBlockName(GLuint program,GLuint uniformBlockIndex,GLsizei bufSize,GLsizei * length,GLchar * uniformBlockName)1033 void GL_APIENTRY GL_GetActiveUniformBlockName(GLuint program,
1034 GLuint uniformBlockIndex,
1035 GLsizei bufSize,
1036 GLsizei *length,
1037 GLchar *uniformBlockName)
1038 {
1039 Context *context = GetValidGlobalContext();
1040 EVENT(
1041 context, GLGetActiveUniformBlockName,
1042 "context = %d, program = %u, uniformBlockIndex = %u, bufSize = %d, length = 0x%016" PRIxPTR
1043 ", uniformBlockName = 0x%016" PRIxPTR "",
1044 CID(context), program, uniformBlockIndex, bufSize, (uintptr_t)length,
1045 (uintptr_t)uniformBlockName);
1046
1047 if (context)
1048 {
1049 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1050 UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex);
1051 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1052 bool isCallValid =
1053 (context->skipValidation() ||
1054 ValidateGetActiveUniformBlockName(
1055 context, angle::EntryPoint::GLGetActiveUniformBlockName, programPacked,
1056 uniformBlockIndexPacked, bufSize, length, uniformBlockName));
1057 if (isCallValid)
1058 {
1059 context->getActiveUniformBlockName(programPacked, uniformBlockIndexPacked, bufSize,
1060 length, uniformBlockName);
1061 }
1062 ANGLE_CAPTURE(GetActiveUniformBlockName, isCallValid, context, programPacked,
1063 uniformBlockIndexPacked, bufSize, length, uniformBlockName);
1064 }
1065 else
1066 {
1067 GenerateContextLostErrorOnCurrentGlobalContext();
1068 }
1069 }
1070
GL_GetActiveUniformBlockiv(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLint * params)1071 void GL_APIENTRY GL_GetActiveUniformBlockiv(GLuint program,
1072 GLuint uniformBlockIndex,
1073 GLenum pname,
1074 GLint *params)
1075 {
1076 Context *context = GetValidGlobalContext();
1077 EVENT(context, GLGetActiveUniformBlockiv,
1078 "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, params = 0x%016" PRIxPTR
1079 "",
1080 CID(context), program, uniformBlockIndex,
1081 GLenumToString(GLenumGroup::UniformBlockPName, pname), (uintptr_t)params);
1082
1083 if (context)
1084 {
1085 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1086 UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex);
1087 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1088 bool isCallValid = (context->skipValidation() ||
1089 ValidateGetActiveUniformBlockiv(
1090 context, angle::EntryPoint::GLGetActiveUniformBlockiv,
1091 programPacked, uniformBlockIndexPacked, pname, params));
1092 if (isCallValid)
1093 {
1094 context->getActiveUniformBlockiv(programPacked, uniformBlockIndexPacked, pname, params);
1095 }
1096 ANGLE_CAPTURE(GetActiveUniformBlockiv, isCallValid, context, programPacked,
1097 uniformBlockIndexPacked, pname, params);
1098 }
1099 else
1100 {
1101 GenerateContextLostErrorOnCurrentGlobalContext();
1102 }
1103 }
1104
GL_GetActiveUniformsiv(GLuint program,GLsizei uniformCount,const GLuint * uniformIndices,GLenum pname,GLint * params)1105 void GL_APIENTRY GL_GetActiveUniformsiv(GLuint program,
1106 GLsizei uniformCount,
1107 const GLuint *uniformIndices,
1108 GLenum pname,
1109 GLint *params)
1110 {
1111 Context *context = GetValidGlobalContext();
1112 EVENT(context, GLGetActiveUniformsiv,
1113 "context = %d, program = %u, uniformCount = %d, uniformIndices = 0x%016" PRIxPTR
1114 ", pname = %s, params = 0x%016" PRIxPTR "",
1115 CID(context), program, uniformCount, (uintptr_t)uniformIndices,
1116 GLenumToString(GLenumGroup::UniformPName, pname), (uintptr_t)params);
1117
1118 if (context)
1119 {
1120 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1121 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1122 bool isCallValid = (context->skipValidation() ||
1123 ValidateGetActiveUniformsiv(
1124 context, angle::EntryPoint::GLGetActiveUniformsiv, programPacked,
1125 uniformCount, uniformIndices, pname, params));
1126 if (isCallValid)
1127 {
1128 context->getActiveUniformsiv(programPacked, uniformCount, uniformIndices, pname,
1129 params);
1130 }
1131 ANGLE_CAPTURE(GetActiveUniformsiv, isCallValid, context, programPacked, uniformCount,
1132 uniformIndices, pname, params);
1133 }
1134 else
1135 {
1136 GenerateContextLostErrorOnCurrentGlobalContext();
1137 }
1138 }
1139
GL_GetBufferParameteri64v(GLenum target,GLenum pname,GLint64 * params)1140 void GL_APIENTRY GL_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
1141 {
1142 Context *context = GetValidGlobalContext();
1143 EVENT(context, GLGetBufferParameteri64v,
1144 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1145 GLenumToString(GLenumGroup::BufferTargetARB, target),
1146 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
1147
1148 if (context)
1149 {
1150 BufferBinding targetPacked = PackParam<BufferBinding>(target);
1151 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1152 bool isCallValid =
1153 (context->skipValidation() ||
1154 ValidateGetBufferParameteri64v(context, angle::EntryPoint::GLGetBufferParameteri64v,
1155 targetPacked, pname, params));
1156 if (isCallValid)
1157 {
1158 context->getBufferParameteri64v(targetPacked, pname, params);
1159 }
1160 ANGLE_CAPTURE(GetBufferParameteri64v, isCallValid, context, targetPacked, pname, params);
1161 }
1162 else
1163 {
1164 GenerateContextLostErrorOnCurrentGlobalContext();
1165 }
1166 }
1167
GL_GetBufferPointerv(GLenum target,GLenum pname,void ** params)1168 void GL_APIENTRY GL_GetBufferPointerv(GLenum target, GLenum pname, void **params)
1169 {
1170 Context *context = GetValidGlobalContext();
1171 EVENT(context, GLGetBufferPointerv,
1172 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1173 GLenumToString(GLenumGroup::BufferTargetARB, target),
1174 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
1175
1176 if (context)
1177 {
1178 BufferBinding targetPacked = PackParam<BufferBinding>(target);
1179 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1180 bool isCallValid =
1181 (context->skipValidation() ||
1182 ValidateGetBufferPointerv(context, angle::EntryPoint::GLGetBufferPointerv,
1183 targetPacked, pname, params));
1184 if (isCallValid)
1185 {
1186 context->getBufferPointerv(targetPacked, pname, params);
1187 }
1188 ANGLE_CAPTURE(GetBufferPointerv, isCallValid, context, targetPacked, pname, params);
1189 }
1190 else
1191 {
1192 GenerateContextLostErrorOnCurrentGlobalContext();
1193 }
1194 }
1195
GL_GetFragDataLocation(GLuint program,const GLchar * name)1196 GLint GL_APIENTRY GL_GetFragDataLocation(GLuint program, const GLchar *name)
1197 {
1198 Context *context = GetValidGlobalContext();
1199 EVENT(context, GLGetFragDataLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
1200 CID(context), program, (uintptr_t)name);
1201
1202 GLint returnValue;
1203 if (context)
1204 {
1205 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1206 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1207 bool isCallValid =
1208 (context->skipValidation() ||
1209 ValidateGetFragDataLocation(context, angle::EntryPoint::GLGetFragDataLocation,
1210 programPacked, name));
1211 if (isCallValid)
1212 {
1213 returnValue = context->getFragDataLocation(programPacked, name);
1214 }
1215 else
1216 {
1217 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataLocation, GLint>();
1218 }
1219 ANGLE_CAPTURE(GetFragDataLocation, isCallValid, context, programPacked, name, returnValue);
1220 }
1221 else
1222 {
1223 GenerateContextLostErrorOnCurrentGlobalContext();
1224 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataLocation, GLint>();
1225 }
1226 return returnValue;
1227 }
1228
GL_GetInteger64i_v(GLenum target,GLuint index,GLint64 * data)1229 void GL_APIENTRY GL_GetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
1230 {
1231 Context *context = GetValidGlobalContext();
1232 EVENT(context, GLGetInteger64i_v,
1233 "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context),
1234 GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
1235
1236 if (context)
1237 {
1238 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1239 bool isCallValid = (context->skipValidation() ||
1240 ValidateGetInteger64i_v(context, angle::EntryPoint::GLGetInteger64i_v,
1241 target, index, data));
1242 if (isCallValid)
1243 {
1244 context->getInteger64i_v(target, index, data);
1245 }
1246 ANGLE_CAPTURE(GetInteger64i_v, isCallValid, context, target, index, data);
1247 }
1248 else
1249 {
1250 GenerateContextLostErrorOnCurrentGlobalContext();
1251 }
1252 }
1253
GL_GetInteger64v(GLenum pname,GLint64 * data)1254 void GL_APIENTRY GL_GetInteger64v(GLenum pname, GLint64 *data)
1255 {
1256 Context *context = GetValidGlobalContext();
1257 EVENT(context, GLGetInteger64v, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
1258 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
1259
1260 if (context)
1261 {
1262 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1263 bool isCallValid =
1264 (context->skipValidation() ||
1265 ValidateGetInteger64v(context, angle::EntryPoint::GLGetInteger64v, pname, data));
1266 if (isCallValid)
1267 {
1268 context->getInteger64v(pname, data);
1269 }
1270 ANGLE_CAPTURE(GetInteger64v, isCallValid, context, pname, data);
1271 }
1272 else
1273 {
1274 GenerateContextLostErrorOnCurrentGlobalContext();
1275 }
1276 }
1277
GL_GetIntegeri_v(GLenum target,GLuint index,GLint * data)1278 void GL_APIENTRY GL_GetIntegeri_v(GLenum target, GLuint index, GLint *data)
1279 {
1280 Context *context = GetValidGlobalContext();
1281 EVENT(context, GLGetIntegeri_v,
1282 "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context),
1283 GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
1284
1285 if (context)
1286 {
1287 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1288 bool isCallValid = (context->skipValidation() ||
1289 ValidateGetIntegeri_v(context, angle::EntryPoint::GLGetIntegeri_v,
1290 target, index, data));
1291 if (isCallValid)
1292 {
1293 context->getIntegeri_v(target, index, data);
1294 }
1295 ANGLE_CAPTURE(GetIntegeri_v, isCallValid, context, target, index, data);
1296 }
1297 else
1298 {
1299 GenerateContextLostErrorOnCurrentGlobalContext();
1300 }
1301 }
1302
GL_GetInternalformativ(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint * params)1303 void GL_APIENTRY GL_GetInternalformativ(GLenum target,
1304 GLenum internalformat,
1305 GLenum pname,
1306 GLsizei bufSize,
1307 GLint *params)
1308 {
1309 Context *context = GetValidGlobalContext();
1310 EVENT(context, GLGetInternalformativ,
1311 "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, params = "
1312 "0x%016" PRIxPTR "",
1313 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
1314 GLenumToString(GLenumGroup::InternalFormat, internalformat),
1315 GLenumToString(GLenumGroup::InternalFormatPName, pname), bufSize, (uintptr_t)params);
1316
1317 if (context)
1318 {
1319 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1320 bool isCallValid =
1321 (context->skipValidation() ||
1322 ValidateGetInternalformativ(context, angle::EntryPoint::GLGetInternalformativ, target,
1323 internalformat, pname, bufSize, params));
1324 if (isCallValid)
1325 {
1326 context->getInternalformativ(target, internalformat, pname, bufSize, params);
1327 }
1328 ANGLE_CAPTURE(GetInternalformativ, isCallValid, context, target, internalformat, pname,
1329 bufSize, params);
1330 }
1331 else
1332 {
1333 GenerateContextLostErrorOnCurrentGlobalContext();
1334 }
1335 }
1336
GL_GetProgramBinary(GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)1337 void GL_APIENTRY GL_GetProgramBinary(GLuint program,
1338 GLsizei bufSize,
1339 GLsizei *length,
1340 GLenum *binaryFormat,
1341 void *binary)
1342 {
1343 Context *context = GetValidGlobalContext();
1344 EVENT(context, GLGetProgramBinary,
1345 "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
1346 ", binaryFormat = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR "",
1347 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
1348 (uintptr_t)binary);
1349
1350 if (context)
1351 {
1352 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1353 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1354 bool isCallValid =
1355 (context->skipValidation() ||
1356 ValidateGetProgramBinary(context, angle::EntryPoint::GLGetProgramBinary, programPacked,
1357 bufSize, length, binaryFormat, binary));
1358 if (isCallValid)
1359 {
1360 context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
1361 }
1362 ANGLE_CAPTURE(GetProgramBinary, isCallValid, context, programPacked, bufSize, length,
1363 binaryFormat, binary);
1364 }
1365 else
1366 {
1367 GenerateContextLostErrorOnCurrentGlobalContext();
1368 }
1369 }
1370
GL_GetQueryObjectuiv(GLuint id,GLenum pname,GLuint * params)1371 void GL_APIENTRY GL_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
1372 {
1373 Context *context = GetValidGlobalContext();
1374 EVENT(context, GLGetQueryObjectuiv,
1375 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
1376 GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
1377
1378 if (context)
1379 {
1380 QueryID idPacked = PackParam<QueryID>(id);
1381 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1382 bool isCallValid =
1383 (context->skipValidation() ||
1384 ValidateGetQueryObjectuiv(context, angle::EntryPoint::GLGetQueryObjectuiv, idPacked,
1385 pname, params));
1386 if (isCallValid)
1387 {
1388 context->getQueryObjectuiv(idPacked, pname, params);
1389 }
1390 ANGLE_CAPTURE(GetQueryObjectuiv, isCallValid, context, idPacked, pname, params);
1391 }
1392 else
1393 {
1394 GenerateContextLostErrorOnCurrentGlobalContext();
1395 }
1396 }
1397
GL_GetQueryiv(GLenum target,GLenum pname,GLint * params)1398 void GL_APIENTRY GL_GetQueryiv(GLenum target, GLenum pname, GLint *params)
1399 {
1400 Context *context = GetValidGlobalContext();
1401 EVENT(context, GLGetQueryiv,
1402 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1403 GLenumToString(GLenumGroup::QueryTarget, target),
1404 GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
1405
1406 if (context)
1407 {
1408 QueryType targetPacked = PackParam<QueryType>(target);
1409 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1410 bool isCallValid = (context->skipValidation() ||
1411 ValidateGetQueryiv(context, angle::EntryPoint::GLGetQueryiv,
1412 targetPacked, pname, params));
1413 if (isCallValid)
1414 {
1415 context->getQueryiv(targetPacked, pname, params);
1416 }
1417 ANGLE_CAPTURE(GetQueryiv, isCallValid, context, targetPacked, pname, params);
1418 }
1419 else
1420 {
1421 GenerateContextLostErrorOnCurrentGlobalContext();
1422 }
1423 }
1424
GL_GetSamplerParameterfv(GLuint sampler,GLenum pname,GLfloat * params)1425 void GL_APIENTRY GL_GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
1426 {
1427 Context *context = GetValidGlobalContext();
1428 EVENT(context, GLGetSamplerParameterfv,
1429 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1430 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
1431
1432 if (context)
1433 {
1434 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
1435 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1436 bool isCallValid =
1437 (context->skipValidation() ||
1438 ValidateGetSamplerParameterfv(context, angle::EntryPoint::GLGetSamplerParameterfv,
1439 samplerPacked, pname, params));
1440 if (isCallValid)
1441 {
1442 context->getSamplerParameterfv(samplerPacked, pname, params);
1443 }
1444 ANGLE_CAPTURE(GetSamplerParameterfv, isCallValid, context, samplerPacked, pname, params);
1445 }
1446 else
1447 {
1448 GenerateContextLostErrorOnCurrentGlobalContext();
1449 }
1450 }
1451
GL_GetSamplerParameteriv(GLuint sampler,GLenum pname,GLint * params)1452 void GL_APIENTRY GL_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
1453 {
1454 Context *context = GetValidGlobalContext();
1455 EVENT(context, GLGetSamplerParameteriv,
1456 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
1457 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
1458
1459 if (context)
1460 {
1461 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
1462 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1463 bool isCallValid =
1464 (context->skipValidation() ||
1465 ValidateGetSamplerParameteriv(context, angle::EntryPoint::GLGetSamplerParameteriv,
1466 samplerPacked, pname, params));
1467 if (isCallValid)
1468 {
1469 context->getSamplerParameteriv(samplerPacked, pname, params);
1470 }
1471 ANGLE_CAPTURE(GetSamplerParameteriv, isCallValid, context, samplerPacked, pname, params);
1472 }
1473 else
1474 {
1475 GenerateContextLostErrorOnCurrentGlobalContext();
1476 }
1477 }
1478
GL_GetStringi(GLenum name,GLuint index)1479 const GLubyte *GL_APIENTRY GL_GetStringi(GLenum name, GLuint index)
1480 {
1481 Context *context = GetValidGlobalContext();
1482 EVENT(context, GLGetStringi, "context = %d, name = %s, index = %u", CID(context),
1483 GLenumToString(GLenumGroup::StringName, name), index);
1484
1485 const GLubyte *returnValue;
1486 if (context)
1487 {
1488 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1489 bool isCallValid =
1490 (context->skipValidation() ||
1491 ValidateGetStringi(context, angle::EntryPoint::GLGetStringi, name, index));
1492 if (isCallValid)
1493 {
1494 returnValue = context->getStringi(name, index);
1495 }
1496 else
1497 {
1498 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetStringi, const GLubyte *>();
1499 }
1500 ANGLE_CAPTURE(GetStringi, isCallValid, context, name, index, returnValue);
1501 }
1502 else
1503 {
1504 GenerateContextLostErrorOnCurrentGlobalContext();
1505 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetStringi, const GLubyte *>();
1506 }
1507 return returnValue;
1508 }
1509
1510 void GL_APIENTRY
GL_GetSynciv(GLsync sync,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * values)1511 GL_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
1512 {
1513 Context *context = GetGlobalContext();
1514 EVENT(context, GLGetSynciv,
1515 "context = %d, sync = 0x%016" PRIxPTR
1516 ", pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", values = 0x%016" PRIxPTR "",
1517 CID(context), (uintptr_t)sync, GLenumToString(GLenumGroup::SyncParameterName, pname),
1518 bufSize, (uintptr_t)length, (uintptr_t)values);
1519
1520 if (context)
1521 {
1522 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1523 bool isCallValid =
1524 (context->skipValidation() || ValidateGetSynciv(context, angle::EntryPoint::GLGetSynciv,
1525 sync, pname, bufSize, length, values));
1526 if (isCallValid)
1527 {
1528 context->getSynciv(sync, pname, bufSize, length, values);
1529 }
1530 ANGLE_CAPTURE(GetSynciv, isCallValid, context, sync, pname, bufSize, length, values);
1531 }
1532 else
1533 {}
1534 }
1535
GL_GetTransformFeedbackVarying(GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLsizei * size,GLenum * type,GLchar * name)1536 void GL_APIENTRY GL_GetTransformFeedbackVarying(GLuint program,
1537 GLuint index,
1538 GLsizei bufSize,
1539 GLsizei *length,
1540 GLsizei *size,
1541 GLenum *type,
1542 GLchar *name)
1543 {
1544 Context *context = GetValidGlobalContext();
1545 EVENT(context, GLGetTransformFeedbackVarying,
1546 "context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
1547 ", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
1548 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
1549 (uintptr_t)type, (uintptr_t)name);
1550
1551 if (context)
1552 {
1553 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1554 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1555 bool isCallValid = (context->skipValidation() ||
1556 ValidateGetTransformFeedbackVarying(
1557 context, angle::EntryPoint::GLGetTransformFeedbackVarying,
1558 programPacked, index, bufSize, length, size, type, name));
1559 if (isCallValid)
1560 {
1561 context->getTransformFeedbackVarying(programPacked, index, bufSize, length, size, type,
1562 name);
1563 }
1564 ANGLE_CAPTURE(GetTransformFeedbackVarying, isCallValid, context, programPacked, index,
1565 bufSize, length, size, type, name);
1566 }
1567 else
1568 {
1569 GenerateContextLostErrorOnCurrentGlobalContext();
1570 }
1571 }
1572
GL_GetUniformBlockIndex(GLuint program,const GLchar * uniformBlockName)1573 GLuint GL_APIENTRY GL_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
1574 {
1575 Context *context = GetValidGlobalContext();
1576 EVENT(context, GLGetUniformBlockIndex,
1577 "context = %d, program = %u, uniformBlockName = 0x%016" PRIxPTR "", CID(context), program,
1578 (uintptr_t)uniformBlockName);
1579
1580 GLuint returnValue;
1581 if (context)
1582 {
1583 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1584 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1585 bool isCallValid =
1586 (context->skipValidation() ||
1587 ValidateGetUniformBlockIndex(context, angle::EntryPoint::GLGetUniformBlockIndex,
1588 programPacked, uniformBlockName));
1589 if (isCallValid)
1590 {
1591 returnValue = context->getUniformBlockIndex(programPacked, uniformBlockName);
1592 }
1593 else
1594 {
1595 returnValue =
1596 GetDefaultReturnValue<angle::EntryPoint::GLGetUniformBlockIndex, GLuint>();
1597 }
1598 ANGLE_CAPTURE(GetUniformBlockIndex, isCallValid, context, programPacked, uniformBlockName,
1599 returnValue);
1600 }
1601 else
1602 {
1603 GenerateContextLostErrorOnCurrentGlobalContext();
1604 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformBlockIndex, GLuint>();
1605 }
1606 return returnValue;
1607 }
1608
GL_GetUniformIndices(GLuint program,GLsizei uniformCount,const GLchar * const * uniformNames,GLuint * uniformIndices)1609 void GL_APIENTRY GL_GetUniformIndices(GLuint program,
1610 GLsizei uniformCount,
1611 const GLchar *const *uniformNames,
1612 GLuint *uniformIndices)
1613 {
1614 Context *context = GetValidGlobalContext();
1615 EVENT(context, GLGetUniformIndices,
1616 "context = %d, program = %u, uniformCount = %d, uniformNames = 0x%016" PRIxPTR
1617 ", uniformIndices = 0x%016" PRIxPTR "",
1618 CID(context), program, uniformCount, (uintptr_t)uniformNames, (uintptr_t)uniformIndices);
1619
1620 if (context)
1621 {
1622 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1623 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1624 bool isCallValid =
1625 (context->skipValidation() ||
1626 ValidateGetUniformIndices(context, angle::EntryPoint::GLGetUniformIndices,
1627 programPacked, uniformCount, uniformNames, uniformIndices));
1628 if (isCallValid)
1629 {
1630 context->getUniformIndices(programPacked, uniformCount, uniformNames, uniformIndices);
1631 }
1632 ANGLE_CAPTURE(GetUniformIndices, isCallValid, context, programPacked, uniformCount,
1633 uniformNames, uniformIndices);
1634 }
1635 else
1636 {
1637 GenerateContextLostErrorOnCurrentGlobalContext();
1638 }
1639 }
1640
GL_GetUniformuiv(GLuint program,GLint location,GLuint * params)1641 void GL_APIENTRY GL_GetUniformuiv(GLuint program, GLint location, GLuint *params)
1642 {
1643 Context *context = GetValidGlobalContext();
1644 EVENT(context, GLGetUniformuiv,
1645 "context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
1646 program, location, (uintptr_t)params);
1647
1648 if (context)
1649 {
1650 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1651 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1652 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1653 bool isCallValid = (context->skipValidation() ||
1654 ValidateGetUniformuiv(context, angle::EntryPoint::GLGetUniformuiv,
1655 programPacked, locationPacked, params));
1656 if (isCallValid)
1657 {
1658 context->getUniformuiv(programPacked, locationPacked, params);
1659 }
1660 ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, locationPacked, params);
1661 }
1662 else
1663 {
1664 GenerateContextLostErrorOnCurrentGlobalContext();
1665 }
1666 }
1667
GL_GetVertexAttribIiv(GLuint index,GLenum pname,GLint * params)1668 void GL_APIENTRY GL_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
1669 {
1670 Context *context = GetValidGlobalContext();
1671 EVENT(context, GLGetVertexAttribIiv,
1672 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
1673 GLenumToString(GLenumGroup::VertexAttribEnum, pname), (uintptr_t)params);
1674
1675 if (context)
1676 {
1677 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1678 bool isCallValid =
1679 (context->skipValidation() ||
1680 ValidateGetVertexAttribIiv(context, angle::EntryPoint::GLGetVertexAttribIiv, index,
1681 pname, params));
1682 if (isCallValid)
1683 {
1684 context->getVertexAttribIiv(index, pname, params);
1685 }
1686 ANGLE_CAPTURE(GetVertexAttribIiv, isCallValid, context, index, pname, params);
1687 }
1688 else
1689 {
1690 GenerateContextLostErrorOnCurrentGlobalContext();
1691 }
1692 }
1693
GL_GetVertexAttribIuiv(GLuint index,GLenum pname,GLuint * params)1694 void GL_APIENTRY GL_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
1695 {
1696 Context *context = GetValidGlobalContext();
1697 EVENT(context, GLGetVertexAttribIuiv,
1698 "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
1699 GLenumToString(GLenumGroup::VertexAttribEnum, pname), (uintptr_t)params);
1700
1701 if (context)
1702 {
1703 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1704 bool isCallValid =
1705 (context->skipValidation() ||
1706 ValidateGetVertexAttribIuiv(context, angle::EntryPoint::GLGetVertexAttribIuiv, index,
1707 pname, params));
1708 if (isCallValid)
1709 {
1710 context->getVertexAttribIuiv(index, pname, params);
1711 }
1712 ANGLE_CAPTURE(GetVertexAttribIuiv, isCallValid, context, index, pname, params);
1713 }
1714 else
1715 {
1716 GenerateContextLostErrorOnCurrentGlobalContext();
1717 }
1718 }
1719
GL_InvalidateFramebuffer(GLenum target,GLsizei numAttachments,const GLenum * attachments)1720 void GL_APIENTRY GL_InvalidateFramebuffer(GLenum target,
1721 GLsizei numAttachments,
1722 const GLenum *attachments)
1723 {
1724 Context *context = GetValidGlobalContext();
1725 EVENT(context, GLInvalidateFramebuffer,
1726 "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "",
1727 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments,
1728 (uintptr_t)attachments);
1729
1730 if (context)
1731 {
1732 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1733 bool isCallValid =
1734 (context->skipValidation() ||
1735 ValidateInvalidateFramebuffer(context, angle::EntryPoint::GLInvalidateFramebuffer,
1736 target, numAttachments, attachments));
1737 if (isCallValid)
1738 {
1739 context->invalidateFramebuffer(target, numAttachments, attachments);
1740 }
1741 ANGLE_CAPTURE(InvalidateFramebuffer, isCallValid, context, target, numAttachments,
1742 attachments);
1743 }
1744 else
1745 {
1746 GenerateContextLostErrorOnCurrentGlobalContext();
1747 }
1748 }
1749
GL_InvalidateSubFramebuffer(GLenum target,GLsizei numAttachments,const GLenum * attachments,GLint x,GLint y,GLsizei width,GLsizei height)1750 void GL_APIENTRY GL_InvalidateSubFramebuffer(GLenum target,
1751 GLsizei numAttachments,
1752 const GLenum *attachments,
1753 GLint x,
1754 GLint y,
1755 GLsizei width,
1756 GLsizei height)
1757 {
1758 Context *context = GetValidGlobalContext();
1759 EVENT(context, GLInvalidateSubFramebuffer,
1760 "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR
1761 ", x = %d, y = %d, width = %d, height = %d",
1762 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), numAttachments,
1763 (uintptr_t)attachments, x, y, width, height);
1764
1765 if (context)
1766 {
1767 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1768 bool isCallValid = (context->skipValidation() ||
1769 ValidateInvalidateSubFramebuffer(
1770 context, angle::EntryPoint::GLInvalidateSubFramebuffer, target,
1771 numAttachments, attachments, x, y, width, height));
1772 if (isCallValid)
1773 {
1774 context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
1775 height);
1776 }
1777 ANGLE_CAPTURE(InvalidateSubFramebuffer, isCallValid, context, target, numAttachments,
1778 attachments, x, y, width, height);
1779 }
1780 else
1781 {
1782 GenerateContextLostErrorOnCurrentGlobalContext();
1783 }
1784 }
1785
GL_IsQuery(GLuint id)1786 GLboolean GL_APIENTRY GL_IsQuery(GLuint id)
1787 {
1788 Context *context = GetValidGlobalContext();
1789 EVENT(context, GLIsQuery, "context = %d, id = %u", CID(context), id);
1790
1791 GLboolean returnValue;
1792 if (context)
1793 {
1794 QueryID idPacked = PackParam<QueryID>(id);
1795 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1796 bool isCallValid = (context->skipValidation() ||
1797 ValidateIsQuery(context, angle::EntryPoint::GLIsQuery, idPacked));
1798 if (isCallValid)
1799 {
1800 returnValue = context->isQuery(idPacked);
1801 }
1802 else
1803 {
1804 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQuery, GLboolean>();
1805 }
1806 ANGLE_CAPTURE(IsQuery, isCallValid, context, idPacked, returnValue);
1807 }
1808 else
1809 {
1810 GenerateContextLostErrorOnCurrentGlobalContext();
1811 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQuery, GLboolean>();
1812 }
1813 return returnValue;
1814 }
1815
GL_IsSampler(GLuint sampler)1816 GLboolean GL_APIENTRY GL_IsSampler(GLuint sampler)
1817 {
1818 Context *context = GetValidGlobalContext();
1819 EVENT(context, GLIsSampler, "context = %d, sampler = %u", CID(context), sampler);
1820
1821 GLboolean returnValue;
1822 if (context)
1823 {
1824 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
1825 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1826 bool isCallValid =
1827 (context->skipValidation() ||
1828 ValidateIsSampler(context, angle::EntryPoint::GLIsSampler, samplerPacked));
1829 if (isCallValid)
1830 {
1831 returnValue = context->isSampler(samplerPacked);
1832 }
1833 else
1834 {
1835 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSampler, GLboolean>();
1836 }
1837 ANGLE_CAPTURE(IsSampler, isCallValid, context, samplerPacked, returnValue);
1838 }
1839 else
1840 {
1841 GenerateContextLostErrorOnCurrentGlobalContext();
1842 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSampler, GLboolean>();
1843 }
1844 return returnValue;
1845 }
1846
GL_IsSync(GLsync sync)1847 GLboolean GL_APIENTRY GL_IsSync(GLsync sync)
1848 {
1849 Context *context = GetValidGlobalContext();
1850 EVENT(context, GLIsSync, "context = %d, sync = 0x%016" PRIxPTR "", CID(context),
1851 (uintptr_t)sync);
1852
1853 GLboolean returnValue;
1854 if (context)
1855 {
1856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1857 bool isCallValid = (context->skipValidation() ||
1858 ValidateIsSync(context, angle::EntryPoint::GLIsSync, sync));
1859 if (isCallValid)
1860 {
1861 returnValue = context->isSync(sync);
1862 }
1863 else
1864 {
1865 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSync, GLboolean>();
1866 }
1867 ANGLE_CAPTURE(IsSync, isCallValid, context, sync, returnValue);
1868 }
1869 else
1870 {
1871 GenerateContextLostErrorOnCurrentGlobalContext();
1872 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSync, GLboolean>();
1873 }
1874 return returnValue;
1875 }
1876
GL_IsTransformFeedback(GLuint id)1877 GLboolean GL_APIENTRY GL_IsTransformFeedback(GLuint id)
1878 {
1879 Context *context = GetValidGlobalContext();
1880 EVENT(context, GLIsTransformFeedback, "context = %d, id = %u", CID(context), id);
1881
1882 GLboolean returnValue;
1883 if (context)
1884 {
1885 TransformFeedbackID idPacked = PackParam<TransformFeedbackID>(id);
1886 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1887 bool isCallValid = (context->skipValidation() ||
1888 ValidateIsTransformFeedback(
1889 context, angle::EntryPoint::GLIsTransformFeedback, idPacked));
1890 if (isCallValid)
1891 {
1892 returnValue = context->isTransformFeedback(idPacked);
1893 }
1894 else
1895 {
1896 returnValue =
1897 GetDefaultReturnValue<angle::EntryPoint::GLIsTransformFeedback, GLboolean>();
1898 }
1899 ANGLE_CAPTURE(IsTransformFeedback, isCallValid, context, idPacked, returnValue);
1900 }
1901 else
1902 {
1903 GenerateContextLostErrorOnCurrentGlobalContext();
1904 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsTransformFeedback, GLboolean>();
1905 }
1906 return returnValue;
1907 }
1908
GL_IsVertexArray(GLuint array)1909 GLboolean GL_APIENTRY GL_IsVertexArray(GLuint array)
1910 {
1911 Context *context = GetValidGlobalContext();
1912 EVENT(context, GLIsVertexArray, "context = %d, array = %u", CID(context), array);
1913
1914 GLboolean returnValue;
1915 if (context)
1916 {
1917 VertexArrayID arrayPacked = PackParam<VertexArrayID>(array);
1918 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1919 bool isCallValid =
1920 (context->skipValidation() ||
1921 ValidateIsVertexArray(context, angle::EntryPoint::GLIsVertexArray, arrayPacked));
1922 if (isCallValid)
1923 {
1924 returnValue = context->isVertexArray(arrayPacked);
1925 }
1926 else
1927 {
1928 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArray, GLboolean>();
1929 }
1930 ANGLE_CAPTURE(IsVertexArray, isCallValid, context, arrayPacked, returnValue);
1931 }
1932 else
1933 {
1934 GenerateContextLostErrorOnCurrentGlobalContext();
1935 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArray, GLboolean>();
1936 }
1937 return returnValue;
1938 }
1939
GL_MapBufferRange(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)1940 void *GL_APIENTRY GL_MapBufferRange(GLenum target,
1941 GLintptr offset,
1942 GLsizeiptr length,
1943 GLbitfield access)
1944 {
1945 Context *context = GetValidGlobalContext();
1946 EVENT(context, GLMapBufferRange,
1947 "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context),
1948 GLenumToString(GLenumGroup::BufferTargetARB, target),
1949 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
1950 GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
1951
1952 void *returnValue;
1953 if (context)
1954 {
1955 BufferBinding targetPacked = PackParam<BufferBinding>(target);
1956 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1957 bool isCallValid = (context->skipValidation() ||
1958 ValidateMapBufferRange(context, angle::EntryPoint::GLMapBufferRange,
1959 targetPacked, offset, length, access));
1960 if (isCallValid)
1961 {
1962 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
1963 }
1964 else
1965 {
1966 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRange, void *>();
1967 }
1968 ANGLE_CAPTURE(MapBufferRange, isCallValid, context, targetPacked, offset, length, access,
1969 returnValue);
1970 }
1971 else
1972 {
1973 GenerateContextLostErrorOnCurrentGlobalContext();
1974 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRange, void *>();
1975 }
1976 return returnValue;
1977 }
1978
GL_PauseTransformFeedback()1979 void GL_APIENTRY GL_PauseTransformFeedback()
1980 {
1981 Context *context = GetValidGlobalContext();
1982 EVENT(context, GLPauseTransformFeedback, "context = %d", CID(context));
1983
1984 if (context)
1985 {
1986 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1987 bool isCallValid =
1988 (context->skipValidation() ||
1989 ValidatePauseTransformFeedback(context, angle::EntryPoint::GLPauseTransformFeedback));
1990 if (isCallValid)
1991 {
1992 context->pauseTransformFeedback();
1993 }
1994 ANGLE_CAPTURE(PauseTransformFeedback, isCallValid, context);
1995 }
1996 else
1997 {
1998 GenerateContextLostErrorOnCurrentGlobalContext();
1999 }
2000 }
2001
GL_ProgramBinary(GLuint program,GLenum binaryFormat,const void * binary,GLsizei length)2002 void GL_APIENTRY GL_ProgramBinary(GLuint program,
2003 GLenum binaryFormat,
2004 const void *binary,
2005 GLsizei length)
2006 {
2007 Context *context = GetValidGlobalContext();
2008 EVENT(context, GLProgramBinary,
2009 "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d",
2010 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat),
2011 (uintptr_t)binary, length);
2012
2013 if (context)
2014 {
2015 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2016 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2017 bool isCallValid = (context->skipValidation() ||
2018 ValidateProgramBinary(context, angle::EntryPoint::GLProgramBinary,
2019 programPacked, binaryFormat, binary, length));
2020 if (isCallValid)
2021 {
2022 context->programBinary(programPacked, binaryFormat, binary, length);
2023 }
2024 ANGLE_CAPTURE(ProgramBinary, isCallValid, context, programPacked, binaryFormat, binary,
2025 length);
2026 }
2027 else
2028 {
2029 GenerateContextLostErrorOnCurrentGlobalContext();
2030 }
2031 }
2032
GL_ProgramParameteri(GLuint program,GLenum pname,GLint value)2033 void GL_APIENTRY GL_ProgramParameteri(GLuint program, GLenum pname, GLint value)
2034 {
2035 Context *context = GetValidGlobalContext();
2036 EVENT(context, GLProgramParameteri, "context = %d, program = %u, pname = %s, value = %d",
2037 CID(context), program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value);
2038
2039 if (context)
2040 {
2041 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2042 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2043 bool isCallValid =
2044 (context->skipValidation() ||
2045 ValidateProgramParameteri(context, angle::EntryPoint::GLProgramParameteri,
2046 programPacked, pname, value));
2047 if (isCallValid)
2048 {
2049 context->programParameteri(programPacked, pname, value);
2050 }
2051 ANGLE_CAPTURE(ProgramParameteri, isCallValid, context, programPacked, pname, value);
2052 }
2053 else
2054 {
2055 GenerateContextLostErrorOnCurrentGlobalContext();
2056 }
2057 }
2058
GL_ReadBuffer(GLenum src)2059 void GL_APIENTRY GL_ReadBuffer(GLenum src)
2060 {
2061 Context *context = GetValidGlobalContext();
2062 EVENT(context, GLReadBuffer, "context = %d, src = %s", CID(context),
2063 GLenumToString(GLenumGroup::ReadBufferMode, src));
2064
2065 if (context)
2066 {
2067 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2068 bool isCallValid = (context->skipValidation() ||
2069 ValidateReadBuffer(context, angle::EntryPoint::GLReadBuffer, src));
2070 if (isCallValid)
2071 {
2072 context->readBuffer(src);
2073 }
2074 ANGLE_CAPTURE(ReadBuffer, isCallValid, context, src);
2075 }
2076 else
2077 {
2078 GenerateContextLostErrorOnCurrentGlobalContext();
2079 }
2080 }
2081
GL_RenderbufferStorageMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)2082 void GL_APIENTRY GL_RenderbufferStorageMultisample(GLenum target,
2083 GLsizei samples,
2084 GLenum internalformat,
2085 GLsizei width,
2086 GLsizei height)
2087 {
2088 Context *context = GetValidGlobalContext();
2089 EVENT(context, GLRenderbufferStorageMultisample,
2090 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
2091 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
2092 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
2093
2094 if (context)
2095 {
2096 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2097 bool isCallValid = (context->skipValidation() ||
2098 ValidateRenderbufferStorageMultisample(
2099 context, angle::EntryPoint::GLRenderbufferStorageMultisample,
2100 target, samples, internalformat, width, height));
2101 if (isCallValid)
2102 {
2103 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
2104 }
2105 ANGLE_CAPTURE(RenderbufferStorageMultisample, isCallValid, context, target, samples,
2106 internalformat, width, height);
2107 }
2108 else
2109 {
2110 GenerateContextLostErrorOnCurrentGlobalContext();
2111 }
2112 }
2113
GL_ResumeTransformFeedback()2114 void GL_APIENTRY GL_ResumeTransformFeedback()
2115 {
2116 Context *context = GetValidGlobalContext();
2117 EVENT(context, GLResumeTransformFeedback, "context = %d", CID(context));
2118
2119 if (context)
2120 {
2121 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2122 bool isCallValid = (context->skipValidation() ||
2123 ValidateResumeTransformFeedback(
2124 context, angle::EntryPoint::GLResumeTransformFeedback));
2125 if (isCallValid)
2126 {
2127 context->resumeTransformFeedback();
2128 }
2129 ANGLE_CAPTURE(ResumeTransformFeedback, isCallValid, context);
2130 }
2131 else
2132 {
2133 GenerateContextLostErrorOnCurrentGlobalContext();
2134 }
2135 }
2136
GL_SamplerParameterf(GLuint sampler,GLenum pname,GLfloat param)2137 void GL_APIENTRY GL_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
2138 {
2139 Context *context = GetValidGlobalContext();
2140 EVENT(context, GLSamplerParameterf, "context = %d, sampler = %u, pname = %s, param = %f",
2141 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param);
2142
2143 if (context)
2144 {
2145 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2146 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2147 bool isCallValid =
2148 (context->skipValidation() ||
2149 ValidateSamplerParameterf(context, angle::EntryPoint::GLSamplerParameterf,
2150 samplerPacked, pname, param));
2151 if (isCallValid)
2152 {
2153 context->samplerParameterf(samplerPacked, pname, param);
2154 }
2155 ANGLE_CAPTURE(SamplerParameterf, isCallValid, context, samplerPacked, pname, param);
2156 }
2157 else
2158 {
2159 GenerateContextLostErrorOnCurrentGlobalContext();
2160 }
2161 }
2162
GL_SamplerParameterfv(GLuint sampler,GLenum pname,const GLfloat * param)2163 void GL_APIENTRY GL_SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
2164 {
2165 Context *context = GetValidGlobalContext();
2166 EVENT(context, GLSamplerParameterfv,
2167 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
2168 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
2169
2170 if (context)
2171 {
2172 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2173 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2174 bool isCallValid =
2175 (context->skipValidation() ||
2176 ValidateSamplerParameterfv(context, angle::EntryPoint::GLSamplerParameterfv,
2177 samplerPacked, pname, param));
2178 if (isCallValid)
2179 {
2180 context->samplerParameterfv(samplerPacked, pname, param);
2181 }
2182 ANGLE_CAPTURE(SamplerParameterfv, isCallValid, context, samplerPacked, pname, param);
2183 }
2184 else
2185 {
2186 GenerateContextLostErrorOnCurrentGlobalContext();
2187 }
2188 }
2189
GL_SamplerParameteri(GLuint sampler,GLenum pname,GLint param)2190 void GL_APIENTRY GL_SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
2191 {
2192 Context *context = GetValidGlobalContext();
2193 EVENT(context, GLSamplerParameteri, "context = %d, sampler = %u, pname = %s, param = %d",
2194 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param);
2195
2196 if (context)
2197 {
2198 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2199 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2200 bool isCallValid =
2201 (context->skipValidation() ||
2202 ValidateSamplerParameteri(context, angle::EntryPoint::GLSamplerParameteri,
2203 samplerPacked, pname, param));
2204 if (isCallValid)
2205 {
2206 context->samplerParameteri(samplerPacked, pname, param);
2207 }
2208 ANGLE_CAPTURE(SamplerParameteri, isCallValid, context, samplerPacked, pname, param);
2209 }
2210 else
2211 {
2212 GenerateContextLostErrorOnCurrentGlobalContext();
2213 }
2214 }
2215
GL_SamplerParameteriv(GLuint sampler,GLenum pname,const GLint * param)2216 void GL_APIENTRY GL_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
2217 {
2218 Context *context = GetValidGlobalContext();
2219 EVENT(context, GLSamplerParameteriv,
2220 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
2221 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
2222
2223 if (context)
2224 {
2225 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2226 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2227 bool isCallValid =
2228 (context->skipValidation() ||
2229 ValidateSamplerParameteriv(context, angle::EntryPoint::GLSamplerParameteriv,
2230 samplerPacked, pname, param));
2231 if (isCallValid)
2232 {
2233 context->samplerParameteriv(samplerPacked, pname, param);
2234 }
2235 ANGLE_CAPTURE(SamplerParameteriv, isCallValid, context, samplerPacked, pname, param);
2236 }
2237 else
2238 {
2239 GenerateContextLostErrorOnCurrentGlobalContext();
2240 }
2241 }
2242
GL_TexImage3D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)2243 void GL_APIENTRY GL_TexImage3D(GLenum target,
2244 GLint level,
2245 GLint internalformat,
2246 GLsizei width,
2247 GLsizei height,
2248 GLsizei depth,
2249 GLint border,
2250 GLenum format,
2251 GLenum type,
2252 const void *pixels)
2253 {
2254 Context *context = GetValidGlobalContext();
2255 EVENT(context, GLTexImage3D,
2256 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
2257 "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
2258 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
2259 width, height, depth, border, GLenumToString(GLenumGroup::PixelFormat, format),
2260 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
2261
2262 if (context)
2263 {
2264 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2265 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2266 bool isCallValid = (context->skipValidation() ||
2267 ValidateTexImage3D(context, angle::EntryPoint::GLTexImage3D,
2268 targetPacked, level, internalformat, width, height,
2269 depth, border, format, type, pixels));
2270 if (isCallValid)
2271 {
2272 context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
2273 format, type, pixels);
2274 }
2275 ANGLE_CAPTURE(TexImage3D, isCallValid, context, targetPacked, level, internalformat, width,
2276 height, depth, border, format, type, pixels);
2277 }
2278 else
2279 {
2280 GenerateContextLostErrorOnCurrentGlobalContext();
2281 }
2282 }
2283
2284 void GL_APIENTRY
GL_TexStorage2D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)2285 GL_TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
2286 {
2287 Context *context = GetValidGlobalContext();
2288 EVENT(context, GLTexStorage2D,
2289 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d",
2290 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
2291 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
2292
2293 if (context)
2294 {
2295 TextureType targetPacked = PackParam<TextureType>(target);
2296 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2297 bool isCallValid =
2298 (context->skipValidation() ||
2299 ValidateTexStorage2D(context, angle::EntryPoint::GLTexStorage2D, targetPacked, levels,
2300 internalformat, width, height));
2301 if (isCallValid)
2302 {
2303 context->texStorage2D(targetPacked, levels, internalformat, width, height);
2304 }
2305 ANGLE_CAPTURE(TexStorage2D, isCallValid, context, targetPacked, levels, internalformat,
2306 width, height);
2307 }
2308 else
2309 {
2310 GenerateContextLostErrorOnCurrentGlobalContext();
2311 }
2312 }
2313
GL_TexStorage3D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)2314 void GL_APIENTRY GL_TexStorage3D(GLenum target,
2315 GLsizei levels,
2316 GLenum internalformat,
2317 GLsizei width,
2318 GLsizei height,
2319 GLsizei depth)
2320 {
2321 Context *context = GetValidGlobalContext();
2322 EVENT(context, GLTexStorage3D,
2323 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, "
2324 "depth = %d",
2325 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
2326 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth);
2327
2328 if (context)
2329 {
2330 TextureType targetPacked = PackParam<TextureType>(target);
2331 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2332 bool isCallValid =
2333 (context->skipValidation() ||
2334 ValidateTexStorage3D(context, angle::EntryPoint::GLTexStorage3D, targetPacked, levels,
2335 internalformat, width, height, depth));
2336 if (isCallValid)
2337 {
2338 context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
2339 }
2340 ANGLE_CAPTURE(TexStorage3D, isCallValid, context, targetPacked, levels, internalformat,
2341 width, height, depth);
2342 }
2343 else
2344 {
2345 GenerateContextLostErrorOnCurrentGlobalContext();
2346 }
2347 }
2348
GL_TexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)2349 void GL_APIENTRY GL_TexSubImage3D(GLenum target,
2350 GLint level,
2351 GLint xoffset,
2352 GLint yoffset,
2353 GLint zoffset,
2354 GLsizei width,
2355 GLsizei height,
2356 GLsizei depth,
2357 GLenum format,
2358 GLenum type,
2359 const void *pixels)
2360 {
2361 Context *context = GetValidGlobalContext();
2362 EVENT(context, GLTexSubImage3D,
2363 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
2364 "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
2365 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
2366 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
2367 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
2368
2369 if (context)
2370 {
2371 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2372 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2373 bool isCallValid = (context->skipValidation() ||
2374 ValidateTexSubImage3D(context, angle::EntryPoint::GLTexSubImage3D,
2375 targetPacked, level, xoffset, yoffset, zoffset,
2376 width, height, depth, format, type, pixels));
2377 if (isCallValid)
2378 {
2379 context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
2380 depth, format, type, pixels);
2381 }
2382 ANGLE_CAPTURE(TexSubImage3D, isCallValid, context, targetPacked, level, xoffset, yoffset,
2383 zoffset, width, height, depth, format, type, pixels);
2384 }
2385 else
2386 {
2387 GenerateContextLostErrorOnCurrentGlobalContext();
2388 }
2389 }
2390
GL_TransformFeedbackVaryings(GLuint program,GLsizei count,const GLchar * const * varyings,GLenum bufferMode)2391 void GL_APIENTRY GL_TransformFeedbackVaryings(GLuint program,
2392 GLsizei count,
2393 const GLchar *const *varyings,
2394 GLenum bufferMode)
2395 {
2396 Context *context = GetValidGlobalContext();
2397 EVENT(context, GLTransformFeedbackVaryings,
2398 "context = %d, program = %u, count = %d, varyings = 0x%016" PRIxPTR ", bufferMode = %s",
2399 CID(context), program, count, (uintptr_t)varyings,
2400 GLenumToString(GLenumGroup::DefaultGroup, bufferMode));
2401
2402 if (context)
2403 {
2404 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2405 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2406 bool isCallValid = (context->skipValidation() ||
2407 ValidateTransformFeedbackVaryings(
2408 context, angle::EntryPoint::GLTransformFeedbackVaryings,
2409 programPacked, count, varyings, bufferMode));
2410 if (isCallValid)
2411 {
2412 context->transformFeedbackVaryings(programPacked, count, varyings, bufferMode);
2413 }
2414 ANGLE_CAPTURE(TransformFeedbackVaryings, isCallValid, context, programPacked, count,
2415 varyings, bufferMode);
2416 }
2417 else
2418 {
2419 GenerateContextLostErrorOnCurrentGlobalContext();
2420 }
2421 }
2422
GL_Uniform1ui(GLint location,GLuint v0)2423 void GL_APIENTRY GL_Uniform1ui(GLint location, GLuint v0)
2424 {
2425 Context *context = GetValidGlobalContext();
2426 EVENT(context, GLUniform1ui, "context = %d, location = %d, v0 = %u", CID(context), location,
2427 v0);
2428
2429 if (context)
2430 {
2431 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2432 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2433 bool isCallValid =
2434 (context->skipValidation() ||
2435 ValidateUniform1ui(context, angle::EntryPoint::GLUniform1ui, locationPacked, v0));
2436 if (isCallValid)
2437 {
2438 context->uniform1ui(locationPacked, v0);
2439 }
2440 ANGLE_CAPTURE(Uniform1ui, isCallValid, context, locationPacked, v0);
2441 }
2442 else
2443 {
2444 GenerateContextLostErrorOnCurrentGlobalContext();
2445 }
2446 }
2447
GL_Uniform1uiv(GLint location,GLsizei count,const GLuint * value)2448 void GL_APIENTRY GL_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
2449 {
2450 Context *context = GetValidGlobalContext();
2451 EVENT(context, GLUniform1uiv,
2452 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
2453 location, count, (uintptr_t)value);
2454
2455 if (context)
2456 {
2457 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2458 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2459 bool isCallValid = (context->skipValidation() ||
2460 ValidateUniform1uiv(context, angle::EntryPoint::GLUniform1uiv,
2461 locationPacked, count, value));
2462 if (isCallValid)
2463 {
2464 context->uniform1uiv(locationPacked, count, value);
2465 }
2466 ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, locationPacked, count, value);
2467 }
2468 else
2469 {
2470 GenerateContextLostErrorOnCurrentGlobalContext();
2471 }
2472 }
2473
GL_Uniform2ui(GLint location,GLuint v0,GLuint v1)2474 void GL_APIENTRY GL_Uniform2ui(GLint location, GLuint v0, GLuint v1)
2475 {
2476 Context *context = GetValidGlobalContext();
2477 EVENT(context, GLUniform2ui, "context = %d, location = %d, v0 = %u, v1 = %u", CID(context),
2478 location, v0, v1);
2479
2480 if (context)
2481 {
2482 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2483 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2484 bool isCallValid =
2485 (context->skipValidation() ||
2486 ValidateUniform2ui(context, angle::EntryPoint::GLUniform2ui, locationPacked, v0, v1));
2487 if (isCallValid)
2488 {
2489 context->uniform2ui(locationPacked, v0, v1);
2490 }
2491 ANGLE_CAPTURE(Uniform2ui, isCallValid, context, locationPacked, v0, v1);
2492 }
2493 else
2494 {
2495 GenerateContextLostErrorOnCurrentGlobalContext();
2496 }
2497 }
2498
GL_Uniform2uiv(GLint location,GLsizei count,const GLuint * value)2499 void GL_APIENTRY GL_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
2500 {
2501 Context *context = GetValidGlobalContext();
2502 EVENT(context, GLUniform2uiv,
2503 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
2504 location, count, (uintptr_t)value);
2505
2506 if (context)
2507 {
2508 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2509 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2510 bool isCallValid = (context->skipValidation() ||
2511 ValidateUniform2uiv(context, angle::EntryPoint::GLUniform2uiv,
2512 locationPacked, count, value));
2513 if (isCallValid)
2514 {
2515 context->uniform2uiv(locationPacked, count, value);
2516 }
2517 ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, locationPacked, count, value);
2518 }
2519 else
2520 {
2521 GenerateContextLostErrorOnCurrentGlobalContext();
2522 }
2523 }
2524
GL_Uniform3ui(GLint location,GLuint v0,GLuint v1,GLuint v2)2525 void GL_APIENTRY GL_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
2526 {
2527 Context *context = GetValidGlobalContext();
2528 EVENT(context, GLUniform3ui, "context = %d, location = %d, v0 = %u, v1 = %u, v2 = %u",
2529 CID(context), location, v0, v1, v2);
2530
2531 if (context)
2532 {
2533 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2534 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2535 bool isCallValid = (context->skipValidation() ||
2536 ValidateUniform3ui(context, angle::EntryPoint::GLUniform3ui,
2537 locationPacked, v0, v1, v2));
2538 if (isCallValid)
2539 {
2540 context->uniform3ui(locationPacked, v0, v1, v2);
2541 }
2542 ANGLE_CAPTURE(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2);
2543 }
2544 else
2545 {
2546 GenerateContextLostErrorOnCurrentGlobalContext();
2547 }
2548 }
2549
GL_Uniform3uiv(GLint location,GLsizei count,const GLuint * value)2550 void GL_APIENTRY GL_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
2551 {
2552 Context *context = GetValidGlobalContext();
2553 EVENT(context, GLUniform3uiv,
2554 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
2555 location, count, (uintptr_t)value);
2556
2557 if (context)
2558 {
2559 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2560 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2561 bool isCallValid = (context->skipValidation() ||
2562 ValidateUniform3uiv(context, angle::EntryPoint::GLUniform3uiv,
2563 locationPacked, count, value));
2564 if (isCallValid)
2565 {
2566 context->uniform3uiv(locationPacked, count, value);
2567 }
2568 ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, locationPacked, count, value);
2569 }
2570 else
2571 {
2572 GenerateContextLostErrorOnCurrentGlobalContext();
2573 }
2574 }
2575
GL_Uniform4ui(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)2576 void GL_APIENTRY GL_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
2577 {
2578 Context *context = GetValidGlobalContext();
2579 EVENT(context, GLUniform4ui, "context = %d, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u",
2580 CID(context), location, v0, v1, v2, v3);
2581
2582 if (context)
2583 {
2584 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2585 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2586 bool isCallValid = (context->skipValidation() ||
2587 ValidateUniform4ui(context, angle::EntryPoint::GLUniform4ui,
2588 locationPacked, v0, v1, v2, v3));
2589 if (isCallValid)
2590 {
2591 context->uniform4ui(locationPacked, v0, v1, v2, v3);
2592 }
2593 ANGLE_CAPTURE(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3);
2594 }
2595 else
2596 {
2597 GenerateContextLostErrorOnCurrentGlobalContext();
2598 }
2599 }
2600
GL_Uniform4uiv(GLint location,GLsizei count,const GLuint * value)2601 void GL_APIENTRY GL_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
2602 {
2603 Context *context = GetValidGlobalContext();
2604 EVENT(context, GLUniform4uiv,
2605 "context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
2606 location, count, (uintptr_t)value);
2607
2608 if (context)
2609 {
2610 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2611 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2612 bool isCallValid = (context->skipValidation() ||
2613 ValidateUniform4uiv(context, angle::EntryPoint::GLUniform4uiv,
2614 locationPacked, count, value));
2615 if (isCallValid)
2616 {
2617 context->uniform4uiv(locationPacked, count, value);
2618 }
2619 ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, locationPacked, count, value);
2620 }
2621 else
2622 {
2623 GenerateContextLostErrorOnCurrentGlobalContext();
2624 }
2625 }
2626
GL_UniformBlockBinding(GLuint program,GLuint uniformBlockIndex,GLuint uniformBlockBinding)2627 void GL_APIENTRY GL_UniformBlockBinding(GLuint program,
2628 GLuint uniformBlockIndex,
2629 GLuint uniformBlockBinding)
2630 {
2631 Context *context = GetValidGlobalContext();
2632 EVENT(context, GLUniformBlockBinding,
2633 "context = %d, program = %u, uniformBlockIndex = %u, uniformBlockBinding = %u",
2634 CID(context), program, uniformBlockIndex, uniformBlockBinding);
2635
2636 if (context)
2637 {
2638 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2639 UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex);
2640 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2641 bool isCallValid = (context->skipValidation() ||
2642 ValidateUniformBlockBinding(
2643 context, angle::EntryPoint::GLUniformBlockBinding, programPacked,
2644 uniformBlockIndexPacked, uniformBlockBinding));
2645 if (isCallValid)
2646 {
2647 context->uniformBlockBinding(programPacked, uniformBlockIndexPacked,
2648 uniformBlockBinding);
2649 }
2650 ANGLE_CAPTURE(UniformBlockBinding, isCallValid, context, programPacked,
2651 uniformBlockIndexPacked, uniformBlockBinding);
2652 }
2653 else
2654 {
2655 GenerateContextLostErrorOnCurrentGlobalContext();
2656 }
2657 }
2658
GL_UniformMatrix2x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2659 void GL_APIENTRY GL_UniformMatrix2x3fv(GLint location,
2660 GLsizei count,
2661 GLboolean transpose,
2662 const GLfloat *value)
2663 {
2664 Context *context = GetValidGlobalContext();
2665 EVENT(context, GLUniformMatrix2x3fv,
2666 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2667 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2668
2669 if (context)
2670 {
2671 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2672 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2673 bool isCallValid =
2674 (context->skipValidation() ||
2675 ValidateUniformMatrix2x3fv(context, angle::EntryPoint::GLUniformMatrix2x3fv,
2676 locationPacked, count, transpose, value));
2677 if (isCallValid)
2678 {
2679 context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
2680 }
2681 ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
2682 value);
2683 }
2684 else
2685 {
2686 GenerateContextLostErrorOnCurrentGlobalContext();
2687 }
2688 }
2689
GL_UniformMatrix2x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2690 void GL_APIENTRY GL_UniformMatrix2x4fv(GLint location,
2691 GLsizei count,
2692 GLboolean transpose,
2693 const GLfloat *value)
2694 {
2695 Context *context = GetValidGlobalContext();
2696 EVENT(context, GLUniformMatrix2x4fv,
2697 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2698 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2699
2700 if (context)
2701 {
2702 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2703 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2704 bool isCallValid =
2705 (context->skipValidation() ||
2706 ValidateUniformMatrix2x4fv(context, angle::EntryPoint::GLUniformMatrix2x4fv,
2707 locationPacked, count, transpose, value));
2708 if (isCallValid)
2709 {
2710 context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
2711 }
2712 ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
2713 value);
2714 }
2715 else
2716 {
2717 GenerateContextLostErrorOnCurrentGlobalContext();
2718 }
2719 }
2720
GL_UniformMatrix3x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2721 void GL_APIENTRY GL_UniformMatrix3x2fv(GLint location,
2722 GLsizei count,
2723 GLboolean transpose,
2724 const GLfloat *value)
2725 {
2726 Context *context = GetValidGlobalContext();
2727 EVENT(context, GLUniformMatrix3x2fv,
2728 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2729 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2730
2731 if (context)
2732 {
2733 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2734 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2735 bool isCallValid =
2736 (context->skipValidation() ||
2737 ValidateUniformMatrix3x2fv(context, angle::EntryPoint::GLUniformMatrix3x2fv,
2738 locationPacked, count, transpose, value));
2739 if (isCallValid)
2740 {
2741 context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
2742 }
2743 ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
2744 value);
2745 }
2746 else
2747 {
2748 GenerateContextLostErrorOnCurrentGlobalContext();
2749 }
2750 }
2751
GL_UniformMatrix3x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2752 void GL_APIENTRY GL_UniformMatrix3x4fv(GLint location,
2753 GLsizei count,
2754 GLboolean transpose,
2755 const GLfloat *value)
2756 {
2757 Context *context = GetValidGlobalContext();
2758 EVENT(context, GLUniformMatrix3x4fv,
2759 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2760 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2761
2762 if (context)
2763 {
2764 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2765 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2766 bool isCallValid =
2767 (context->skipValidation() ||
2768 ValidateUniformMatrix3x4fv(context, angle::EntryPoint::GLUniformMatrix3x4fv,
2769 locationPacked, count, transpose, value));
2770 if (isCallValid)
2771 {
2772 context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
2773 }
2774 ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
2775 value);
2776 }
2777 else
2778 {
2779 GenerateContextLostErrorOnCurrentGlobalContext();
2780 }
2781 }
2782
GL_UniformMatrix4x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2783 void GL_APIENTRY GL_UniformMatrix4x2fv(GLint location,
2784 GLsizei count,
2785 GLboolean transpose,
2786 const GLfloat *value)
2787 {
2788 Context *context = GetValidGlobalContext();
2789 EVENT(context, GLUniformMatrix4x2fv,
2790 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2791 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2792
2793 if (context)
2794 {
2795 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2796 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2797 bool isCallValid =
2798 (context->skipValidation() ||
2799 ValidateUniformMatrix4x2fv(context, angle::EntryPoint::GLUniformMatrix4x2fv,
2800 locationPacked, count, transpose, value));
2801 if (isCallValid)
2802 {
2803 context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
2804 }
2805 ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
2806 value);
2807 }
2808 else
2809 {
2810 GenerateContextLostErrorOnCurrentGlobalContext();
2811 }
2812 }
2813
GL_UniformMatrix4x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)2814 void GL_APIENTRY GL_UniformMatrix4x3fv(GLint location,
2815 GLsizei count,
2816 GLboolean transpose,
2817 const GLfloat *value)
2818 {
2819 Context *context = GetValidGlobalContext();
2820 EVENT(context, GLUniformMatrix4x3fv,
2821 "context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
2822 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
2823
2824 if (context)
2825 {
2826 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2827 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2828 bool isCallValid =
2829 (context->skipValidation() ||
2830 ValidateUniformMatrix4x3fv(context, angle::EntryPoint::GLUniformMatrix4x3fv,
2831 locationPacked, count, transpose, value));
2832 if (isCallValid)
2833 {
2834 context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
2835 }
2836 ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
2837 value);
2838 }
2839 else
2840 {
2841 GenerateContextLostErrorOnCurrentGlobalContext();
2842 }
2843 }
2844
GL_UnmapBuffer(GLenum target)2845 GLboolean GL_APIENTRY GL_UnmapBuffer(GLenum target)
2846 {
2847 Context *context = GetValidGlobalContext();
2848 EVENT(context, GLUnmapBuffer, "context = %d, target = %s", CID(context),
2849 GLenumToString(GLenumGroup::BufferTargetARB, target));
2850
2851 GLboolean returnValue;
2852 if (context)
2853 {
2854 BufferBinding targetPacked = PackParam<BufferBinding>(target);
2855 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2856 bool isCallValid =
2857 (context->skipValidation() ||
2858 ValidateUnmapBuffer(context, angle::EntryPoint::GLUnmapBuffer, targetPacked));
2859 if (isCallValid)
2860 {
2861 returnValue = context->unmapBuffer(targetPacked);
2862 }
2863 else
2864 {
2865 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBuffer, GLboolean>();
2866 }
2867 ANGLE_CAPTURE(UnmapBuffer, isCallValid, context, targetPacked, returnValue);
2868 }
2869 else
2870 {
2871 GenerateContextLostErrorOnCurrentGlobalContext();
2872 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBuffer, GLboolean>();
2873 }
2874 return returnValue;
2875 }
2876
GL_VertexAttribDivisor(GLuint index,GLuint divisor)2877 void GL_APIENTRY GL_VertexAttribDivisor(GLuint index, GLuint divisor)
2878 {
2879 Context *context = GetValidGlobalContext();
2880 EVENT(context, GLVertexAttribDivisor, "context = %d, index = %u, divisor = %u", CID(context),
2881 index, divisor);
2882
2883 if (context)
2884 {
2885 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2886 bool isCallValid = (context->skipValidation() ||
2887 ValidateVertexAttribDivisor(
2888 context, angle::EntryPoint::GLVertexAttribDivisor, index, divisor));
2889 if (isCallValid)
2890 {
2891 context->vertexAttribDivisor(index, divisor);
2892 }
2893 ANGLE_CAPTURE(VertexAttribDivisor, isCallValid, context, index, divisor);
2894 }
2895 else
2896 {
2897 GenerateContextLostErrorOnCurrentGlobalContext();
2898 }
2899 }
2900
GL_VertexAttribI4i(GLuint index,GLint x,GLint y,GLint z,GLint w)2901 void GL_APIENTRY GL_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
2902 {
2903 Context *context = GetValidGlobalContext();
2904 EVENT(context, GLVertexAttribI4i, "context = %d, index = %u, x = %d, y = %d, z = %d, w = %d",
2905 CID(context), index, x, y, z, w);
2906
2907 if (context)
2908 {
2909 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2910 bool isCallValid = (context->skipValidation() ||
2911 ValidateVertexAttribI4i(context, angle::EntryPoint::GLVertexAttribI4i,
2912 index, x, y, z, w));
2913 if (isCallValid)
2914 {
2915 context->vertexAttribI4i(index, x, y, z, w);
2916 }
2917 ANGLE_CAPTURE(VertexAttribI4i, isCallValid, context, index, x, y, z, w);
2918 }
2919 else
2920 {
2921 GenerateContextLostErrorOnCurrentGlobalContext();
2922 }
2923 }
2924
GL_VertexAttribI4iv(GLuint index,const GLint * v)2925 void GL_APIENTRY GL_VertexAttribI4iv(GLuint index, const GLint *v)
2926 {
2927 Context *context = GetValidGlobalContext();
2928 EVENT(context, GLVertexAttribI4iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2929 CID(context), index, (uintptr_t)v);
2930
2931 if (context)
2932 {
2933 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2934 bool isCallValid =
2935 (context->skipValidation() ||
2936 ValidateVertexAttribI4iv(context, angle::EntryPoint::GLVertexAttribI4iv, index, v));
2937 if (isCallValid)
2938 {
2939 context->vertexAttribI4iv(index, v);
2940 }
2941 ANGLE_CAPTURE(VertexAttribI4iv, isCallValid, context, index, v);
2942 }
2943 else
2944 {
2945 GenerateContextLostErrorOnCurrentGlobalContext();
2946 }
2947 }
2948
GL_VertexAttribI4ui(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)2949 void GL_APIENTRY GL_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
2950 {
2951 Context *context = GetValidGlobalContext();
2952 EVENT(context, GLVertexAttribI4ui, "context = %d, index = %u, x = %u, y = %u, z = %u, w = %u",
2953 CID(context), index, x, y, z, w);
2954
2955 if (context)
2956 {
2957 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2958 bool isCallValid = (context->skipValidation() ||
2959 ValidateVertexAttribI4ui(context, angle::EntryPoint::GLVertexAttribI4ui,
2960 index, x, y, z, w));
2961 if (isCallValid)
2962 {
2963 context->vertexAttribI4ui(index, x, y, z, w);
2964 }
2965 ANGLE_CAPTURE(VertexAttribI4ui, isCallValid, context, index, x, y, z, w);
2966 }
2967 else
2968 {
2969 GenerateContextLostErrorOnCurrentGlobalContext();
2970 }
2971 }
2972
GL_VertexAttribI4uiv(GLuint index,const GLuint * v)2973 void GL_APIENTRY GL_VertexAttribI4uiv(GLuint index, const GLuint *v)
2974 {
2975 Context *context = GetValidGlobalContext();
2976 EVENT(context, GLVertexAttribI4uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
2977 CID(context), index, (uintptr_t)v);
2978
2979 if (context)
2980 {
2981 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2982 bool isCallValid =
2983 (context->skipValidation() ||
2984 ValidateVertexAttribI4uiv(context, angle::EntryPoint::GLVertexAttribI4uiv, index, v));
2985 if (isCallValid)
2986 {
2987 context->vertexAttribI4uiv(index, v);
2988 }
2989 ANGLE_CAPTURE(VertexAttribI4uiv, isCallValid, context, index, v);
2990 }
2991 else
2992 {
2993 GenerateContextLostErrorOnCurrentGlobalContext();
2994 }
2995 }
2996
2997 void GL_APIENTRY
GL_VertexAttribIPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const void * pointer)2998 GL_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
2999 {
3000 Context *context = GetValidGlobalContext();
3001 EVENT(context, GLVertexAttribIPointer,
3002 "context = %d, index = %u, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR
3003 "",
3004 CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
3005 stride, (uintptr_t)pointer);
3006
3007 if (context)
3008 {
3009 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
3010 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3011 bool isCallValid =
3012 (context->skipValidation() ||
3013 ValidateVertexAttribIPointer(context, angle::EntryPoint::GLVertexAttribIPointer, index,
3014 size, typePacked, stride, pointer));
3015 if (isCallValid)
3016 {
3017 context->vertexAttribIPointer(index, size, typePacked, stride, pointer);
3018 }
3019 ANGLE_CAPTURE(VertexAttribIPointer, isCallValid, context, index, size, typePacked, stride,
3020 pointer);
3021 }
3022 else
3023 {
3024 GenerateContextLostErrorOnCurrentGlobalContext();
3025 }
3026 }
3027
GL_WaitSync(GLsync sync,GLbitfield flags,GLuint64 timeout)3028 void GL_APIENTRY GL_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3029 {
3030 Context *context = GetValidGlobalContext();
3031 EVENT(context, GLWaitSync, "context = %d, sync = 0x%016" PRIxPTR ", flags = %s, timeout = %llu",
3032 CID(context), (uintptr_t)sync,
3033 GLbitfieldToString(GLenumGroup::DefaultGroup, flags).c_str(),
3034 static_cast<unsigned long long>(timeout));
3035
3036 if (context)
3037 {
3038 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3039 bool isCallValid =
3040 (context->skipValidation() ||
3041 ValidateWaitSync(context, angle::EntryPoint::GLWaitSync, sync, flags, timeout));
3042 if (isCallValid)
3043 {
3044 context->waitSync(sync, flags, timeout);
3045 }
3046 ANGLE_CAPTURE(WaitSync, isCallValid, context, sync, flags, timeout);
3047 }
3048 else
3049 {
3050 GenerateContextLostErrorOnCurrentGlobalContext();
3051 }
3052 }
3053
3054 } // extern "C"
3055