1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.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_ext_autogen.cpp:
9 // Defines the GLES extension entry points.
10
11 #include "libGLESv2/entry_points_gles_ext_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/capture_gles_ext_autogen.h"
16 #include "libANGLE/entry_points_utils.h"
17 #include "libANGLE/gl_enum_utils.h"
18 #include "libANGLE/validationESEXT.h"
19 #include "libGLESv2/global_state.h"
20
21 #include "libANGLE/capture_gles_1_0_autogen.h"
22 #include "libANGLE/capture_gles_2_0_autogen.h"
23 #include "libANGLE/capture_gles_3_0_autogen.h"
24 #include "libANGLE/capture_gles_3_1_autogen.h"
25 #include "libANGLE/capture_gles_3_2_autogen.h"
26 #include "libANGLE/validationES1.h"
27 #include "libANGLE/validationES2.h"
28 #include "libANGLE/validationES3.h"
29 #include "libANGLE/validationES31.h"
30 #include "libANGLE/validationES32.h"
31
32 namespace gl
33 {
34
35 // GL_ANGLE_base_vertex_base_instance
DrawArraysInstancedBaseInstanceANGLE(GLenum mode,GLint first,GLsizei count,GLsizei instanceCount,GLuint baseInstance)36 void GL_APIENTRY DrawArraysInstancedBaseInstanceANGLE(GLenum mode,
37 GLint first,
38 GLsizei count,
39 GLsizei instanceCount,
40 GLuint baseInstance)
41 {
42 Context *context = GetValidGlobalContext();
43 EVENT("glDrawArraysInstancedBaseInstanceANGLE",
44 "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei "
45 "instanceCount = %d, GLuint baseInstance = %u",
46 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count,
47 instanceCount, baseInstance);
48
49 if (context)
50 {
51 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
52 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
53 bool isCallValid = (context->skipValidation() ||
54 ValidateDrawArraysInstancedBaseInstanceANGLE(
55 context, modePacked, first, count, instanceCount, baseInstance));
56 if (isCallValid)
57 {
58 context->drawArraysInstancedBaseInstance(modePacked, first, count, instanceCount,
59 baseInstance);
60 }
61 ANGLE_CAPTURE(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, first,
62 count, instanceCount, baseInstance);
63 }
64 }
65
DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,GLsizei count,GLenum type,const GLvoid * indices,GLsizei instanceCounts,GLint baseVertex,GLuint baseInstance)66 void GL_APIENTRY DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
67 GLsizei count,
68 GLenum type,
69 const GLvoid *indices,
70 GLsizei instanceCounts,
71 GLint baseVertex,
72 GLuint baseInstance)
73 {
74 Context *context = GetValidGlobalContext();
75 EVENT("glDrawElementsInstancedBaseVertexBaseInstanceANGLE",
76 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const GLvoid "
77 "*indices = 0x%016" PRIxPTR
78 ", GLsizei instanceCounts = %d, GLint baseVertex = %d, GLuint baseInstance = %u",
79 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
80 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instanceCounts,
81 baseVertex, baseInstance);
82
83 if (context)
84 {
85 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
86 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
87 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
88 bool isCallValid =
89 (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE(
90 context, modePacked, count, typePacked, indices,
91 instanceCounts, baseVertex, baseInstance));
92 if (isCallValid)
93 {
94 context->drawElementsInstancedBaseVertexBaseInstance(
95 modePacked, count, typePacked, indices, instanceCounts, baseVertex, baseInstance);
96 }
97 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
98 modePacked, count, typePacked, indices, instanceCounts, baseVertex,
99 baseInstance);
100 }
101 }
102
MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)103 void GL_APIENTRY MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
104 const GLint *firsts,
105 const GLsizei *counts,
106 const GLsizei *instanceCounts,
107 const GLuint *baseInstances,
108 GLsizei drawcount)
109 {
110 Context *context = GetValidGlobalContext();
111 EVENT("glMultiDrawArraysInstancedBaseInstanceANGLE",
112 "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR
113 ", const GLsizei *counts = 0x%016" PRIxPTR
114 ", const GLsizei *instanceCounts = 0x%016" PRIxPTR
115 ", const GLuint *baseInstances = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
116 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
117 (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount);
118
119 if (context)
120 {
121 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
122 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
123 bool isCallValid =
124 (context->skipValidation() ||
125 ValidateMultiDrawArraysInstancedBaseInstanceANGLE(
126 context, modePacked, firsts, counts, instanceCounts, baseInstances, drawcount));
127 if (isCallValid)
128 {
129 context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts,
130 instanceCounts, baseInstances, drawcount);
131 }
132 ANGLE_CAPTURE(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked,
133 firsts, counts, instanceCounts, baseInstances, drawcount);
134 }
135 }
136
137 void GL_APIENTRY
MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,const GLsizei * instanceCounts,const GLint * baseVertices,const GLuint * baseInstances,GLsizei drawcount)138 MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
139 const GLsizei *counts,
140 GLenum type,
141 const GLvoid *const *indices,
142 const GLsizei *instanceCounts,
143 const GLint *baseVertices,
144 const GLuint *baseInstances,
145 GLsizei drawcount)
146 {
147 Context *context = GetValidGlobalContext();
148 EVENT("glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE",
149 "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR
150 ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR
151 ", const GLsizei *instanceCounts = 0x%016" PRIxPTR
152 ", const GLint *baseVertices = 0x%016" PRIxPTR
153 ", const GLuint *baseInstances = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
154 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
155 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
156 (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount);
157
158 if (context)
159 {
160 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
161 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
162 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
163 bool isCallValid = (context->skipValidation() ||
164 ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
165 context, modePacked, counts, typePacked, indices, instanceCounts,
166 baseVertices, baseInstances, drawcount));
167 if (isCallValid)
168 {
169 context->multiDrawElementsInstancedBaseVertexBaseInstance(
170 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
171 baseInstances, drawcount);
172 }
173 ANGLE_CAPTURE(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
174 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
175 baseInstances, drawcount);
176 }
177 }
178
179 // GL_ANGLE_copy_texture_3d
CopyTexture3DANGLE(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)180 void GL_APIENTRY CopyTexture3DANGLE(GLuint sourceId,
181 GLint sourceLevel,
182 GLenum destTarget,
183 GLuint destId,
184 GLint destLevel,
185 GLint internalFormat,
186 GLenum destType,
187 GLboolean unpackFlipY,
188 GLboolean unpackPremultiplyAlpha,
189 GLboolean unpackUnmultiplyAlpha)
190 {
191 Context *context = GetValidGlobalContext();
192 EVENT("glCopyTexture3DANGLE",
193 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
194 "GLuint destId = %u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = "
195 "%s, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = %s, GLboolean "
196 "unpackUnmultiplyAlpha = %s",
197 CID(context), sourceId, sourceLevel,
198 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
199 GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
200 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
201
202 if (context)
203 {
204 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
205 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
206 TextureID destIdPacked = FromGL<TextureID>(destId);
207 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
208 bool isCallValid = (context->skipValidation() ||
209 ValidateCopyTexture3DANGLE(
210 context, sourceIdPacked, sourceLevel, destTargetPacked,
211 destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
212 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
213 if (isCallValid)
214 {
215 context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
216 destLevel, internalFormat, destType, unpackFlipY,
217 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
218 }
219 ANGLE_CAPTURE(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
220 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
221 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
222 }
223 }
224
CopySubTexture3DANGLE(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLint z,GLint width,GLint height,GLint depth,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)225 void GL_APIENTRY CopySubTexture3DANGLE(GLuint sourceId,
226 GLint sourceLevel,
227 GLenum destTarget,
228 GLuint destId,
229 GLint destLevel,
230 GLint xoffset,
231 GLint yoffset,
232 GLint zoffset,
233 GLint x,
234 GLint y,
235 GLint z,
236 GLint width,
237 GLint height,
238 GLint depth,
239 GLboolean unpackFlipY,
240 GLboolean unpackPremultiplyAlpha,
241 GLboolean unpackUnmultiplyAlpha)
242 {
243 Context *context = GetValidGlobalContext();
244 EVENT("glCopySubTexture3DANGLE",
245 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
246 "GLuint destId = %u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
247 "zoffset = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height "
248 "= %d, GLint depth = %d, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = "
249 "%s, GLboolean unpackUnmultiplyAlpha = %s",
250 CID(context), sourceId, sourceLevel,
251 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
252 yoffset, zoffset, x, y, z, width, height, depth, GLbooleanToString(unpackFlipY),
253 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
254
255 if (context)
256 {
257 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
258 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
259 TextureID destIdPacked = FromGL<TextureID>(destId);
260 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
261 bool isCallValid =
262 (context->skipValidation() ||
263 ValidateCopySubTexture3DANGLE(context, sourceIdPacked, sourceLevel, destTargetPacked,
264 destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y,
265 z, width, height, depth, unpackFlipY,
266 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
267 if (isCallValid)
268 {
269 context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
270 destLevel, xoffset, yoffset, zoffset, x, y, z, width, height,
271 depth, unpackFlipY, unpackPremultiplyAlpha,
272 unpackUnmultiplyAlpha);
273 }
274 ANGLE_CAPTURE(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
275 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z,
276 width, height, depth, unpackFlipY, unpackPremultiplyAlpha,
277 unpackUnmultiplyAlpha);
278 }
279 }
280
281 // GL_ANGLE_framebuffer_blit
BlitFramebufferANGLE(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)282 void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0,
283 GLint srcY0,
284 GLint srcX1,
285 GLint srcY1,
286 GLint dstX0,
287 GLint dstY0,
288 GLint dstX1,
289 GLint dstY1,
290 GLbitfield mask,
291 GLenum filter)
292 {
293 Context *context = GetValidGlobalContext();
294 EVENT("glBlitFramebufferANGLE",
295 "context = %d, GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
296 "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask "
297 "= %s, GLenum filter = %s",
298 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
299 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
300 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
301
302 if (context)
303 {
304 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
305 bool isCallValid = (context->skipValidation() ||
306 ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0,
307 dstY0, dstX1, dstY1, mask, filter));
308 if (isCallValid)
309 {
310 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
311 filter);
312 }
313 ANGLE_CAPTURE(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
314 dstY0, dstX1, dstY1, mask, filter);
315 }
316 }
317
318 // GL_ANGLE_framebuffer_multisample
RenderbufferStorageMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)319 void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target,
320 GLsizei samples,
321 GLenum internalformat,
322 GLsizei width,
323 GLsizei height)
324 {
325 Context *context = GetValidGlobalContext();
326 EVENT("glRenderbufferStorageMultisampleANGLE",
327 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
328 "GLsizei width = %d, GLsizei height = %d",
329 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
330 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
331
332 if (context)
333 {
334 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
335 bool isCallValid = (context->skipValidation() ||
336 ValidateRenderbufferStorageMultisampleANGLE(
337 context, target, samples, internalformat, width, height));
338 if (isCallValid)
339 {
340 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
341 }
342 ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples,
343 internalformat, width, height);
344 }
345 }
346
347 // GL_ANGLE_get_image
348 void GL_APIENTRY
GetTexImageANGLE(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)349 GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
350 {
351 Context *context = GetValidGlobalContext();
352 EVENT("glGetTexImageANGLE",
353 "context = %d, GLenum target = %s, GLint level = %d, GLenum format = %s, GLenum type = "
354 "%s, void *pixels = 0x%016" PRIxPTR "",
355 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
356 GLenumToString(GLenumGroup::PixelFormat, format),
357 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
358
359 if (context)
360 {
361 TextureTarget targetPacked = FromGL<TextureTarget>(target);
362 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
363 bool isCallValid =
364 (context->skipValidation() ||
365 ValidateGetTexImageANGLE(context, targetPacked, level, format, type, pixels));
366 if (isCallValid)
367 {
368 context->getTexImage(targetPacked, level, format, type, pixels);
369 }
370 ANGLE_CAPTURE(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type,
371 pixels);
372 }
373 }
374
GetRenderbufferImageANGLE(GLenum target,GLenum format,GLenum type,void * pixels)375 void GL_APIENTRY GetRenderbufferImageANGLE(GLenum target, GLenum format, GLenum type, void *pixels)
376 {
377 Context *context = GetValidGlobalContext();
378 EVENT("glGetRenderbufferImageANGLE",
379 "context = %d, GLenum target = %s, GLenum format = %s, GLenum type = %s, void *pixels = "
380 "0x%016" PRIxPTR "",
381 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
382 GLenumToString(GLenumGroup::PixelFormat, format),
383 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
384
385 if (context)
386 {
387 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
388 bool isCallValid =
389 (context->skipValidation() ||
390 ValidateGetRenderbufferImageANGLE(context, target, format, type, pixels));
391 if (isCallValid)
392 {
393 context->getRenderbufferImage(target, format, type, pixels);
394 }
395 ANGLE_CAPTURE(GetRenderbufferImageANGLE, isCallValid, context, target, format, type,
396 pixels);
397 }
398 }
399
400 // GL_ANGLE_instanced_arrays
DrawArraysInstancedANGLE(GLenum mode,GLint first,GLsizei count,GLsizei primcount)401 void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode,
402 GLint first,
403 GLsizei count,
404 GLsizei primcount)
405 {
406 Context *context = GetValidGlobalContext();
407 EVENT("glDrawArraysInstancedANGLE",
408 "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei primcount "
409 "= %d",
410 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, primcount);
411
412 if (context)
413 {
414 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
415 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
416 bool isCallValid =
417 (context->skipValidation() ||
418 ValidateDrawArraysInstancedANGLE(context, modePacked, first, count, primcount));
419 if (isCallValid)
420 {
421 context->drawArraysInstanced(modePacked, first, count, primcount);
422 }
423 ANGLE_CAPTURE(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count,
424 primcount);
425 }
426 }
427
DrawElementsInstancedANGLE(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)428 void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode,
429 GLsizei count,
430 GLenum type,
431 const void *indices,
432 GLsizei primcount)
433 {
434 Context *context = GetValidGlobalContext();
435 EVENT("glDrawElementsInstancedANGLE",
436 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
437 "*indices = 0x%016" PRIxPTR ", GLsizei primcount = %d",
438 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
439 GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, primcount);
440
441 if (context)
442 {
443 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
444 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
445 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
446 bool isCallValid = (context->skipValidation() ||
447 ValidateDrawElementsInstancedANGLE(context, modePacked, count,
448 typePacked, indices, primcount));
449 if (isCallValid)
450 {
451 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
452 }
453 ANGLE_CAPTURE(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count,
454 typePacked, indices, primcount);
455 }
456 }
457
VertexAttribDivisorANGLE(GLuint index,GLuint divisor)458 void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
459 {
460 Context *context = GetValidGlobalContext();
461 EVENT("glVertexAttribDivisorANGLE", "context = %d, GLuint index = %u, GLuint divisor = %u",
462 CID(context), index, divisor);
463
464 if (context)
465 {
466 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
467 bool isCallValid = (context->skipValidation() ||
468 ValidateVertexAttribDivisorANGLE(context, index, divisor));
469 if (isCallValid)
470 {
471 context->vertexAttribDivisor(index, divisor);
472 }
473 ANGLE_CAPTURE(VertexAttribDivisorANGLE, isCallValid, context, index, divisor);
474 }
475 }
476
477 // GL_ANGLE_memory_object_fuchsia
ImportMemoryZirconHandleANGLE(GLuint memory,GLuint64 size,GLenum handleType,GLuint handle)478 void GL_APIENTRY ImportMemoryZirconHandleANGLE(GLuint memory,
479 GLuint64 size,
480 GLenum handleType,
481 GLuint handle)
482 {
483 Context *context = GetValidGlobalContext();
484 EVENT("glImportMemoryZirconHandleANGLE",
485 "context = %d, GLuint memory = %u, GLuint64 size = %llu, GLenum handleType = %s, GLuint "
486 "handle = %u",
487 CID(context), memory, static_cast<unsigned long long>(size),
488 GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle);
489
490 if (context)
491 {
492 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
493 HandleType handleTypePacked = FromGL<HandleType>(handleType);
494 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
495 bool isCallValid = (context->skipValidation() ||
496 ValidateImportMemoryZirconHandleANGLE(context, memoryPacked, size,
497 handleTypePacked, handle));
498 if (isCallValid)
499 {
500 context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle);
501 }
502 ANGLE_CAPTURE(ImportMemoryZirconHandleANGLE, isCallValid, context, memoryPacked, size,
503 handleTypePacked, handle);
504 }
505 }
506
507 // GL_ANGLE_multi_draw
MultiDrawArraysANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)508 void GL_APIENTRY MultiDrawArraysANGLE(GLenum mode,
509 const GLint *firsts,
510 const GLsizei *counts,
511 GLsizei drawcount)
512 {
513 Context *context = GetValidGlobalContext();
514 EVENT("glMultiDrawArraysANGLE",
515 "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR
516 ", const GLsizei *counts = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
517 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
518 (uintptr_t)counts, drawcount);
519
520 if (context)
521 {
522 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
523 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
524 bool isCallValid =
525 (context->skipValidation() ||
526 ValidateMultiDrawArraysANGLE(context, modePacked, firsts, counts, drawcount));
527 if (isCallValid)
528 {
529 context->multiDrawArrays(modePacked, firsts, counts, drawcount);
530 }
531 ANGLE_CAPTURE(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts,
532 drawcount);
533 }
534 }
535
MultiDrawArraysInstancedANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)536 void GL_APIENTRY MultiDrawArraysInstancedANGLE(GLenum mode,
537 const GLint *firsts,
538 const GLsizei *counts,
539 const GLsizei *instanceCounts,
540 GLsizei drawcount)
541 {
542 Context *context = GetValidGlobalContext();
543 EVENT("glMultiDrawArraysInstancedANGLE",
544 "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR
545 ", const GLsizei *counts = 0x%016" PRIxPTR
546 ", const GLsizei *instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
547 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
548 (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
549
550 if (context)
551 {
552 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
553 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
554 bool isCallValid = (context->skipValidation() ||
555 ValidateMultiDrawArraysInstancedANGLE(
556 context, modePacked, firsts, counts, instanceCounts, drawcount));
557 if (isCallValid)
558 {
559 context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
560 drawcount);
561 }
562 ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts,
563 counts, instanceCounts, drawcount);
564 }
565 }
566
MultiDrawElementsANGLE(GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,GLsizei drawcount)567 void GL_APIENTRY MultiDrawElementsANGLE(GLenum mode,
568 const GLsizei *counts,
569 GLenum type,
570 const GLvoid *const *indices,
571 GLsizei drawcount)
572 {
573 Context *context = GetValidGlobalContext();
574 EVENT("glMultiDrawElementsANGLE",
575 "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR
576 ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR
577 ", GLsizei drawcount = %d",
578 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
579 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount);
580
581 if (context)
582 {
583 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
584 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
585 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
586 bool isCallValid = (context->skipValidation() ||
587 ValidateMultiDrawElementsANGLE(context, modePacked, counts, typePacked,
588 indices, drawcount));
589 if (isCallValid)
590 {
591 context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
592 }
593 ANGLE_CAPTURE(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts, typePacked,
594 indices, drawcount);
595 }
596 }
597
MultiDrawElementsInstancedANGLE(GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)598 void GL_APIENTRY MultiDrawElementsInstancedANGLE(GLenum mode,
599 const GLsizei *counts,
600 GLenum type,
601 const GLvoid *const *indices,
602 const GLsizei *instanceCounts,
603 GLsizei drawcount)
604 {
605 Context *context = GetValidGlobalContext();
606 EVENT("glMultiDrawElementsInstancedANGLE",
607 "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR
608 ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR
609 ", const GLsizei*instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
610 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
611 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
612 (uintptr_t)instanceCounts, drawcount);
613
614 if (context)
615 {
616 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
617 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
618 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
619 bool isCallValid =
620 (context->skipValidation() ||
621 ValidateMultiDrawElementsInstancedANGLE(context, modePacked, counts, typePacked,
622 indices, instanceCounts, drawcount));
623 if (isCallValid)
624 {
625 context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
626 instanceCounts, drawcount);
627 }
628 ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts,
629 typePacked, indices, instanceCounts, drawcount);
630 }
631 }
632
633 // GL_ANGLE_program_binary
634
635 // GL_ANGLE_provoking_vertex
ProvokingVertexANGLE(GLenum mode)636 void GL_APIENTRY ProvokingVertexANGLE(GLenum mode)
637 {
638 Context *context = GetValidGlobalContext();
639 EVENT("glProvokingVertexANGLE", "context = %d, GLenum mode = %s", CID(context),
640 GLenumToString(GLenumGroup::VertexProvokingMode, mode));
641
642 if (context)
643 {
644 ProvokingVertexConvention modePacked = FromGL<ProvokingVertexConvention>(mode);
645 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
646 bool isCallValid =
647 (context->skipValidation() || ValidateProvokingVertexANGLE(context, modePacked));
648 if (isCallValid)
649 {
650 context->provokingVertex(modePacked);
651 }
652 ANGLE_CAPTURE(ProvokingVertexANGLE, isCallValid, context, modePacked);
653 }
654 }
655
656 // GL_ANGLE_request_extension
RequestExtensionANGLE(const GLchar * name)657 void GL_APIENTRY RequestExtensionANGLE(const GLchar *name)
658 {
659 Context *context = GetValidGlobalContext();
660 EVENT("glRequestExtensionANGLE", "context = %d, const GLchar * name = 0x%016" PRIxPTR "",
661 CID(context), (uintptr_t)name);
662
663 if (context)
664 {
665 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
666 bool isCallValid =
667 (context->skipValidation() || ValidateRequestExtensionANGLE(context, name));
668 if (isCallValid)
669 {
670 context->requestExtension(name);
671 }
672 ANGLE_CAPTURE(RequestExtensionANGLE, isCallValid, context, name);
673 }
674 }
675
DisableExtensionANGLE(const GLchar * name)676 void GL_APIENTRY DisableExtensionANGLE(const GLchar *name)
677 {
678 Context *context = GetValidGlobalContext();
679 EVENT("glDisableExtensionANGLE", "context = %d, const GLchar * name = 0x%016" PRIxPTR "",
680 CID(context), (uintptr_t)name);
681
682 if (context)
683 {
684 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
685 bool isCallValid =
686 (context->skipValidation() || ValidateDisableExtensionANGLE(context, name));
687 if (isCallValid)
688 {
689 context->disableExtension(name);
690 }
691 ANGLE_CAPTURE(DisableExtensionANGLE, isCallValid, context, name);
692 }
693 }
694
695 // GL_ANGLE_robust_client_memory
GetBooleanvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)696 void GL_APIENTRY GetBooleanvRobustANGLE(GLenum pname,
697 GLsizei bufSize,
698 GLsizei *length,
699 GLboolean *params)
700 {
701 Context *context = GetValidGlobalContext();
702 EVENT("glGetBooleanvRobustANGLE",
703 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
704 ", GLboolean * params = 0x%016" PRIxPTR "",
705 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
706 (uintptr_t)length, (uintptr_t)params);
707
708 if (context)
709 {
710 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
711 bool isCallValid =
712 (context->skipValidation() ||
713 ValidateGetBooleanvRobustANGLE(context, pname, bufSize, length, params));
714 if (isCallValid)
715 {
716 context->getBooleanvRobust(pname, bufSize, length, params);
717 }
718 ANGLE_CAPTURE(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
719 }
720 }
721
GetBufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)722 void GL_APIENTRY GetBufferParameterivRobustANGLE(GLenum target,
723 GLenum pname,
724 GLsizei bufSize,
725 GLsizei *length,
726 GLint *params)
727 {
728 Context *context = GetValidGlobalContext();
729 EVENT("glGetBufferParameterivRobustANGLE",
730 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
731 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
732 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
733 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
734 (uintptr_t)params);
735
736 if (context)
737 {
738 BufferBinding targetPacked = FromGL<BufferBinding>(target);
739 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
740 bool isCallValid = (context->skipValidation() ||
741 ValidateGetBufferParameterivRobustANGLE(context, targetPacked, pname,
742 bufSize, length, params));
743 if (isCallValid)
744 {
745 context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
746 }
747 ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
748 bufSize, length, params);
749 }
750 }
751
GetFloatvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)752 void GL_APIENTRY GetFloatvRobustANGLE(GLenum pname,
753 GLsizei bufSize,
754 GLsizei *length,
755 GLfloat *params)
756 {
757 Context *context = GetValidGlobalContext();
758 EVENT("glGetFloatvRobustANGLE",
759 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
760 ", GLfloat * params = 0x%016" PRIxPTR "",
761 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
762 (uintptr_t)length, (uintptr_t)params);
763
764 if (context)
765 {
766 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
767 bool isCallValid = (context->skipValidation() ||
768 ValidateGetFloatvRobustANGLE(context, pname, bufSize, length, params));
769 if (isCallValid)
770 {
771 context->getFloatvRobust(pname, bufSize, length, params);
772 }
773 ANGLE_CAPTURE(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
774 }
775 }
776
GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)777 void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
778 GLenum attachment,
779 GLenum pname,
780 GLsizei bufSize,
781 GLsizei *length,
782 GLint *params)
783 {
784 Context *context = GetValidGlobalContext();
785 EVENT("glGetFramebufferAttachmentParameterivRobustANGLE",
786 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLsizei "
787 "bufSize = %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
788 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
789 GLenumToString(GLenumGroup::DefaultGroup, attachment),
790 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
791 (uintptr_t)params);
792
793 if (context)
794 {
795 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
796 bool isCallValid = (context->skipValidation() ||
797 ValidateGetFramebufferAttachmentParameterivRobustANGLE(
798 context, target, attachment, pname, bufSize, length, params));
799 if (isCallValid)
800 {
801 context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
802 length, params);
803 }
804 ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context, target,
805 attachment, pname, bufSize, length, params);
806 }
807 }
808
GetIntegervRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)809 void GL_APIENTRY GetIntegervRobustANGLE(GLenum pname, GLsizei bufSize, GLsizei *length, GLint *data)
810 {
811 Context *context = GetValidGlobalContext();
812 EVENT("glGetIntegervRobustANGLE",
813 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
814 ", GLint * data = 0x%016" PRIxPTR "",
815 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
816 (uintptr_t)length, (uintptr_t)data);
817
818 if (context)
819 {
820 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
821 bool isCallValid = (context->skipValidation() ||
822 ValidateGetIntegervRobustANGLE(context, pname, bufSize, length, data));
823 if (isCallValid)
824 {
825 context->getIntegervRobust(pname, bufSize, length, data);
826 }
827 ANGLE_CAPTURE(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length, data);
828 }
829 }
830
GetProgramivRobustANGLE(GLuint program,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)831 void GL_APIENTRY GetProgramivRobustANGLE(GLuint program,
832 GLenum pname,
833 GLsizei bufSize,
834 GLsizei *length,
835 GLint *params)
836 {
837 Context *context = GetGlobalContext();
838 EVENT("glGetProgramivRobustANGLE",
839 "context = %d, GLuint program = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
840 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
841 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
842 (uintptr_t)length, (uintptr_t)params);
843
844 if (context)
845 {
846 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
847 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
848 bool isCallValid = (context->skipValidation() ||
849 ValidateGetProgramivRobustANGLE(context, programPacked, pname, bufSize,
850 length, params));
851 if (isCallValid)
852 {
853 context->getProgramivRobust(programPacked, pname, bufSize, length, params);
854 }
855 ANGLE_CAPTURE(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname, bufSize,
856 length, params);
857 }
858 }
859
GetRenderbufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)860 void GL_APIENTRY GetRenderbufferParameterivRobustANGLE(GLenum target,
861 GLenum pname,
862 GLsizei bufSize,
863 GLsizei *length,
864 GLint *params)
865 {
866 Context *context = GetValidGlobalContext();
867 EVENT("glGetRenderbufferParameterivRobustANGLE",
868 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
869 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
870 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
871 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
872 (uintptr_t)params);
873
874 if (context)
875 {
876 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
877 bool isCallValid =
878 (context->skipValidation() || ValidateGetRenderbufferParameterivRobustANGLE(
879 context, target, pname, bufSize, length, params));
880 if (isCallValid)
881 {
882 context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
883 }
884 ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname,
885 bufSize, length, params);
886 }
887 }
888
889 void GL_APIENTRY
GetShaderivRobustANGLE(GLuint shader,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)890 GetShaderivRobustANGLE(GLuint shader, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params)
891 {
892 Context *context = GetGlobalContext();
893 EVENT("glGetShaderivRobustANGLE",
894 "context = %d, GLuint shader = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
895 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
896 CID(context), shader, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
897 (uintptr_t)length, (uintptr_t)params);
898
899 if (context)
900 {
901 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
902 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
903 bool isCallValid =
904 (context->skipValidation() ||
905 ValidateGetShaderivRobustANGLE(context, shaderPacked, pname, bufSize, length, params));
906 if (isCallValid)
907 {
908 context->getShaderivRobust(shaderPacked, pname, bufSize, length, params);
909 }
910 ANGLE_CAPTURE(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize,
911 length, params);
912 }
913 }
914
GetTexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)915 void GL_APIENTRY GetTexParameterfvRobustANGLE(GLenum target,
916 GLenum pname,
917 GLsizei bufSize,
918 GLsizei *length,
919 GLfloat *params)
920 {
921 Context *context = GetValidGlobalContext();
922 EVENT("glGetTexParameterfvRobustANGLE",
923 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
924 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
925 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
926 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
927 (uintptr_t)params);
928
929 if (context)
930 {
931 TextureType targetPacked = FromGL<TextureType>(target);
932 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
933 bool isCallValid = (context->skipValidation() ||
934 ValidateGetTexParameterfvRobustANGLE(context, targetPacked, pname,
935 bufSize, length, params));
936 if (isCallValid)
937 {
938 context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
939 }
940 ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname,
941 bufSize, length, params);
942 }
943 }
944
GetTexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)945 void GL_APIENTRY GetTexParameterivRobustANGLE(GLenum target,
946 GLenum pname,
947 GLsizei bufSize,
948 GLsizei *length,
949 GLint *params)
950 {
951 Context *context = GetValidGlobalContext();
952 EVENT("glGetTexParameterivRobustANGLE",
953 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
954 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
955 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
956 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
957 (uintptr_t)params);
958
959 if (context)
960 {
961 TextureType targetPacked = FromGL<TextureType>(target);
962 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
963 bool isCallValid = (context->skipValidation() ||
964 ValidateGetTexParameterivRobustANGLE(context, targetPacked, pname,
965 bufSize, length, params));
966 if (isCallValid)
967 {
968 context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
969 }
970 ANGLE_CAPTURE(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
971 bufSize, length, params);
972 }
973 }
974
GetUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)975 void GL_APIENTRY GetUniformfvRobustANGLE(GLuint program,
976 GLint location,
977 GLsizei bufSize,
978 GLsizei *length,
979 GLfloat *params)
980 {
981 Context *context = GetValidGlobalContext();
982 EVENT("glGetUniformfvRobustANGLE",
983 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
984 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
985 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
986
987 if (context)
988 {
989 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
990 UniformLocation locationPacked = FromGL<UniformLocation>(location);
991 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
992 bool isCallValid = (context->skipValidation() ||
993 ValidateGetUniformfvRobustANGLE(context, programPacked, locationPacked,
994 bufSize, length, params));
995 if (isCallValid)
996 {
997 context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
998 }
999 ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
1000 bufSize, length, params);
1001 }
1002 }
1003
GetUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)1004 void GL_APIENTRY GetUniformivRobustANGLE(GLuint program,
1005 GLint location,
1006 GLsizei bufSize,
1007 GLsizei *length,
1008 GLint *params)
1009 {
1010 Context *context = GetValidGlobalContext();
1011 EVENT("glGetUniformivRobustANGLE",
1012 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
1013 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
1014 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1015
1016 if (context)
1017 {
1018 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1019 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1020 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1021 bool isCallValid = (context->skipValidation() ||
1022 ValidateGetUniformivRobustANGLE(context, programPacked, locationPacked,
1023 bufSize, length, params));
1024 if (isCallValid)
1025 {
1026 context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
1027 }
1028 ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
1029 bufSize, length, params);
1030 }
1031 }
1032
GetVertexAttribfvRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1033 void GL_APIENTRY GetVertexAttribfvRobustANGLE(GLuint index,
1034 GLenum pname,
1035 GLsizei bufSize,
1036 GLsizei *length,
1037 GLfloat *params)
1038 {
1039 Context *context = GetValidGlobalContext();
1040 EVENT("glGetVertexAttribfvRobustANGLE",
1041 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1042 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
1043 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1044 (uintptr_t)length, (uintptr_t)params);
1045
1046 if (context)
1047 {
1048 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1049 bool isCallValid =
1050 (context->skipValidation() ||
1051 ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, length, params));
1052 if (isCallValid)
1053 {
1054 context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
1055 }
1056 ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize,
1057 length, params);
1058 }
1059 }
1060
GetVertexAttribivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1061 void GL_APIENTRY GetVertexAttribivRobustANGLE(GLuint index,
1062 GLenum pname,
1063 GLsizei bufSize,
1064 GLsizei *length,
1065 GLint *params)
1066 {
1067 Context *context = GetValidGlobalContext();
1068 EVENT("glGetVertexAttribivRobustANGLE",
1069 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1070 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
1071 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1072 (uintptr_t)length, (uintptr_t)params);
1073
1074 if (context)
1075 {
1076 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1077 bool isCallValid =
1078 (context->skipValidation() ||
1079 ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, length, params));
1080 if (isCallValid)
1081 {
1082 context->getVertexAttribivRobust(index, pname, bufSize, length, params);
1083 }
1084 ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize,
1085 length, params);
1086 }
1087 }
1088
GetVertexAttribPointervRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)1089 void GL_APIENTRY GetVertexAttribPointervRobustANGLE(GLuint index,
1090 GLenum pname,
1091 GLsizei bufSize,
1092 GLsizei *length,
1093 void **pointer)
1094 {
1095 Context *context = GetValidGlobalContext();
1096 EVENT("glGetVertexAttribPointervRobustANGLE",
1097 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1098 "length = 0x%016" PRIxPTR ", void ** pointer = 0x%016" PRIxPTR "",
1099 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1100 (uintptr_t)length, (uintptr_t)pointer);
1101
1102 if (context)
1103 {
1104 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1105 bool isCallValid =
1106 (context->skipValidation() || ValidateGetVertexAttribPointervRobustANGLE(
1107 context, index, pname, bufSize, length, pointer));
1108 if (isCallValid)
1109 {
1110 context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
1111 }
1112 ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname,
1113 bufSize, length, pointer);
1114 }
1115 }
1116
ReadPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * pixels)1117 void GL_APIENTRY ReadPixelsRobustANGLE(GLint x,
1118 GLint y,
1119 GLsizei width,
1120 GLsizei height,
1121 GLenum format,
1122 GLenum type,
1123 GLsizei bufSize,
1124 GLsizei *length,
1125 GLsizei *columns,
1126 GLsizei *rows,
1127 void *pixels)
1128 {
1129 Context *context = GetValidGlobalContext();
1130 EVENT(
1131 "glReadPixelsRobustANGLE",
1132 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum "
1133 "format = %s, GLenum type = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
1134 ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
1135 ", void * pixels = 0x%016" PRIxPTR "",
1136 CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
1137 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
1138 (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)pixels);
1139
1140 if (context)
1141 {
1142 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1143 bool isCallValid =
1144 (context->skipValidation() ||
1145 ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
1146 length, columns, rows, pixels));
1147 if (isCallValid)
1148 {
1149 context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
1150 rows, pixels);
1151 }
1152 ANGLE_CAPTURE(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
1153 type, bufSize, length, columns, rows, pixels);
1154 }
1155 }
1156
TexImage2DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)1157 void GL_APIENTRY TexImage2DRobustANGLE(GLenum target,
1158 GLint level,
1159 GLint internalformat,
1160 GLsizei width,
1161 GLsizei height,
1162 GLint border,
1163 GLenum format,
1164 GLenum type,
1165 GLsizei bufSize,
1166 const void *pixels)
1167 {
1168 Context *context = GetValidGlobalContext();
1169 EVENT("glTexImage2DRobustANGLE",
1170 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
1171 "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = "
1172 "%s, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR "",
1173 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
1174 width, height, border, GLenumToString(GLenumGroup::DefaultGroup, format),
1175 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1176
1177 if (context)
1178 {
1179 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1180 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1181 bool isCallValid =
1182 (context->skipValidation() ||
1183 ValidateTexImage2DRobustANGLE(context, targetPacked, level, internalformat, width,
1184 height, border, format, type, bufSize, pixels));
1185 if (isCallValid)
1186 {
1187 context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
1188 format, type, bufSize, pixels);
1189 }
1190 ANGLE_CAPTURE(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1191 internalformat, width, height, border, format, type, bufSize, pixels);
1192 }
1193 }
1194
TexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLfloat * params)1195 void GL_APIENTRY TexParameterfvRobustANGLE(GLenum target,
1196 GLenum pname,
1197 GLsizei bufSize,
1198 const GLfloat *params)
1199 {
1200 Context *context = GetValidGlobalContext();
1201 EVENT("glTexParameterfvRobustANGLE",
1202 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const "
1203 "GLfloat * params = 0x%016" PRIxPTR "",
1204 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1205 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
1206
1207 if (context)
1208 {
1209 TextureType targetPacked = FromGL<TextureType>(target);
1210 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1211 bool isCallValid =
1212 (context->skipValidation() ||
1213 ValidateTexParameterfvRobustANGLE(context, targetPacked, pname, bufSize, params));
1214 if (isCallValid)
1215 {
1216 context->texParameterfvRobust(targetPacked, pname, bufSize, params);
1217 }
1218 ANGLE_CAPTURE(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
1219 params);
1220 }
1221 }
1222
TexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)1223 void GL_APIENTRY TexParameterivRobustANGLE(GLenum target,
1224 GLenum pname,
1225 GLsizei bufSize,
1226 const GLint *params)
1227 {
1228 Context *context = GetValidGlobalContext();
1229 EVENT("glTexParameterivRobustANGLE",
1230 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLint "
1231 "* params = 0x%016" PRIxPTR "",
1232 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1233 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
1234
1235 if (context)
1236 {
1237 TextureType targetPacked = FromGL<TextureType>(target);
1238 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1239 bool isCallValid =
1240 (context->skipValidation() ||
1241 ValidateTexParameterivRobustANGLE(context, targetPacked, pname, bufSize, params));
1242 if (isCallValid)
1243 {
1244 context->texParameterivRobust(targetPacked, pname, bufSize, params);
1245 }
1246 ANGLE_CAPTURE(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
1247 params);
1248 }
1249 }
1250
TexSubImage2DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)1251 void GL_APIENTRY TexSubImage2DRobustANGLE(GLenum target,
1252 GLint level,
1253 GLint xoffset,
1254 GLint yoffset,
1255 GLsizei width,
1256 GLsizei height,
1257 GLenum format,
1258 GLenum type,
1259 GLsizei bufSize,
1260 const void *pixels)
1261 {
1262 Context *context = GetValidGlobalContext();
1263 EVENT("glTexSubImage2DRobustANGLE",
1264 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
1265 "%d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLenum type = %s, "
1266 "GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR "",
1267 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1268 width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
1269 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1270
1271 if (context)
1272 {
1273 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1274 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1275 bool isCallValid =
1276 (context->skipValidation() ||
1277 ValidateTexSubImage2DRobustANGLE(context, targetPacked, level, xoffset, yoffset, width,
1278 height, format, type, bufSize, pixels));
1279 if (isCallValid)
1280 {
1281 context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
1282 format, type, bufSize, pixels);
1283 }
1284 ANGLE_CAPTURE(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
1285 yoffset, width, height, format, type, bufSize, pixels);
1286 }
1287 }
1288
TexImage3DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)1289 void GL_APIENTRY TexImage3DRobustANGLE(GLenum target,
1290 GLint level,
1291 GLint internalformat,
1292 GLsizei width,
1293 GLsizei height,
1294 GLsizei depth,
1295 GLint border,
1296 GLenum format,
1297 GLenum type,
1298 GLsizei bufSize,
1299 const void *pixels)
1300 {
1301 Context *context = GetValidGlobalContext();
1302 EVENT("glTexImage3DRobustANGLE",
1303 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
1304 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = "
1305 "%s, GLenum type = %s, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR "",
1306 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
1307 width, height, depth, border, GLenumToString(GLenumGroup::DefaultGroup, format),
1308 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1309
1310 if (context)
1311 {
1312 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1313 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1314 bool isCallValid =
1315 (context->skipValidation() ||
1316 ValidateTexImage3DRobustANGLE(context, targetPacked, level, internalformat, width,
1317 height, depth, border, format, type, bufSize, pixels));
1318 if (isCallValid)
1319 {
1320 context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
1321 border, format, type, bufSize, pixels);
1322 }
1323 ANGLE_CAPTURE(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
1324 internalformat, width, height, depth, border, format, type, bufSize, pixels);
1325 }
1326 }
1327
TexSubImage3DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)1328 void GL_APIENTRY TexSubImage3DRobustANGLE(GLenum target,
1329 GLint level,
1330 GLint xoffset,
1331 GLint yoffset,
1332 GLint zoffset,
1333 GLsizei width,
1334 GLsizei height,
1335 GLsizei depth,
1336 GLenum format,
1337 GLenum type,
1338 GLsizei bufSize,
1339 const void *pixels)
1340 {
1341 Context *context = GetValidGlobalContext();
1342 EVENT("glTexSubImage3DRobustANGLE",
1343 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
1344 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
1345 "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, const void * pixels = "
1346 "0x%016" PRIxPTR "",
1347 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1348 zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
1349 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1350
1351 if (context)
1352 {
1353 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1354 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1355 bool isCallValid = (context->skipValidation() ||
1356 ValidateTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset,
1357 yoffset, zoffset, width, height, depth,
1358 format, type, bufSize, pixels));
1359 if (isCallValid)
1360 {
1361 context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
1362 height, depth, format, type, bufSize, pixels);
1363 }
1364 ANGLE_CAPTURE(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
1365 yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
1366 }
1367 }
1368
CompressedTexImage2DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)1369 void GL_APIENTRY CompressedTexImage2DRobustANGLE(GLenum target,
1370 GLint level,
1371 GLenum internalformat,
1372 GLsizei width,
1373 GLsizei height,
1374 GLint border,
1375 GLsizei imageSize,
1376 GLsizei dataSize,
1377 const GLvoid *data)
1378 {
1379 Context *context = GetValidGlobalContext();
1380 EVENT("glCompressedTexImage2DRobustANGLE",
1381 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
1382 "width = %d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, GLsizei "
1383 "dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "",
1384 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
1385 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, border,
1386 imageSize, dataSize, (uintptr_t)data);
1387
1388 if (context)
1389 {
1390 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1391 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1392 bool isCallValid =
1393 (context->skipValidation() || ValidateCompressedTexImage2DRobustANGLE(
1394 context, targetPacked, level, internalformat, width,
1395 height, border, imageSize, dataSize, data));
1396 if (isCallValid)
1397 {
1398 context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
1399 border, imageSize, dataSize, data);
1400 }
1401 ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1402 internalformat, width, height, border, imageSize, dataSize, data);
1403 }
1404 }
1405
CompressedTexSubImage2DRobustANGLE(GLenum target,GLint level,GLsizei xoffset,GLsizei yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)1406 void GL_APIENTRY CompressedTexSubImage2DRobustANGLE(GLenum target,
1407 GLint level,
1408 GLsizei xoffset,
1409 GLsizei yoffset,
1410 GLsizei width,
1411 GLsizei height,
1412 GLenum format,
1413 GLsizei imageSize,
1414 GLsizei dataSize,
1415 const GLvoid *data)
1416 {
1417 Context *context = GetValidGlobalContext();
1418 EVENT("glCompressedTexSubImage2DRobustANGLE",
1419 "context = %d, GLenum target = %s, GLint level = %d, GLsizei xoffset = %d, GLsizei "
1420 "yoffset = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLsizei "
1421 "imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "",
1422 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1423 width, height, GLenumToString(GLenumGroup::DefaultGroup, format), imageSize, dataSize,
1424 (uintptr_t)data);
1425
1426 if (context)
1427 {
1428 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1429 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1430 bool isCallValid =
1431 (context->skipValidation() || ValidateCompressedTexSubImage2DRobustANGLE(
1432 context, targetPacked, level, xoffset, yoffset, width,
1433 height, format, imageSize, dataSize, data));
1434 if (isCallValid)
1435 {
1436 context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
1437 height, format, imageSize, dataSize, data);
1438 }
1439 ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1440 xoffset, yoffset, width, height, format, imageSize, dataSize, data);
1441 }
1442 }
1443
CompressedTexImage3DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)1444 void GL_APIENTRY CompressedTexImage3DRobustANGLE(GLenum target,
1445 GLint level,
1446 GLenum internalformat,
1447 GLsizei width,
1448 GLsizei height,
1449 GLsizei depth,
1450 GLint border,
1451 GLsizei imageSize,
1452 GLsizei dataSize,
1453 const GLvoid *data)
1454 {
1455 Context *context = GetValidGlobalContext();
1456 EVENT("glCompressedTexImage3DRobustANGLE",
1457 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
1458 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei "
1459 "imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "",
1460 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
1461 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, depth, border,
1462 imageSize, dataSize, (uintptr_t)data);
1463
1464 if (context)
1465 {
1466 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1467 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1468 bool isCallValid =
1469 (context->skipValidation() || ValidateCompressedTexImage3DRobustANGLE(
1470 context, targetPacked, level, internalformat, width,
1471 height, depth, border, imageSize, dataSize, data));
1472 if (isCallValid)
1473 {
1474 context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
1475 depth, border, imageSize, dataSize, data);
1476 }
1477 ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
1478 internalformat, width, height, depth, border, imageSize, dataSize, data);
1479 }
1480 }
1481
CompressedTexSubImage3DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)1482 void GL_APIENTRY CompressedTexSubImage3DRobustANGLE(GLenum target,
1483 GLint level,
1484 GLint xoffset,
1485 GLint yoffset,
1486 GLint zoffset,
1487 GLsizei width,
1488 GLsizei height,
1489 GLsizei depth,
1490 GLenum format,
1491 GLsizei imageSize,
1492 GLsizei dataSize,
1493 const GLvoid *data)
1494 {
1495 Context *context = GetValidGlobalContext();
1496 EVENT("glCompressedTexSubImage3DRobustANGLE",
1497 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
1498 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
1499 "GLenum format = %s, GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid * data "
1500 "= 0x%016" PRIxPTR "",
1501 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
1502 zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
1503 imageSize, dataSize, (uintptr_t)data);
1504
1505 if (context)
1506 {
1507 TextureTarget targetPacked = FromGL<TextureTarget>(target);
1508 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1509 bool isCallValid = (context->skipValidation() ||
1510 ValidateCompressedTexSubImage3DRobustANGLE(
1511 context, targetPacked, level, xoffset, yoffset, zoffset, width,
1512 height, depth, format, imageSize, dataSize, data));
1513 if (isCallValid)
1514 {
1515 context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
1516 width, height, depth, format, imageSize,
1517 dataSize, data);
1518 }
1519 ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level,
1520 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
1521 data);
1522 }
1523 }
1524
1525 void GL_APIENTRY
GetQueryivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1526 GetQueryivRobustANGLE(GLenum target, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params)
1527 {
1528 Context *context = GetValidGlobalContext();
1529 EVENT("glGetQueryivRobustANGLE",
1530 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1531 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
1532 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1533 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1534 (uintptr_t)params);
1535
1536 if (context)
1537 {
1538 QueryType targetPacked = FromGL<QueryType>(target);
1539 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1540 bool isCallValid =
1541 (context->skipValidation() ||
1542 ValidateGetQueryivRobustANGLE(context, targetPacked, pname, bufSize, length, params));
1543 if (isCallValid)
1544 {
1545 context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
1546 }
1547 ANGLE_CAPTURE(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
1548 length, params);
1549 }
1550 }
1551
GetQueryObjectuivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)1552 void GL_APIENTRY GetQueryObjectuivRobustANGLE(GLuint id,
1553 GLenum pname,
1554 GLsizei bufSize,
1555 GLsizei *length,
1556 GLuint *params)
1557 {
1558 Context *context = GetValidGlobalContext();
1559 EVENT("glGetQueryObjectuivRobustANGLE",
1560 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
1561 "= 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
1562 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1563 (uintptr_t)length, (uintptr_t)params);
1564
1565 if (context)
1566 {
1567 QueryID idPacked = FromGL<QueryID>(id);
1568 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1569 bool isCallValid =
1570 (context->skipValidation() || ValidateGetQueryObjectuivRobustANGLE(
1571 context, idPacked, pname, bufSize, length, params));
1572 if (isCallValid)
1573 {
1574 context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params);
1575 }
1576 ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
1577 length, params);
1578 }
1579 }
1580
GetBufferPointervRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)1581 void GL_APIENTRY GetBufferPointervRobustANGLE(GLenum target,
1582 GLenum pname,
1583 GLsizei bufSize,
1584 GLsizei *length,
1585 void **params)
1586 {
1587 Context *context = GetValidGlobalContext();
1588 EVENT("glGetBufferPointervRobustANGLE",
1589 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1590 "length = 0x%016" PRIxPTR ", void ** params = 0x%016" PRIxPTR "",
1591 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1592 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1593 (uintptr_t)params);
1594
1595 if (context)
1596 {
1597 BufferBinding targetPacked = FromGL<BufferBinding>(target);
1598 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1599 bool isCallValid = (context->skipValidation() ||
1600 ValidateGetBufferPointervRobustANGLE(context, targetPacked, pname,
1601 bufSize, length, params));
1602 if (isCallValid)
1603 {
1604 context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
1605 }
1606 ANGLE_CAPTURE(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname,
1607 bufSize, length, params);
1608 }
1609 }
1610
1611 void GL_APIENTRY
GetIntegeri_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)1612 GetIntegeri_vRobustANGLE(GLenum target, GLuint index, GLsizei bufSize, GLsizei *length, GLint *data)
1613 {
1614 Context *context = GetValidGlobalContext();
1615 EVENT("glGetIntegeri_vRobustANGLE",
1616 "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
1617 "length = 0x%016" PRIxPTR ", GLint * data = 0x%016" PRIxPTR "",
1618 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
1619 (uintptr_t)length, (uintptr_t)data);
1620
1621 if (context)
1622 {
1623 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1624 bool isCallValid =
1625 (context->skipValidation() ||
1626 ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, length, data));
1627 if (isCallValid)
1628 {
1629 context->getIntegeri_vRobust(target, index, bufSize, length, data);
1630 }
1631 ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize,
1632 length, data);
1633 }
1634 }
1635
GetInternalformativRobustANGLE(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1636 void GL_APIENTRY GetInternalformativRobustANGLE(GLenum target,
1637 GLenum internalformat,
1638 GLenum pname,
1639 GLsizei bufSize,
1640 GLsizei *length,
1641 GLint *params)
1642 {
1643 Context *context = GetValidGlobalContext();
1644 EVENT("glGetInternalformativRobustANGLE",
1645 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLenum pname = %s, "
1646 "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
1647 ", GLint * params = 0x%016" PRIxPTR "",
1648 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1649 GLenumToString(GLenumGroup::DefaultGroup, internalformat),
1650 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1651 (uintptr_t)params);
1652
1653 if (context)
1654 {
1655 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1656 bool isCallValid = (context->skipValidation() ||
1657 ValidateGetInternalformativRobustANGLE(context, target, internalformat,
1658 pname, bufSize, length, params));
1659 if (isCallValid)
1660 {
1661 context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
1662 params);
1663 }
1664 ANGLE_CAPTURE(GetInternalformativRobustANGLE, isCallValid, context, target, internalformat,
1665 pname, bufSize, length, params);
1666 }
1667 }
1668
GetVertexAttribIivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1669 void GL_APIENTRY GetVertexAttribIivRobustANGLE(GLuint index,
1670 GLenum pname,
1671 GLsizei bufSize,
1672 GLsizei *length,
1673 GLint *params)
1674 {
1675 Context *context = GetValidGlobalContext();
1676 EVENT("glGetVertexAttribIivRobustANGLE",
1677 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1678 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
1679 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1680 (uintptr_t)length, (uintptr_t)params);
1681
1682 if (context)
1683 {
1684 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1685 bool isCallValid =
1686 (context->skipValidation() ||
1687 ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, length, params));
1688 if (isCallValid)
1689 {
1690 context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
1691 }
1692 ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize,
1693 length, params);
1694 }
1695 }
1696
GetVertexAttribIuivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)1697 void GL_APIENTRY GetVertexAttribIuivRobustANGLE(GLuint index,
1698 GLenum pname,
1699 GLsizei bufSize,
1700 GLsizei *length,
1701 GLuint *params)
1702 {
1703 Context *context = GetValidGlobalContext();
1704 EVENT("glGetVertexAttribIuivRobustANGLE",
1705 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1706 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
1707 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1708 (uintptr_t)length, (uintptr_t)params);
1709
1710 if (context)
1711 {
1712 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1713 bool isCallValid =
1714 (context->skipValidation() || ValidateGetVertexAttribIuivRobustANGLE(
1715 context, index, pname, bufSize, length, params));
1716 if (isCallValid)
1717 {
1718 context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
1719 }
1720 ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname, bufSize,
1721 length, params);
1722 }
1723 }
1724
GetUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)1725 void GL_APIENTRY GetUniformuivRobustANGLE(GLuint program,
1726 GLint location,
1727 GLsizei bufSize,
1728 GLsizei *length,
1729 GLuint *params)
1730 {
1731 Context *context = GetValidGlobalContext();
1732 EVENT("glGetUniformuivRobustANGLE",
1733 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
1734 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
1735 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1736
1737 if (context)
1738 {
1739 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1740 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1741 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1742 bool isCallValid = (context->skipValidation() ||
1743 ValidateGetUniformuivRobustANGLE(context, programPacked, locationPacked,
1744 bufSize, length, params));
1745 if (isCallValid)
1746 {
1747 context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
1748 }
1749 ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, locationPacked,
1750 bufSize, length, params);
1751 }
1752 }
1753
GetActiveUniformBlockivRobustANGLE(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1754 void GL_APIENTRY GetActiveUniformBlockivRobustANGLE(GLuint program,
1755 GLuint uniformBlockIndex,
1756 GLenum pname,
1757 GLsizei bufSize,
1758 GLsizei *length,
1759 GLint *params)
1760 {
1761 Context *context = GetValidGlobalContext();
1762 EVENT("glGetActiveUniformBlockivRobustANGLE",
1763 "context = %d, GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = %s, "
1764 "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
1765 ", GLint * params = 0x%016" PRIxPTR "",
1766 CID(context), program, uniformBlockIndex,
1767 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1768 (uintptr_t)params);
1769
1770 if (context)
1771 {
1772 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1773 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1774 bool isCallValid =
1775 (context->skipValidation() ||
1776 ValidateGetActiveUniformBlockivRobustANGLE(context, programPacked, uniformBlockIndex,
1777 pname, bufSize, length, params));
1778 if (isCallValid)
1779 {
1780 context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndex, pname, bufSize,
1781 length, params);
1782 }
1783 ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked,
1784 uniformBlockIndex, pname, bufSize, length, params);
1785 }
1786 }
1787
GetInteger64vRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)1788 void GL_APIENTRY GetInteger64vRobustANGLE(GLenum pname,
1789 GLsizei bufSize,
1790 GLsizei *length,
1791 GLint64 *data)
1792 {
1793 Context *context = GetValidGlobalContext();
1794 EVENT("glGetInteger64vRobustANGLE",
1795 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
1796 ", GLint64 * data = 0x%016" PRIxPTR "",
1797 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1798 (uintptr_t)length, (uintptr_t)data);
1799
1800 if (context)
1801 {
1802 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1803 bool isCallValid =
1804 (context->skipValidation() ||
1805 ValidateGetInteger64vRobustANGLE(context, pname, bufSize, length, data));
1806 if (isCallValid)
1807 {
1808 context->getInteger64vRobust(pname, bufSize, length, data);
1809 }
1810 ANGLE_CAPTURE(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length, data);
1811 }
1812 }
1813
GetInteger64i_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)1814 void GL_APIENTRY GetInteger64i_vRobustANGLE(GLenum target,
1815 GLuint index,
1816 GLsizei bufSize,
1817 GLsizei *length,
1818 GLint64 *data)
1819 {
1820 Context *context = GetValidGlobalContext();
1821 EVENT("glGetInteger64i_vRobustANGLE",
1822 "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
1823 "length = 0x%016" PRIxPTR ", GLint64 * data = 0x%016" PRIxPTR "",
1824 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
1825 (uintptr_t)length, (uintptr_t)data);
1826
1827 if (context)
1828 {
1829 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1830 bool isCallValid =
1831 (context->skipValidation() ||
1832 ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, length, data));
1833 if (isCallValid)
1834 {
1835 context->getInteger64i_vRobust(target, index, bufSize, length, data);
1836 }
1837 ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize,
1838 length, data);
1839 }
1840 }
1841
GetBufferParameteri64vRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)1842 void GL_APIENTRY GetBufferParameteri64vRobustANGLE(GLenum target,
1843 GLenum pname,
1844 GLsizei bufSize,
1845 GLsizei *length,
1846 GLint64 *params)
1847 {
1848 Context *context = GetValidGlobalContext();
1849 EVENT("glGetBufferParameteri64vRobustANGLE",
1850 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1851 "length = 0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR "",
1852 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1853 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1854 (uintptr_t)params);
1855
1856 if (context)
1857 {
1858 BufferBinding targetPacked = FromGL<BufferBinding>(target);
1859 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1860 bool isCallValid = (context->skipValidation() ||
1861 ValidateGetBufferParameteri64vRobustANGLE(context, targetPacked, pname,
1862 bufSize, length, params));
1863 if (isCallValid)
1864 {
1865 context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
1866 }
1867 ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked, pname,
1868 bufSize, length, params);
1869 }
1870 }
1871
SamplerParameterivRobustANGLE(GLuint sampler,GLuint pname,GLsizei bufSize,const GLint * param)1872 void GL_APIENTRY SamplerParameterivRobustANGLE(GLuint sampler,
1873 GLuint pname,
1874 GLsizei bufSize,
1875 const GLint *param)
1876 {
1877 Context *context = GetValidGlobalContext();
1878 EVENT("glSamplerParameterivRobustANGLE",
1879 "context = %d, GLuint sampler = %u, GLuint pname = %u, GLsizei bufSize = %d, const GLint "
1880 "* param = 0x%016" PRIxPTR "",
1881 CID(context), sampler, pname, bufSize, (uintptr_t)param);
1882
1883 if (context)
1884 {
1885 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
1886 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1887 bool isCallValid =
1888 (context->skipValidation() ||
1889 ValidateSamplerParameterivRobustANGLE(context, samplerPacked, pname, bufSize, param));
1890 if (isCallValid)
1891 {
1892 context->samplerParameterivRobust(samplerPacked, pname, bufSize, param);
1893 }
1894 ANGLE_CAPTURE(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
1895 bufSize, param);
1896 }
1897 }
1898
SamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLfloat * param)1899 void GL_APIENTRY SamplerParameterfvRobustANGLE(GLuint sampler,
1900 GLenum pname,
1901 GLsizei bufSize,
1902 const GLfloat *param)
1903 {
1904 Context *context = GetValidGlobalContext();
1905 EVENT("glSamplerParameterfvRobustANGLE",
1906 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const "
1907 "GLfloat * param = 0x%016" PRIxPTR "",
1908 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1909 (uintptr_t)param);
1910
1911 if (context)
1912 {
1913 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
1914 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1915 bool isCallValid =
1916 (context->skipValidation() ||
1917 ValidateSamplerParameterfvRobustANGLE(context, samplerPacked, pname, bufSize, param));
1918 if (isCallValid)
1919 {
1920 context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param);
1921 }
1922 ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
1923 bufSize, param);
1924 }
1925 }
1926
GetSamplerParameterivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1927 void GL_APIENTRY GetSamplerParameterivRobustANGLE(GLuint sampler,
1928 GLenum pname,
1929 GLsizei bufSize,
1930 GLsizei *length,
1931 GLint *params)
1932 {
1933 Context *context = GetValidGlobalContext();
1934 EVENT("glGetSamplerParameterivRobustANGLE",
1935 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1936 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
1937 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1938 (uintptr_t)length, (uintptr_t)params);
1939
1940 if (context)
1941 {
1942 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
1943 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1944 bool isCallValid = (context->skipValidation() ||
1945 ValidateGetSamplerParameterivRobustANGLE(context, samplerPacked, pname,
1946 bufSize, length, params));
1947 if (isCallValid)
1948 {
1949 context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params);
1950 }
1951 ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
1952 bufSize, length, params);
1953 }
1954 }
1955
GetSamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1956 void GL_APIENTRY GetSamplerParameterfvRobustANGLE(GLuint sampler,
1957 GLenum pname,
1958 GLsizei bufSize,
1959 GLsizei *length,
1960 GLfloat *params)
1961 {
1962 Context *context = GetValidGlobalContext();
1963 EVENT("glGetSamplerParameterfvRobustANGLE",
1964 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1965 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
1966 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1967 (uintptr_t)length, (uintptr_t)params);
1968
1969 if (context)
1970 {
1971 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
1972 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1973 bool isCallValid = (context->skipValidation() ||
1974 ValidateGetSamplerParameterfvRobustANGLE(context, samplerPacked, pname,
1975 bufSize, length, params));
1976 if (isCallValid)
1977 {
1978 context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params);
1979 }
1980 ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
1981 bufSize, length, params);
1982 }
1983 }
1984
GetFramebufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1985 void GL_APIENTRY GetFramebufferParameterivRobustANGLE(GLenum target,
1986 GLenum pname,
1987 GLsizei bufSize,
1988 GLsizei *length,
1989 GLint *params)
1990 {
1991 Context *context = GetValidGlobalContext();
1992 EVENT("glGetFramebufferParameterivRobustANGLE",
1993 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
1994 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
1995 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1996 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1997 (uintptr_t)params);
1998
1999 if (context)
2000 {
2001 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2002 bool isCallValid =
2003 (context->skipValidation() || ValidateGetFramebufferParameterivRobustANGLE(
2004 context, target, pname, bufSize, length, params));
2005 if (isCallValid)
2006 {
2007 context->getFramebufferParameterivRobust(target, pname, bufSize, length, params);
2008 }
2009 ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname,
2010 bufSize, length, params);
2011 }
2012 }
2013
GetProgramInterfaceivRobustANGLE(GLuint program,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2014 void GL_APIENTRY GetProgramInterfaceivRobustANGLE(GLuint program,
2015 GLenum programInterface,
2016 GLenum pname,
2017 GLsizei bufSize,
2018 GLsizei *length,
2019 GLint *params)
2020 {
2021 Context *context = GetValidGlobalContext();
2022 EVENT("glGetProgramInterfaceivRobustANGLE",
2023 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLenum pname = %s, "
2024 "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
2025 ", GLint * params = 0x%016" PRIxPTR "",
2026 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, programInterface),
2027 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2028 (uintptr_t)params);
2029
2030 if (context)
2031 {
2032 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
2033 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2034 bool isCallValid =
2035 (context->skipValidation() ||
2036 ValidateGetProgramInterfaceivRobustANGLE(context, programPacked, programInterface,
2037 pname, bufSize, length, params));
2038 if (isCallValid)
2039 {
2040 context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize,
2041 length, params);
2042 }
2043 ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked,
2044 programInterface, pname, bufSize, length, params);
2045 }
2046 }
2047
GetBooleani_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)2048 void GL_APIENTRY GetBooleani_vRobustANGLE(GLenum target,
2049 GLuint index,
2050 GLsizei bufSize,
2051 GLsizei *length,
2052 GLboolean *data)
2053 {
2054 Context *context = GetValidGlobalContext();
2055 EVENT("glGetBooleani_vRobustANGLE",
2056 "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
2057 "length = 0x%016" PRIxPTR ", GLboolean * data = 0x%016" PRIxPTR "",
2058 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2059 (uintptr_t)length, (uintptr_t)data);
2060
2061 if (context)
2062 {
2063 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2064 bool isCallValid =
2065 (context->skipValidation() ||
2066 ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, length, data));
2067 if (isCallValid)
2068 {
2069 context->getBooleani_vRobust(target, index, bufSize, length, data);
2070 }
2071 ANGLE_CAPTURE(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize,
2072 length, data);
2073 }
2074 }
2075
GetMultisamplefvRobustANGLE(GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)2076 void GL_APIENTRY GetMultisamplefvRobustANGLE(GLenum pname,
2077 GLuint index,
2078 GLsizei bufSize,
2079 GLsizei *length,
2080 GLfloat *val)
2081 {
2082 Context *context = GetValidGlobalContext();
2083 EVENT("glGetMultisamplefvRobustANGLE",
2084 "context = %d, GLenum pname = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
2085 "length = 0x%016" PRIxPTR ", GLfloat * val = 0x%016" PRIxPTR "",
2086 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, bufSize,
2087 (uintptr_t)length, (uintptr_t)val);
2088
2089 if (context)
2090 {
2091 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2092 bool isCallValid =
2093 (context->skipValidation() ||
2094 ValidateGetMultisamplefvRobustANGLE(context, pname, index, bufSize, length, val));
2095 if (isCallValid)
2096 {
2097 context->getMultisamplefvRobust(pname, index, bufSize, length, val);
2098 }
2099 ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize,
2100 length, val);
2101 }
2102 }
2103
GetTexLevelParameterivRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2104 void GL_APIENTRY GetTexLevelParameterivRobustANGLE(GLenum target,
2105 GLint level,
2106 GLenum pname,
2107 GLsizei bufSize,
2108 GLsizei *length,
2109 GLint *params)
2110 {
2111 Context *context = GetValidGlobalContext();
2112 EVENT("glGetTexLevelParameterivRobustANGLE",
2113 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLsizei bufSize "
2114 "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
2115 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2116 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2117 (uintptr_t)params);
2118
2119 if (context)
2120 {
2121 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2122 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2123 bool isCallValid = (context->skipValidation() ||
2124 ValidateGetTexLevelParameterivRobustANGLE(
2125 context, targetPacked, level, pname, bufSize, length, params));
2126 if (isCallValid)
2127 {
2128 context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
2129 params);
2130 }
2131 ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked, level,
2132 pname, bufSize, length, params);
2133 }
2134 }
2135
GetTexLevelParameterfvRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2136 void GL_APIENTRY GetTexLevelParameterfvRobustANGLE(GLenum target,
2137 GLint level,
2138 GLenum pname,
2139 GLsizei bufSize,
2140 GLsizei *length,
2141 GLfloat *params)
2142 {
2143 Context *context = GetValidGlobalContext();
2144 EVENT("glGetTexLevelParameterfvRobustANGLE",
2145 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLsizei bufSize "
2146 "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
2147 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2148 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2149 (uintptr_t)params);
2150
2151 if (context)
2152 {
2153 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2154 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2155 bool isCallValid = (context->skipValidation() ||
2156 ValidateGetTexLevelParameterfvRobustANGLE(
2157 context, targetPacked, level, pname, bufSize, length, params));
2158 if (isCallValid)
2159 {
2160 context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
2161 params);
2162 }
2163 ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked, level,
2164 pname, bufSize, length, params);
2165 }
2166 }
2167
GetPointervRobustANGLERobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2168 void GL_APIENTRY GetPointervRobustANGLERobustANGLE(GLenum pname,
2169 GLsizei bufSize,
2170 GLsizei *length,
2171 void **params)
2172 {
2173 Context *context = GetValidGlobalContext();
2174 EVENT("glGetPointervRobustANGLERobustANGLE",
2175 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
2176 ", void ** params = 0x%016" PRIxPTR "",
2177 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2178 (uintptr_t)length, (uintptr_t)params);
2179
2180 if (context)
2181 {
2182 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2183 bool isCallValid =
2184 (context->skipValidation() ||
2185 ValidateGetPointervRobustANGLERobustANGLE(context, pname, bufSize, length, params));
2186 if (isCallValid)
2187 {
2188 context->getPointervRobustANGLERobust(pname, bufSize, length, params);
2189 }
2190 ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize,
2191 length, params);
2192 }
2193 }
2194
ReadnPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * data)2195 void GL_APIENTRY ReadnPixelsRobustANGLE(GLint x,
2196 GLint y,
2197 GLsizei width,
2198 GLsizei height,
2199 GLenum format,
2200 GLenum type,
2201 GLsizei bufSize,
2202 GLsizei *length,
2203 GLsizei *columns,
2204 GLsizei *rows,
2205 void *data)
2206 {
2207 Context *context = GetValidGlobalContext();
2208 EVENT(
2209 "glReadnPixelsRobustANGLE",
2210 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum "
2211 "format = %s, GLenum type = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
2212 ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
2213 ", void * data = 0x%016" PRIxPTR "",
2214 CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
2215 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
2216 (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)data);
2217
2218 if (context)
2219 {
2220 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2221 bool isCallValid =
2222 (context->skipValidation() ||
2223 ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
2224 length, columns, rows, data));
2225 if (isCallValid)
2226 {
2227 context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
2228 rows, data);
2229 }
2230 ANGLE_CAPTURE(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
2231 type, bufSize, length, columns, rows, data);
2232 }
2233 }
2234
GetnUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)2235 void GL_APIENTRY GetnUniformfvRobustANGLE(GLuint program,
2236 GLint location,
2237 GLsizei bufSize,
2238 GLsizei *length,
2239 GLfloat *params)
2240 {
2241 Context *context = GetValidGlobalContext();
2242 EVENT("glGetnUniformfvRobustANGLE",
2243 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
2244 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
2245 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2246
2247 if (context)
2248 {
2249 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
2250 UniformLocation locationPacked = FromGL<UniformLocation>(location);
2251 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2252 bool isCallValid = (context->skipValidation() ||
2253 ValidateGetnUniformfvRobustANGLE(context, programPacked, locationPacked,
2254 bufSize, length, params));
2255 if (isCallValid)
2256 {
2257 context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
2258 }
2259 ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
2260 bufSize, length, params);
2261 }
2262 }
2263
GetnUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)2264 void GL_APIENTRY GetnUniformivRobustANGLE(GLuint program,
2265 GLint location,
2266 GLsizei bufSize,
2267 GLsizei *length,
2268 GLint *params)
2269 {
2270 Context *context = GetValidGlobalContext();
2271 EVENT("glGetnUniformivRobustANGLE",
2272 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
2273 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
2274 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2275
2276 if (context)
2277 {
2278 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
2279 UniformLocation locationPacked = FromGL<UniformLocation>(location);
2280 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2281 bool isCallValid = (context->skipValidation() ||
2282 ValidateGetnUniformivRobustANGLE(context, programPacked, locationPacked,
2283 bufSize, length, params));
2284 if (isCallValid)
2285 {
2286 context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
2287 }
2288 ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
2289 bufSize, length, params);
2290 }
2291 }
2292
GetnUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)2293 void GL_APIENTRY GetnUniformuivRobustANGLE(GLuint program,
2294 GLint location,
2295 GLsizei bufSize,
2296 GLsizei *length,
2297 GLuint *params)
2298 {
2299 Context *context = GetValidGlobalContext();
2300 EVENT("glGetnUniformuivRobustANGLE",
2301 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
2302 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
2303 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2304
2305 if (context)
2306 {
2307 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
2308 UniformLocation locationPacked = FromGL<UniformLocation>(location);
2309 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2310 bool isCallValid = (context->skipValidation() ||
2311 ValidateGetnUniformuivRobustANGLE(
2312 context, programPacked, locationPacked, bufSize, length, params));
2313 if (isCallValid)
2314 {
2315 context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
2316 }
2317 ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
2318 locationPacked, bufSize, length, params);
2319 }
2320 }
2321
TexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)2322 void GL_APIENTRY TexParameterIivRobustANGLE(GLenum target,
2323 GLenum pname,
2324 GLsizei bufSize,
2325 const GLint *params)
2326 {
2327 Context *context = GetValidGlobalContext();
2328 EVENT("glTexParameterIivRobustANGLE",
2329 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLint "
2330 "* params = 0x%016" PRIxPTR "",
2331 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2332 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
2333
2334 if (context)
2335 {
2336 TextureType targetPacked = FromGL<TextureType>(target);
2337 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2338 bool isCallValid =
2339 (context->skipValidation() ||
2340 ValidateTexParameterIivRobustANGLE(context, targetPacked, pname, bufSize, params));
2341 if (isCallValid)
2342 {
2343 context->texParameterIivRobust(targetPacked, pname, bufSize, params);
2344 }
2345 ANGLE_CAPTURE(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
2346 bufSize, params);
2347 }
2348 }
2349
TexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLuint * params)2350 void GL_APIENTRY TexParameterIuivRobustANGLE(GLenum target,
2351 GLenum pname,
2352 GLsizei bufSize,
2353 const GLuint *params)
2354 {
2355 Context *context = GetValidGlobalContext();
2356 EVENT("glTexParameterIuivRobustANGLE",
2357 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLuint "
2358 "* params = 0x%016" PRIxPTR "",
2359 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2360 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
2361
2362 if (context)
2363 {
2364 TextureType targetPacked = FromGL<TextureType>(target);
2365 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2366 bool isCallValid =
2367 (context->skipValidation() ||
2368 ValidateTexParameterIuivRobustANGLE(context, targetPacked, pname, bufSize, params));
2369 if (isCallValid)
2370 {
2371 context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
2372 }
2373 ANGLE_CAPTURE(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
2374 bufSize, params);
2375 }
2376 }
2377
GetTexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2378 void GL_APIENTRY GetTexParameterIivRobustANGLE(GLenum target,
2379 GLenum pname,
2380 GLsizei bufSize,
2381 GLsizei *length,
2382 GLint *params)
2383 {
2384 Context *context = GetValidGlobalContext();
2385 EVENT("glGetTexParameterIivRobustANGLE",
2386 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
2387 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
2388 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2389 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2390 (uintptr_t)params);
2391
2392 if (context)
2393 {
2394 TextureType targetPacked = FromGL<TextureType>(target);
2395 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2396 bool isCallValid = (context->skipValidation() ||
2397 ValidateGetTexParameterIivRobustANGLE(context, targetPacked, pname,
2398 bufSize, length, params));
2399 if (isCallValid)
2400 {
2401 context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
2402 }
2403 ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
2404 bufSize, length, params);
2405 }
2406 }
2407
GetTexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2408 void GL_APIENTRY GetTexParameterIuivRobustANGLE(GLenum target,
2409 GLenum pname,
2410 GLsizei bufSize,
2411 GLsizei *length,
2412 GLuint *params)
2413 {
2414 Context *context = GetValidGlobalContext();
2415 EVENT("glGetTexParameterIuivRobustANGLE",
2416 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
2417 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
2418 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2419 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2420 (uintptr_t)params);
2421
2422 if (context)
2423 {
2424 TextureType targetPacked = FromGL<TextureType>(target);
2425 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2426 bool isCallValid = (context->skipValidation() ||
2427 ValidateGetTexParameterIuivRobustANGLE(context, targetPacked, pname,
2428 bufSize, length, params));
2429 if (isCallValid)
2430 {
2431 context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
2432 }
2433 ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
2434 bufSize, length, params);
2435 }
2436 }
2437
SamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLint * param)2438 void GL_APIENTRY SamplerParameterIivRobustANGLE(GLuint sampler,
2439 GLenum pname,
2440 GLsizei bufSize,
2441 const GLint *param)
2442 {
2443 Context *context = GetValidGlobalContext();
2444 EVENT("glSamplerParameterIivRobustANGLE",
2445 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const GLint "
2446 "* param = 0x%016" PRIxPTR "",
2447 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2448 (uintptr_t)param);
2449
2450 if (context)
2451 {
2452 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
2453 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2454 bool isCallValid =
2455 (context->skipValidation() ||
2456 ValidateSamplerParameterIivRobustANGLE(context, samplerPacked, pname, bufSize, param));
2457 if (isCallValid)
2458 {
2459 context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param);
2460 }
2461 ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
2462 bufSize, param);
2463 }
2464 }
2465
SamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLuint * param)2466 void GL_APIENTRY SamplerParameterIuivRobustANGLE(GLuint sampler,
2467 GLenum pname,
2468 GLsizei bufSize,
2469 const GLuint *param)
2470 {
2471 Context *context = GetValidGlobalContext();
2472 EVENT("glSamplerParameterIuivRobustANGLE",
2473 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const "
2474 "GLuint * param = 0x%016" PRIxPTR "",
2475 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2476 (uintptr_t)param);
2477
2478 if (context)
2479 {
2480 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
2481 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2482 bool isCallValid =
2483 (context->skipValidation() || ValidateSamplerParameterIuivRobustANGLE(
2484 context, samplerPacked, pname, bufSize, param));
2485 if (isCallValid)
2486 {
2487 context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param);
2488 }
2489 ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, pname,
2490 bufSize, param);
2491 }
2492 }
2493
GetSamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2494 void GL_APIENTRY GetSamplerParameterIivRobustANGLE(GLuint sampler,
2495 GLenum pname,
2496 GLsizei bufSize,
2497 GLsizei *length,
2498 GLint *params)
2499 {
2500 Context *context = GetValidGlobalContext();
2501 EVENT("glGetSamplerParameterIivRobustANGLE",
2502 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
2503 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
2504 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2505 (uintptr_t)length, (uintptr_t)params);
2506
2507 if (context)
2508 {
2509 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
2510 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2511 bool isCallValid = (context->skipValidation() ||
2512 ValidateGetSamplerParameterIivRobustANGLE(context, samplerPacked, pname,
2513 bufSize, length, params));
2514 if (isCallValid)
2515 {
2516 context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params);
2517 }
2518 ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
2519 bufSize, length, params);
2520 }
2521 }
2522
GetSamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2523 void GL_APIENTRY GetSamplerParameterIuivRobustANGLE(GLuint sampler,
2524 GLenum pname,
2525 GLsizei bufSize,
2526 GLsizei *length,
2527 GLuint *params)
2528 {
2529 Context *context = GetValidGlobalContext();
2530 EVENT("glGetSamplerParameterIuivRobustANGLE",
2531 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
2532 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
2533 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2534 (uintptr_t)length, (uintptr_t)params);
2535
2536 if (context)
2537 {
2538 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
2539 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2540 bool isCallValid = (context->skipValidation() ||
2541 ValidateGetSamplerParameterIuivRobustANGLE(
2542 context, samplerPacked, pname, bufSize, length, params));
2543 if (isCallValid)
2544 {
2545 context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params);
2546 }
2547 ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked,
2548 pname, bufSize, length, params);
2549 }
2550 }
2551
GetQueryObjectivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2552 void GL_APIENTRY GetQueryObjectivRobustANGLE(GLuint id,
2553 GLenum pname,
2554 GLsizei bufSize,
2555 GLsizei *length,
2556 GLint *params)
2557 {
2558 Context *context = GetGlobalContext();
2559 EVENT("glGetQueryObjectivRobustANGLE",
2560 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
2561 "= 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
2562 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2563 (uintptr_t)length, (uintptr_t)params);
2564
2565 if (context)
2566 {
2567 QueryID idPacked = FromGL<QueryID>(id);
2568 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2569 bool isCallValid =
2570 (context->skipValidation() || ValidateGetQueryObjectivRobustANGLE(
2571 context, idPacked, pname, bufSize, length, params));
2572 if (isCallValid)
2573 {
2574 context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params);
2575 }
2576 ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
2577 length, params);
2578 }
2579 }
2580
GetQueryObjecti64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)2581 void GL_APIENTRY GetQueryObjecti64vRobustANGLE(GLuint id,
2582 GLenum pname,
2583 GLsizei bufSize,
2584 GLsizei *length,
2585 GLint64 *params)
2586 {
2587 Context *context = GetGlobalContext();
2588 EVENT("glGetQueryObjecti64vRobustANGLE",
2589 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
2590 "= 0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR "",
2591 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2592 (uintptr_t)length, (uintptr_t)params);
2593
2594 if (context)
2595 {
2596 QueryID idPacked = FromGL<QueryID>(id);
2597 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2598 bool isCallValid =
2599 (context->skipValidation() || ValidateGetQueryObjecti64vRobustANGLE(
2600 context, idPacked, pname, bufSize, length, params));
2601 if (isCallValid)
2602 {
2603 context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params);
2604 }
2605 ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
2606 length, params);
2607 }
2608 }
2609
GetQueryObjectui64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)2610 void GL_APIENTRY GetQueryObjectui64vRobustANGLE(GLuint id,
2611 GLenum pname,
2612 GLsizei bufSize,
2613 GLsizei *length,
2614 GLuint64 *params)
2615 {
2616 Context *context = GetValidGlobalContext();
2617 EVENT("glGetQueryObjectui64vRobustANGLE",
2618 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
2619 "= 0x%016" PRIxPTR ", GLuint64 * params = 0x%016" PRIxPTR "",
2620 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2621 (uintptr_t)length, (uintptr_t)params);
2622
2623 if (context)
2624 {
2625 QueryID idPacked = FromGL<QueryID>(id);
2626 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2627 bool isCallValid =
2628 (context->skipValidation() || ValidateGetQueryObjectui64vRobustANGLE(
2629 context, idPacked, pname, bufSize, length, params));
2630 if (isCallValid)
2631 {
2632 context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params);
2633 }
2634 ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname,
2635 bufSize, length, params);
2636 }
2637 }
2638
2639 // GL_ANGLE_semaphore_fuchsia
ImportSemaphoreZirconHandleANGLE(GLuint semaphore,GLenum handleType,GLuint handle)2640 void GL_APIENTRY ImportSemaphoreZirconHandleANGLE(GLuint semaphore,
2641 GLenum handleType,
2642 GLuint handle)
2643 {
2644 Context *context = GetValidGlobalContext();
2645 EVENT("glImportSemaphoreZirconHandleANGLE",
2646 "context = %d, GLuint semaphore = %u, GLenum handleType = %s, GLuint handle = %u",
2647 CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType),
2648 handle);
2649
2650 if (context)
2651 {
2652 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
2653 HandleType handleTypePacked = FromGL<HandleType>(handleType);
2654 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2655 bool isCallValid =
2656 (context->skipValidation() || ValidateImportSemaphoreZirconHandleANGLE(
2657 context, semaphorePacked, handleTypePacked, handle));
2658 if (isCallValid)
2659 {
2660 context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle);
2661 }
2662 ANGLE_CAPTURE(ImportSemaphoreZirconHandleANGLE, isCallValid, context, semaphorePacked,
2663 handleTypePacked, handle);
2664 }
2665 }
2666
2667 // GL_ANGLE_texture_external_update
TexImage2DExternalANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)2668 void GL_APIENTRY TexImage2DExternalANGLE(GLenum target,
2669 GLint level,
2670 GLint internalformat,
2671 GLsizei width,
2672 GLsizei height,
2673 GLint border,
2674 GLenum format,
2675 GLenum type)
2676 {
2677 Context *context = GetValidGlobalContext();
2678 EVENT(
2679 "glTexImage2DExternalANGLE",
2680 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
2681 "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = %s",
2682 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
2683 width, height, border, GLenumToString(GLenumGroup::PixelFormat, format),
2684 GLenumToString(GLenumGroup::PixelType, type));
2685
2686 if (context)
2687 {
2688 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2689 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2690 bool isCallValid =
2691 (context->skipValidation() ||
2692 ValidateTexImage2DExternalANGLE(context, targetPacked, level, internalformat, width,
2693 height, border, format, type));
2694 if (isCallValid)
2695 {
2696 context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
2697 format, type);
2698 }
2699 ANGLE_CAPTURE(TexImage2DExternalANGLE, isCallValid, context, targetPacked, level,
2700 internalformat, width, height, border, format, type);
2701 }
2702 }
2703
InvalidateTextureANGLE(GLenum target)2704 void GL_APIENTRY InvalidateTextureANGLE(GLenum target)
2705 {
2706 Context *context = GetValidGlobalContext();
2707 EVENT("glInvalidateTextureANGLE", "context = %d, GLenum target = %s", CID(context),
2708 GLenumToString(GLenumGroup::TextureTarget, target));
2709
2710 if (context)
2711 {
2712 TextureType targetPacked = FromGL<TextureType>(target);
2713 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2714 bool isCallValid =
2715 (context->skipValidation() || ValidateInvalidateTextureANGLE(context, targetPacked));
2716 if (isCallValid)
2717 {
2718 context->invalidateTexture(targetPacked);
2719 }
2720 ANGLE_CAPTURE(InvalidateTextureANGLE, isCallValid, context, targetPacked);
2721 }
2722 }
2723
2724 // GL_ANGLE_texture_multisample
TexStorage2DMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)2725 void GL_APIENTRY TexStorage2DMultisampleANGLE(GLenum target,
2726 GLsizei samples,
2727 GLenum internalformat,
2728 GLsizei width,
2729 GLsizei height,
2730 GLboolean fixedsamplelocations)
2731 {
2732 Context *context = GetValidGlobalContext();
2733 EVENT("glTexStorage2DMultisampleANGLE",
2734 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
2735 "GLsizei width = %d, GLsizei height = %d, GLboolean fixedsamplelocations = %s",
2736 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), samples,
2737 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height,
2738 GLbooleanToString(fixedsamplelocations));
2739
2740 if (context)
2741 {
2742 TextureType targetPacked = FromGL<TextureType>(target);
2743 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2744 bool isCallValid =
2745 (context->skipValidation() ||
2746 ValidateTexStorage2DMultisampleANGLE(context, targetPacked, samples, internalformat,
2747 width, height, fixedsamplelocations));
2748 if (isCallValid)
2749 {
2750 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
2751 fixedsamplelocations);
2752 }
2753 ANGLE_CAPTURE(TexStorage2DMultisampleANGLE, isCallValid, context, targetPacked, samples,
2754 internalformat, width, height, fixedsamplelocations);
2755 }
2756 }
2757
GetTexLevelParameterivANGLE(GLenum target,GLint level,GLenum pname,GLint * params)2758 void GL_APIENTRY GetTexLevelParameterivANGLE(GLenum target,
2759 GLint level,
2760 GLenum pname,
2761 GLint *params)
2762 {
2763 Context *context = GetValidGlobalContext();
2764 EVENT("glGetTexLevelParameterivANGLE",
2765 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint * params = "
2766 "0x%016" PRIxPTR "",
2767 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2768 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
2769
2770 if (context)
2771 {
2772 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2773 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2774 bool isCallValid =
2775 (context->skipValidation() ||
2776 ValidateGetTexLevelParameterivANGLE(context, targetPacked, level, pname, params));
2777 if (isCallValid)
2778 {
2779 context->getTexLevelParameteriv(targetPacked, level, pname, params);
2780 }
2781 ANGLE_CAPTURE(GetTexLevelParameterivANGLE, isCallValid, context, targetPacked, level, pname,
2782 params);
2783 }
2784 }
2785
GetTexLevelParameterfvANGLE(GLenum target,GLint level,GLenum pname,GLfloat * params)2786 void GL_APIENTRY GetTexLevelParameterfvANGLE(GLenum target,
2787 GLint level,
2788 GLenum pname,
2789 GLfloat *params)
2790 {
2791 Context *context = GetValidGlobalContext();
2792 EVENT("glGetTexLevelParameterfvANGLE",
2793 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat * params "
2794 "= 0x%016" PRIxPTR "",
2795 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2796 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
2797
2798 if (context)
2799 {
2800 TextureTarget targetPacked = FromGL<TextureTarget>(target);
2801 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2802 bool isCallValid =
2803 (context->skipValidation() ||
2804 ValidateGetTexLevelParameterfvANGLE(context, targetPacked, level, pname, params));
2805 if (isCallValid)
2806 {
2807 context->getTexLevelParameterfv(targetPacked, level, pname, params);
2808 }
2809 ANGLE_CAPTURE(GetTexLevelParameterfvANGLE, isCallValid, context, targetPacked, level, pname,
2810 params);
2811 }
2812 }
2813
GetMultisamplefvANGLE(GLenum pname,GLuint index,GLfloat * val)2814 void GL_APIENTRY GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
2815 {
2816 Context *context = GetValidGlobalContext();
2817 EVENT("glGetMultisamplefvANGLE",
2818 "context = %d, GLenum pname = %s, GLuint index = %u, GLfloat * val = 0x%016" PRIxPTR "",
2819 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
2820
2821 if (context)
2822 {
2823 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2824 bool isCallValid = (context->skipValidation() ||
2825 ValidateGetMultisamplefvANGLE(context, pname, index, val));
2826 if (isCallValid)
2827 {
2828 context->getMultisamplefv(pname, index, val);
2829 }
2830 ANGLE_CAPTURE(GetMultisamplefvANGLE, isCallValid, context, pname, index, val);
2831 }
2832 }
2833
SampleMaskiANGLE(GLuint maskNumber,GLbitfield mask)2834 void GL_APIENTRY SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
2835 {
2836 Context *context = GetValidGlobalContext();
2837 EVENT("glSampleMaskiANGLE", "context = %d, GLuint maskNumber = %u, GLbitfield mask = %s",
2838 CID(context), maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
2839
2840 if (context)
2841 {
2842 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2843 bool isCallValid =
2844 (context->skipValidation() || ValidateSampleMaskiANGLE(context, maskNumber, mask));
2845 if (isCallValid)
2846 {
2847 context->sampleMaski(maskNumber, mask);
2848 }
2849 ANGLE_CAPTURE(SampleMaskiANGLE, isCallValid, context, maskNumber, mask);
2850 }
2851 }
2852
2853 // GL_ANGLE_translated_shader_source
GetTranslatedShaderSourceANGLE(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * source)2854 void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader,
2855 GLsizei bufsize,
2856 GLsizei *length,
2857 GLchar *source)
2858 {
2859 Context *context = GetValidGlobalContext();
2860 EVENT("glGetTranslatedShaderSourceANGLE",
2861 "context = %d, GLuint shader = %u, GLsizei bufsize = %d, GLsizei *length = 0x%016" PRIxPTR
2862 ", GLchar *source = 0x%016" PRIxPTR "",
2863 CID(context), shader, bufsize, (uintptr_t)length, (uintptr_t)source);
2864
2865 if (context)
2866 {
2867 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
2868 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2869 bool isCallValid =
2870 (context->skipValidation() || ValidateGetTranslatedShaderSourceANGLE(
2871 context, shaderPacked, bufsize, length, source));
2872 if (isCallValid)
2873 {
2874 context->getTranslatedShaderSource(shaderPacked, bufsize, length, source);
2875 }
2876 ANGLE_CAPTURE(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked, bufsize,
2877 length, source);
2878 }
2879 }
2880
2881 // GL_CHROMIUM_bind_uniform_location
BindUniformLocationCHROMIUM(GLuint program,GLint location,const GLchar * name)2882 void GL_APIENTRY BindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
2883 {
2884 Context *context = GetValidGlobalContext();
2885 EVENT("glBindUniformLocationCHROMIUM",
2886 "context = %d, GLuint program = %u, GLint location = %d, const GLchar* name = "
2887 "0x%016" PRIxPTR "",
2888 CID(context), program, location, (uintptr_t)name);
2889
2890 if (context)
2891 {
2892 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
2893 UniformLocation locationPacked = FromGL<UniformLocation>(location);
2894 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2895 bool isCallValid =
2896 (context->skipValidation() ||
2897 ValidateBindUniformLocationCHROMIUM(context, programPacked, locationPacked, name));
2898 if (isCallValid)
2899 {
2900 context->bindUniformLocation(programPacked, locationPacked, name);
2901 }
2902 ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
2903 locationPacked, name);
2904 }
2905 }
2906
2907 // GL_CHROMIUM_copy_compressed_texture
CompressedCopyTextureCHROMIUM(GLuint sourceId,GLuint destId)2908 void GL_APIENTRY CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
2909 {
2910 Context *context = GetValidGlobalContext();
2911 EVENT("glCompressedCopyTextureCHROMIUM",
2912 "context = %d, GLuint sourceId = %u, GLuint destId = %u", CID(context), sourceId, destId);
2913
2914 if (context)
2915 {
2916 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
2917 TextureID destIdPacked = FromGL<TextureID>(destId);
2918 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2919 bool isCallValid =
2920 (context->skipValidation() ||
2921 ValidateCompressedCopyTextureCHROMIUM(context, sourceIdPacked, destIdPacked));
2922 if (isCallValid)
2923 {
2924 context->compressedCopyTexture(sourceIdPacked, destIdPacked);
2925 }
2926 ANGLE_CAPTURE(CompressedCopyTextureCHROMIUM, isCallValid, context, sourceIdPacked,
2927 destIdPacked);
2928 }
2929 }
2930
2931 // GL_CHROMIUM_copy_texture
CopyTextureCHROMIUM(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)2932 void GL_APIENTRY CopyTextureCHROMIUM(GLuint sourceId,
2933 GLint sourceLevel,
2934 GLenum destTarget,
2935 GLuint destId,
2936 GLint destLevel,
2937 GLint internalFormat,
2938 GLenum destType,
2939 GLboolean unpackFlipY,
2940 GLboolean unpackPremultiplyAlpha,
2941 GLboolean unpackUnmultiplyAlpha)
2942 {
2943 Context *context = GetValidGlobalContext();
2944 EVENT("glCopyTextureCHROMIUM",
2945 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
2946 "GLuint destId = %u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = "
2947 "%s, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = %s, GLboolean "
2948 "unpackUnmultiplyAlpha = %s",
2949 CID(context), sourceId, sourceLevel,
2950 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
2951 GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
2952 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
2953
2954 if (context)
2955 {
2956 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
2957 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
2958 TextureID destIdPacked = FromGL<TextureID>(destId);
2959 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
2960 bool isCallValid = (context->skipValidation() ||
2961 ValidateCopyTextureCHROMIUM(
2962 context, sourceIdPacked, sourceLevel, destTargetPacked,
2963 destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
2964 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
2965 if (isCallValid)
2966 {
2967 context->copyTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
2968 destLevel, internalFormat, destType, unpackFlipY,
2969 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
2970 }
2971 ANGLE_CAPTURE(CopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
2972 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
2973 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
2974 }
2975 }
2976
CopySubTextureCHROMIUM(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint xoffset,GLint yoffset,GLint x,GLint y,GLint width,GLint height,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)2977 void GL_APIENTRY CopySubTextureCHROMIUM(GLuint sourceId,
2978 GLint sourceLevel,
2979 GLenum destTarget,
2980 GLuint destId,
2981 GLint destLevel,
2982 GLint xoffset,
2983 GLint yoffset,
2984 GLint x,
2985 GLint y,
2986 GLint width,
2987 GLint height,
2988 GLboolean unpackFlipY,
2989 GLboolean unpackPremultiplyAlpha,
2990 GLboolean unpackUnmultiplyAlpha)
2991 {
2992 Context *context = GetValidGlobalContext();
2993 EVENT("glCopySubTextureCHROMIUM",
2994 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
2995 "GLuint destId = %u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
2996 "x = %d, GLint y = %d, GLint width = %d, GLint height = %d, GLboolean unpackFlipY = %s, "
2997 "GLboolean unpackPremultiplyAlpha = %s, GLboolean unpackUnmultiplyAlpha = %s",
2998 CID(context), sourceId, sourceLevel,
2999 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
3000 yoffset, x, y, width, height, GLbooleanToString(unpackFlipY),
3001 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
3002
3003 if (context)
3004 {
3005 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
3006 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
3007 TextureID destIdPacked = FromGL<TextureID>(destId);
3008 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3009 bool isCallValid = (context->skipValidation() ||
3010 ValidateCopySubTextureCHROMIUM(
3011 context, sourceIdPacked, sourceLevel, destTargetPacked,
3012 destIdPacked, destLevel, xoffset, yoffset, x, y, width, height,
3013 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
3014 if (isCallValid)
3015 {
3016 context->copySubTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
3017 destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
3018 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
3019 }
3020 ANGLE_CAPTURE(CopySubTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
3021 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width,
3022 height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
3023 }
3024 }
3025
3026 // GL_CHROMIUM_framebuffer_mixed_samples
CoverageModulationCHROMIUM(GLenum components)3027 void GL_APIENTRY CoverageModulationCHROMIUM(GLenum components)
3028 {
3029 Context *context = GetValidGlobalContext();
3030 EVENT("glCoverageModulationCHROMIUM", "context = %d, GLenum components = %s", CID(context),
3031 GLenumToString(GLenumGroup::DefaultGroup, components));
3032
3033 if (context)
3034 {
3035 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3036 bool isCallValid =
3037 (context->skipValidation() || ValidateCoverageModulationCHROMIUM(context, components));
3038 if (isCallValid)
3039 {
3040 context->coverageModulation(components);
3041 }
3042 ANGLE_CAPTURE(CoverageModulationCHROMIUM, isCallValid, context, components);
3043 }
3044 }
3045
3046 // GL_CHROMIUM_lose_context
LoseContextCHROMIUM(GLenum current,GLenum other)3047 void GL_APIENTRY LoseContextCHROMIUM(GLenum current, GLenum other)
3048 {
3049 Context *context = GetValidGlobalContext();
3050 EVENT("glLoseContextCHROMIUM", "context = %d, GLenum current = %s, GLenum other = %s",
3051 CID(context), GLenumToString(GLenumGroup::GraphicsResetStatus, current),
3052 GLenumToString(GLenumGroup::GraphicsResetStatus, other));
3053
3054 if (context)
3055 {
3056 GraphicsResetStatus currentPacked = FromGL<GraphicsResetStatus>(current);
3057 GraphicsResetStatus otherPacked = FromGL<GraphicsResetStatus>(other);
3058 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3059 bool isCallValid = (context->skipValidation() ||
3060 ValidateLoseContextCHROMIUM(context, currentPacked, otherPacked));
3061 if (isCallValid)
3062 {
3063 context->loseContext(currentPacked, otherPacked);
3064 }
3065 ANGLE_CAPTURE(LoseContextCHROMIUM, isCallValid, context, currentPacked, otherPacked);
3066 }
3067 }
3068
3069 // GL_EXT_EGL_image_array
3070
3071 // GL_EXT_blend_func_extended
BindFragDataLocationEXT(GLuint program,GLuint color,const GLchar * name)3072 void GL_APIENTRY BindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
3073 {
3074 Context *context = GetValidGlobalContext();
3075 EVENT(
3076 "glBindFragDataLocationEXT",
3077 "context = %d, GLuint program = %u, GLuint color = %u, const GLchar *name = 0x%016" PRIxPTR
3078 "",
3079 CID(context), program, color, (uintptr_t)name);
3080
3081 if (context)
3082 {
3083 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
3084 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3085 bool isCallValid = (context->skipValidation() ||
3086 ValidateBindFragDataLocationEXT(context, programPacked, color, name));
3087 if (isCallValid)
3088 {
3089 context->bindFragDataLocation(programPacked, color, name);
3090 }
3091 ANGLE_CAPTURE(BindFragDataLocationEXT, isCallValid, context, programPacked, color, name);
3092 }
3093 }
3094
BindFragDataLocationIndexedEXT(GLuint program,GLuint colorNumber,GLuint index,const GLchar * name)3095 void GL_APIENTRY BindFragDataLocationIndexedEXT(GLuint program,
3096 GLuint colorNumber,
3097 GLuint index,
3098 const GLchar *name)
3099 {
3100 Context *context = GetValidGlobalContext();
3101 EVENT("glBindFragDataLocationIndexedEXT",
3102 "context = %d, GLuint program = %u, GLuint colorNumber = %u, GLuint index = %u, const "
3103 "GLchar *name = 0x%016" PRIxPTR "",
3104 CID(context), program, colorNumber, index, (uintptr_t)name);
3105
3106 if (context)
3107 {
3108 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
3109 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3110 bool isCallValid =
3111 (context->skipValidation() || ValidateBindFragDataLocationIndexedEXT(
3112 context, programPacked, colorNumber, index, name));
3113 if (isCallValid)
3114 {
3115 context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
3116 }
3117 ANGLE_CAPTURE(BindFragDataLocationIndexedEXT, isCallValid, context, programPacked,
3118 colorNumber, index, name);
3119 }
3120 }
3121
GetFragDataIndexEXT(GLuint program,const GLchar * name)3122 GLint GL_APIENTRY GetFragDataIndexEXT(GLuint program, const GLchar *name)
3123 {
3124 Context *context = GetValidGlobalContext();
3125 EVENT("glGetFragDataIndexEXT",
3126 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
3127 program, (uintptr_t)name);
3128
3129 GLint returnValue;
3130 if (context)
3131 {
3132 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
3133 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3134 bool isCallValid = (context->skipValidation() ||
3135 ValidateGetFragDataIndexEXT(context, programPacked, name));
3136 if (isCallValid)
3137 {
3138 returnValue = context->getFragDataIndex(programPacked, name);
3139 }
3140 else
3141 {
3142 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataIndexEXT, GLint>();
3143 }
3144 ANGLE_CAPTURE(GetFragDataIndexEXT, isCallValid, context, programPacked, name, returnValue);
3145 }
3146 else
3147 {
3148 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataIndexEXT, GLint>();
3149 }
3150 return returnValue;
3151 }
3152
GetProgramResourceLocationIndexEXT(GLuint program,GLenum programInterface,const GLchar * name)3153 GLint GL_APIENTRY GetProgramResourceLocationIndexEXT(GLuint program,
3154 GLenum programInterface,
3155 const GLchar *name)
3156 {
3157 Context *context = GetValidGlobalContext();
3158 EVENT("glGetProgramResourceLocationIndexEXT",
3159 "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = "
3160 "0x%016" PRIxPTR "",
3161 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
3162 (uintptr_t)name);
3163
3164 GLint returnValue;
3165 if (context)
3166 {
3167 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
3168 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3169 bool isCallValid =
3170 (context->skipValidation() || ValidateGetProgramResourceLocationIndexEXT(
3171 context, programPacked, programInterface, name));
3172 if (isCallValid)
3173 {
3174 returnValue =
3175 context->getProgramResourceLocationIndex(programPacked, programInterface, name);
3176 }
3177 else
3178 {
3179 returnValue =
3180 GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndexEXT, GLint>();
3181 }
3182 ANGLE_CAPTURE(GetProgramResourceLocationIndexEXT, isCallValid, context, programPacked,
3183 programInterface, name, returnValue);
3184 }
3185 else
3186 {
3187 returnValue =
3188 GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndexEXT, GLint>();
3189 }
3190 return returnValue;
3191 }
3192
3193 // GL_EXT_debug_marker
InsertEventMarkerEXT(GLsizei length,const GLchar * marker)3194 void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const GLchar *marker)
3195 {
3196 Context *context = GetValidGlobalContext();
3197 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
3198 // It can interfere with the debug events being set by the caller.
3199 // EVENT("glInsertEventMarkerEXT", "context = %d, GLsizei length = %d, const GLchar *marker =
3200 // 0x%016" PRIxPTR "", CID(context), length, (uintptr_t)marker);
3201
3202 if (context)
3203 {
3204 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3205 bool isCallValid =
3206 (context->skipValidation() || ValidateInsertEventMarkerEXT(context, length, marker));
3207 if (isCallValid)
3208 {
3209 context->insertEventMarker(length, marker);
3210 }
3211 ANGLE_CAPTURE(InsertEventMarkerEXT, isCallValid, context, length, marker);
3212 }
3213 }
3214
PopGroupMarkerEXT()3215 void GL_APIENTRY PopGroupMarkerEXT()
3216 {
3217 Context *context = GetValidGlobalContext();
3218 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
3219 // It can interfere with the debug events being set by the caller.
3220 // EVENT("glPopGroupMarkerEXT", "context = %d", CID(context));
3221
3222 if (context)
3223 {
3224 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3225 bool isCallValid = (context->skipValidation() || ValidatePopGroupMarkerEXT(context));
3226 if (isCallValid)
3227 {
3228 context->popGroupMarker();
3229 }
3230 ANGLE_CAPTURE(PopGroupMarkerEXT, isCallValid, context);
3231 }
3232 }
3233
PushGroupMarkerEXT(GLsizei length,const GLchar * marker)3234 void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const GLchar *marker)
3235 {
3236 Context *context = GetValidGlobalContext();
3237 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
3238 // It can interfere with the debug events being set by the caller.
3239 // EVENT("glPushGroupMarkerEXT", "context = %d, GLsizei length = %d, const GLchar *marker =
3240 // 0x%016" PRIxPTR "", CID(context), length, (uintptr_t)marker);
3241
3242 if (context)
3243 {
3244 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3245 bool isCallValid =
3246 (context->skipValidation() || ValidatePushGroupMarkerEXT(context, length, marker));
3247 if (isCallValid)
3248 {
3249 context->pushGroupMarker(length, marker);
3250 }
3251 ANGLE_CAPTURE(PushGroupMarkerEXT, isCallValid, context, length, marker);
3252 }
3253 }
3254
3255 // GL_EXT_discard_framebuffer
DiscardFramebufferEXT(GLenum target,GLsizei numAttachments,const GLenum * attachments)3256 void GL_APIENTRY DiscardFramebufferEXT(GLenum target,
3257 GLsizei numAttachments,
3258 const GLenum *attachments)
3259 {
3260 Context *context = GetValidGlobalContext();
3261 EVENT("glDiscardFramebufferEXT",
3262 "context = %d, GLenum target = %s, GLsizei numAttachments = %d, const GLenum "
3263 "*attachments = 0x%016" PRIxPTR "",
3264 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), numAttachments,
3265 (uintptr_t)attachments);
3266
3267 if (context)
3268 {
3269 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3270 bool isCallValid =
3271 (context->skipValidation() ||
3272 ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments));
3273 if (isCallValid)
3274 {
3275 context->discardFramebuffer(target, numAttachments, attachments);
3276 }
3277 ANGLE_CAPTURE(DiscardFramebufferEXT, isCallValid, context, target, numAttachments,
3278 attachments);
3279 }
3280 }
3281
3282 // GL_EXT_disjoint_timer_query
BeginQueryEXT(GLenum target,GLuint id)3283 void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id)
3284 {
3285 Context *context = GetValidGlobalContext();
3286 EVENT("glBeginQueryEXT", "context = %d, GLenum target = %s, GLuint id = %u", CID(context),
3287 GLenumToString(GLenumGroup::QueryTarget, target), id);
3288
3289 if (context)
3290 {
3291 QueryType targetPacked = FromGL<QueryType>(target);
3292 QueryID idPacked = FromGL<QueryID>(id);
3293 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3294 bool isCallValid =
3295 (context->skipValidation() || ValidateBeginQueryEXT(context, targetPacked, idPacked));
3296 if (isCallValid)
3297 {
3298 context->beginQuery(targetPacked, idPacked);
3299 }
3300 ANGLE_CAPTURE(BeginQueryEXT, isCallValid, context, targetPacked, idPacked);
3301 }
3302 }
3303
DeleteQueriesEXT(GLsizei n,const GLuint * ids)3304 void GL_APIENTRY DeleteQueriesEXT(GLsizei n, const GLuint *ids)
3305 {
3306 Context *context = GetValidGlobalContext();
3307 EVENT("glDeleteQueriesEXT",
3308 "context = %d, GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
3309 (uintptr_t)ids);
3310
3311 if (context)
3312 {
3313 const QueryID *idsPacked = FromGL<const QueryID *>(ids);
3314 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3315 bool isCallValid =
3316 (context->skipValidation() || ValidateDeleteQueriesEXT(context, n, idsPacked));
3317 if (isCallValid)
3318 {
3319 context->deleteQueries(n, idsPacked);
3320 }
3321 ANGLE_CAPTURE(DeleteQueriesEXT, isCallValid, context, n, idsPacked);
3322 }
3323 }
3324
EndQueryEXT(GLenum target)3325 void GL_APIENTRY EndQueryEXT(GLenum target)
3326 {
3327 Context *context = GetValidGlobalContext();
3328 EVENT("glEndQueryEXT", "context = %d, GLenum target = %s", CID(context),
3329 GLenumToString(GLenumGroup::QueryTarget, target));
3330
3331 if (context)
3332 {
3333 QueryType targetPacked = FromGL<QueryType>(target);
3334 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3335 bool isCallValid =
3336 (context->skipValidation() || ValidateEndQueryEXT(context, targetPacked));
3337 if (isCallValid)
3338 {
3339 context->endQuery(targetPacked);
3340 }
3341 ANGLE_CAPTURE(EndQueryEXT, isCallValid, context, targetPacked);
3342 }
3343 }
3344
GenQueriesEXT(GLsizei n,GLuint * ids)3345 void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint *ids)
3346 {
3347 Context *context = GetValidGlobalContext();
3348 EVENT("glGenQueriesEXT", "context = %d, GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR "",
3349 CID(context), n, (uintptr_t)ids);
3350
3351 if (context)
3352 {
3353 QueryID *idsPacked = FromGL<QueryID *>(ids);
3354 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3355 bool isCallValid =
3356 (context->skipValidation() || ValidateGenQueriesEXT(context, n, idsPacked));
3357 if (isCallValid)
3358 {
3359 context->genQueries(n, idsPacked);
3360 }
3361 ANGLE_CAPTURE(GenQueriesEXT, isCallValid, context, n, idsPacked);
3362 }
3363 }
3364
GetInteger64vEXT(GLenum pname,GLint64 * data)3365 void GL_APIENTRY GetInteger64vEXT(GLenum pname, GLint64 *data)
3366 {
3367 Context *context = GetValidGlobalContext();
3368 EVENT("glGetInteger64vEXT",
3369 "context = %d, GLenum pname = %s, GLint64 *data = 0x%016" PRIxPTR "", CID(context),
3370 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
3371
3372 if (context)
3373 {
3374 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3375 bool isCallValid =
3376 (context->skipValidation() || ValidateGetInteger64vEXT(context, pname, data));
3377 if (isCallValid)
3378 {
3379 context->getInteger64v(pname, data);
3380 }
3381 ANGLE_CAPTURE(GetInteger64vEXT, isCallValid, context, pname, data);
3382 }
3383 }
3384
GetQueryObjecti64vEXT(GLuint id,GLenum pname,GLint64 * params)3385 void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
3386 {
3387 Context *context = GetGlobalContext();
3388 EVENT("glGetQueryObjecti64vEXT",
3389 "context = %d, GLuint id = %u, GLenum pname = %s, GLint64 *params = 0x%016" PRIxPTR "",
3390 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
3391 (uintptr_t)params);
3392
3393 if (context)
3394 {
3395 QueryID idPacked = FromGL<QueryID>(id);
3396 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3397 bool isCallValid = (context->skipValidation() ||
3398 ValidateGetQueryObjecti64vEXT(context, idPacked, pname, params));
3399 if (isCallValid)
3400 {
3401 context->getQueryObjecti64v(idPacked, pname, params);
3402 }
3403 ANGLE_CAPTURE(GetQueryObjecti64vEXT, isCallValid, context, idPacked, pname, params);
3404 }
3405 }
3406
GetQueryObjectivEXT(GLuint id,GLenum pname,GLint * params)3407 void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
3408 {
3409 Context *context = GetGlobalContext();
3410 EVENT("glGetQueryObjectivEXT",
3411 "context = %d, GLuint id = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
3412 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
3413 (uintptr_t)params);
3414
3415 if (context)
3416 {
3417 QueryID idPacked = FromGL<QueryID>(id);
3418 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3419 bool isCallValid = (context->skipValidation() ||
3420 ValidateGetQueryObjectivEXT(context, idPacked, pname, params));
3421 if (isCallValid)
3422 {
3423 context->getQueryObjectiv(idPacked, pname, params);
3424 }
3425 ANGLE_CAPTURE(GetQueryObjectivEXT, isCallValid, context, idPacked, pname, params);
3426 }
3427 }
3428
GetQueryObjectui64vEXT(GLuint id,GLenum pname,GLuint64 * params)3429 void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
3430 {
3431 Context *context = GetValidGlobalContext();
3432 EVENT("glGetQueryObjectui64vEXT",
3433 "context = %d, GLuint id = %u, GLenum pname = %s, GLuint64 *params = 0x%016" PRIxPTR "",
3434 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
3435 (uintptr_t)params);
3436
3437 if (context)
3438 {
3439 QueryID idPacked = FromGL<QueryID>(id);
3440 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3441 bool isCallValid = (context->skipValidation() ||
3442 ValidateGetQueryObjectui64vEXT(context, idPacked, pname, params));
3443 if (isCallValid)
3444 {
3445 context->getQueryObjectui64v(idPacked, pname, params);
3446 }
3447 ANGLE_CAPTURE(GetQueryObjectui64vEXT, isCallValid, context, idPacked, pname, params);
3448 }
3449 }
3450
GetQueryObjectuivEXT(GLuint id,GLenum pname,GLuint * params)3451 void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
3452 {
3453 Context *context = GetValidGlobalContext();
3454 EVENT("glGetQueryObjectuivEXT",
3455 "context = %d, GLuint id = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
3456 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
3457 (uintptr_t)params);
3458
3459 if (context)
3460 {
3461 QueryID idPacked = FromGL<QueryID>(id);
3462 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3463 bool isCallValid = (context->skipValidation() ||
3464 ValidateGetQueryObjectuivEXT(context, idPacked, pname, params));
3465 if (isCallValid)
3466 {
3467 context->getQueryObjectuiv(idPacked, pname, params);
3468 }
3469 ANGLE_CAPTURE(GetQueryObjectuivEXT, isCallValid, context, idPacked, pname, params);
3470 }
3471 }
3472
GetQueryivEXT(GLenum target,GLenum pname,GLint * params)3473 void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params)
3474 {
3475 Context *context = GetValidGlobalContext();
3476 EVENT("glGetQueryivEXT",
3477 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
3478 CID(context), GLenumToString(GLenumGroup::QueryTarget, target),
3479 GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
3480
3481 if (context)
3482 {
3483 QueryType targetPacked = FromGL<QueryType>(target);
3484 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3485 bool isCallValid = (context->skipValidation() ||
3486 ValidateGetQueryivEXT(context, targetPacked, pname, params));
3487 if (isCallValid)
3488 {
3489 context->getQueryiv(targetPacked, pname, params);
3490 }
3491 ANGLE_CAPTURE(GetQueryivEXT, isCallValid, context, targetPacked, pname, params);
3492 }
3493 }
3494
IsQueryEXT(GLuint id)3495 GLboolean GL_APIENTRY IsQueryEXT(GLuint id)
3496 {
3497 Context *context = GetValidGlobalContext();
3498 EVENT("glIsQueryEXT", "context = %d, GLuint id = %u", CID(context), id);
3499
3500 GLboolean returnValue;
3501 if (context)
3502 {
3503 QueryID idPacked = FromGL<QueryID>(id);
3504 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3505 bool isCallValid = (context->skipValidation() || ValidateIsQueryEXT(context, idPacked));
3506 if (isCallValid)
3507 {
3508 returnValue = context->isQuery(idPacked);
3509 }
3510 else
3511 {
3512 returnValue = GetDefaultReturnValue<EntryPoint::IsQueryEXT, GLboolean>();
3513 }
3514 ANGLE_CAPTURE(IsQueryEXT, isCallValid, context, idPacked, returnValue);
3515 }
3516 else
3517 {
3518 returnValue = GetDefaultReturnValue<EntryPoint::IsQueryEXT, GLboolean>();
3519 }
3520 return returnValue;
3521 }
3522
QueryCounterEXT(GLuint id,GLenum target)3523 void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target)
3524 {
3525 Context *context = GetValidGlobalContext();
3526 EVENT("glQueryCounterEXT", "context = %d, GLuint id = %u, GLenum target = %s", CID(context), id,
3527 GLenumToString(GLenumGroup::QueryTarget, target));
3528
3529 if (context)
3530 {
3531 QueryID idPacked = FromGL<QueryID>(id);
3532 QueryType targetPacked = FromGL<QueryType>(target);
3533 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3534 bool isCallValid =
3535 (context->skipValidation() || ValidateQueryCounterEXT(context, idPacked, targetPacked));
3536 if (isCallValid)
3537 {
3538 context->queryCounter(idPacked, targetPacked);
3539 }
3540 ANGLE_CAPTURE(QueryCounterEXT, isCallValid, context, idPacked, targetPacked);
3541 }
3542 }
3543
3544 // GL_EXT_draw_buffers
DrawBuffersEXT(GLsizei n,const GLenum * bufs)3545 void GL_APIENTRY DrawBuffersEXT(GLsizei n, const GLenum *bufs)
3546 {
3547 Context *context = GetValidGlobalContext();
3548 EVENT("glDrawBuffersEXT",
3549 "context = %d, GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR "", CID(context), n,
3550 (uintptr_t)bufs);
3551
3552 if (context)
3553 {
3554 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3555 bool isCallValid = (context->skipValidation() || ValidateDrawBuffersEXT(context, n, bufs));
3556 if (isCallValid)
3557 {
3558 context->drawBuffers(n, bufs);
3559 }
3560 ANGLE_CAPTURE(DrawBuffersEXT, isCallValid, context, n, bufs);
3561 }
3562 }
3563
3564 // GL_EXT_draw_buffers_indexed
BlendEquationSeparateiEXT(GLuint buf,GLenum modeRGB,GLenum modeAlpha)3565 void GL_APIENTRY BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
3566 {
3567 Context *context = GetValidGlobalContext();
3568 EVENT("glBlendEquationSeparateiEXT",
3569 "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
3570 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
3571 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
3572
3573 if (context)
3574 {
3575 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3576 bool isCallValid = (context->skipValidation() ||
3577 ValidateBlendEquationSeparateiEXT(context, buf, modeRGB, modeAlpha));
3578 if (isCallValid)
3579 {
3580 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
3581 }
3582 ANGLE_CAPTURE(BlendEquationSeparateiEXT, isCallValid, context, buf, modeRGB, modeAlpha);
3583 }
3584 }
3585
BlendEquationiEXT(GLuint buf,GLenum mode)3586 void GL_APIENTRY BlendEquationiEXT(GLuint buf, GLenum mode)
3587 {
3588 Context *context = GetValidGlobalContext();
3589 EVENT("glBlendEquationiEXT", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context),
3590 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
3591
3592 if (context)
3593 {
3594 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3595 bool isCallValid =
3596 (context->skipValidation() || ValidateBlendEquationiEXT(context, buf, mode));
3597 if (isCallValid)
3598 {
3599 context->blendEquationi(buf, mode);
3600 }
3601 ANGLE_CAPTURE(BlendEquationiEXT, isCallValid, context, buf, mode);
3602 }
3603 }
3604
3605 void GL_APIENTRY
BlendFuncSeparateiEXT(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)3606 BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
3607 {
3608 Context *context = GetValidGlobalContext();
3609 EVENT("glBlendFuncSeparateiEXT",
3610 "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
3611 "= %s, GLenum dstAlpha = %s",
3612 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
3613 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
3614 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
3615 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
3616
3617 if (context)
3618 {
3619 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3620 bool isCallValid =
3621 (context->skipValidation() ||
3622 ValidateBlendFuncSeparateiEXT(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
3623 if (isCallValid)
3624 {
3625 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
3626 }
3627 ANGLE_CAPTURE(BlendFuncSeparateiEXT, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
3628 dstAlpha);
3629 }
3630 }
3631
BlendFunciEXT(GLuint buf,GLenum src,GLenum dst)3632 void GL_APIENTRY BlendFunciEXT(GLuint buf, GLenum src, GLenum dst)
3633 {
3634 Context *context = GetValidGlobalContext();
3635 EVENT("glBlendFunciEXT", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
3636 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
3637 GLenumToString(GLenumGroup::BlendingFactor, dst));
3638
3639 if (context)
3640 {
3641 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3642 bool isCallValid =
3643 (context->skipValidation() || ValidateBlendFunciEXT(context, buf, src, dst));
3644 if (isCallValid)
3645 {
3646 context->blendFunci(buf, src, dst);
3647 }
3648 ANGLE_CAPTURE(BlendFunciEXT, isCallValid, context, buf, src, dst);
3649 }
3650 }
3651
ColorMaskiEXT(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)3652 void GL_APIENTRY ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
3653 {
3654 Context *context = GetValidGlobalContext();
3655 EVENT("glColorMaskiEXT",
3656 "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
3657 "GLboolean a = %s",
3658 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
3659 GLbooleanToString(a));
3660
3661 if (context)
3662 {
3663 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3664 bool isCallValid =
3665 (context->skipValidation() || ValidateColorMaskiEXT(context, index, r, g, b, a));
3666 if (isCallValid)
3667 {
3668 context->colorMaski(index, r, g, b, a);
3669 }
3670 ANGLE_CAPTURE(ColorMaskiEXT, isCallValid, context, index, r, g, b, a);
3671 }
3672 }
3673
DisableiEXT(GLenum target,GLuint index)3674 void GL_APIENTRY DisableiEXT(GLenum target, GLuint index)
3675 {
3676 Context *context = GetValidGlobalContext();
3677 EVENT("glDisableiEXT", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
3678 GLenumToString(GLenumGroup::EnableCap, target), index);
3679
3680 if (context)
3681 {
3682 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3683 bool isCallValid =
3684 (context->skipValidation() || ValidateDisableiEXT(context, target, index));
3685 if (isCallValid)
3686 {
3687 context->disablei(target, index);
3688 }
3689 ANGLE_CAPTURE(DisableiEXT, isCallValid, context, target, index);
3690 }
3691 }
3692
EnableiEXT(GLenum target,GLuint index)3693 void GL_APIENTRY EnableiEXT(GLenum target, GLuint index)
3694 {
3695 Context *context = GetValidGlobalContext();
3696 EVENT("glEnableiEXT", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
3697 GLenumToString(GLenumGroup::EnableCap, target), index);
3698
3699 if (context)
3700 {
3701 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3702 bool isCallValid =
3703 (context->skipValidation() || ValidateEnableiEXT(context, target, index));
3704 if (isCallValid)
3705 {
3706 context->enablei(target, index);
3707 }
3708 ANGLE_CAPTURE(EnableiEXT, isCallValid, context, target, index);
3709 }
3710 }
3711
IsEnablediEXT(GLenum target,GLuint index)3712 GLboolean GL_APIENTRY IsEnablediEXT(GLenum target, GLuint index)
3713 {
3714 Context *context = GetValidGlobalContext();
3715 EVENT("glIsEnablediEXT", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
3716 GLenumToString(GLenumGroup::EnableCap, target), index);
3717
3718 GLboolean returnValue;
3719 if (context)
3720 {
3721 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3722 bool isCallValid =
3723 (context->skipValidation() || ValidateIsEnablediEXT(context, target, index));
3724 if (isCallValid)
3725 {
3726 returnValue = context->isEnabledi(target, index);
3727 }
3728 else
3729 {
3730 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediEXT, GLboolean>();
3731 }
3732 ANGLE_CAPTURE(IsEnablediEXT, isCallValid, context, target, index, returnValue);
3733 }
3734 else
3735 {
3736 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediEXT, GLboolean>();
3737 }
3738 return returnValue;
3739 }
3740
3741 // GL_EXT_draw_elements_base_vertex
DrawElementsBaseVertexEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)3742 void GL_APIENTRY DrawElementsBaseVertexEXT(GLenum mode,
3743 GLsizei count,
3744 GLenum type,
3745 const void *indices,
3746 GLint basevertex)
3747 {
3748 Context *context = GetValidGlobalContext();
3749 EVENT("glDrawElementsBaseVertexEXT",
3750 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
3751 "*indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
3752 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
3753 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
3754
3755 if (context)
3756 {
3757 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
3758 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
3759 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3760 bool isCallValid = (context->skipValidation() ||
3761 ValidateDrawElementsBaseVertexEXT(context, modePacked, count,
3762 typePacked, indices, basevertex));
3763 if (isCallValid)
3764 {
3765 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
3766 }
3767 ANGLE_CAPTURE(DrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
3768 typePacked, indices, basevertex);
3769 }
3770 }
3771
DrawElementsInstancedBaseVertexEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)3772 void GL_APIENTRY DrawElementsInstancedBaseVertexEXT(GLenum mode,
3773 GLsizei count,
3774 GLenum type,
3775 const void *indices,
3776 GLsizei instancecount,
3777 GLint basevertex)
3778 {
3779 Context *context = GetValidGlobalContext();
3780 EVENT("glDrawElementsInstancedBaseVertexEXT",
3781 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
3782 "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d, GLint basevertex = %d",
3783 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
3784 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
3785 basevertex);
3786
3787 if (context)
3788 {
3789 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
3790 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
3791 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3792 bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexEXT(
3793 context, modePacked, count, typePacked,
3794 indices, instancecount, basevertex));
3795 if (isCallValid)
3796 {
3797 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
3798 instancecount, basevertex);
3799 }
3800 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexEXT, isCallValid, context, modePacked, count,
3801 typePacked, indices, instancecount, basevertex);
3802 }
3803 }
3804
DrawRangeElementsBaseVertexEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)3805 void GL_APIENTRY DrawRangeElementsBaseVertexEXT(GLenum mode,
3806 GLuint start,
3807 GLuint end,
3808 GLsizei count,
3809 GLenum type,
3810 const void *indices,
3811 GLint basevertex)
3812 {
3813 Context *context = GetValidGlobalContext();
3814 EVENT("glDrawRangeElementsBaseVertexEXT",
3815 "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
3816 "GLenum type = %s, const void *indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
3817 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
3818 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
3819
3820 if (context)
3821 {
3822 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
3823 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
3824 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3825 bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertexEXT(
3826 context, modePacked, start, end, count,
3827 typePacked, indices, basevertex));
3828 if (isCallValid)
3829 {
3830 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
3831 basevertex);
3832 }
3833 ANGLE_CAPTURE(DrawRangeElementsBaseVertexEXT, isCallValid, context, modePacked, start, end,
3834 count, typePacked, indices, basevertex);
3835 }
3836 }
3837
MultiDrawElementsBaseVertexEXT(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei primcount,const GLint * basevertex)3838 void GL_APIENTRY MultiDrawElementsBaseVertexEXT(GLenum mode,
3839 const GLsizei *count,
3840 GLenum type,
3841 const void *const *indices,
3842 GLsizei primcount,
3843 const GLint *basevertex)
3844 {
3845 Context *context = GetValidGlobalContext();
3846 EVENT("glMultiDrawElementsBaseVertexEXT",
3847 "context = %d, GLenum mode = %s, const GLsizei *count = 0x%016" PRIxPTR
3848 ", GLenum type = %s, const void *const*indices = 0x%016" PRIxPTR
3849 ", GLsizei primcount = %d, const GLint *basevertex = 0x%016" PRIxPTR "",
3850 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count,
3851 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount,
3852 (uintptr_t)basevertex);
3853
3854 if (context)
3855 {
3856 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
3857 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
3858 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3859 bool isCallValid = (context->skipValidation() || ValidateMultiDrawElementsBaseVertexEXT(
3860 context, modePacked, count, typePacked,
3861 indices, primcount, basevertex));
3862 if (isCallValid)
3863 {
3864 context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, primcount,
3865 basevertex);
3866 }
3867 ANGLE_CAPTURE(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
3868 typePacked, indices, primcount, basevertex);
3869 }
3870 }
3871
3872 // GL_EXT_geometry_shader
FramebufferTextureEXT(GLenum target,GLenum attachment,GLuint texture,GLint level)3873 void GL_APIENTRY FramebufferTextureEXT(GLenum target,
3874 GLenum attachment,
3875 GLuint texture,
3876 GLint level)
3877 {
3878 Context *context = GetValidGlobalContext();
3879 EVENT("glFramebufferTextureEXT",
3880 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
3881 "level = %d",
3882 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
3883 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
3884
3885 if (context)
3886 {
3887 TextureID texturePacked = FromGL<TextureID>(texture);
3888 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3889 bool isCallValid =
3890 (context->skipValidation() ||
3891 ValidateFramebufferTextureEXT(context, target, attachment, texturePacked, level));
3892 if (isCallValid)
3893 {
3894 context->framebufferTexture(target, attachment, texturePacked, level);
3895 }
3896 ANGLE_CAPTURE(FramebufferTextureEXT, isCallValid, context, target, attachment,
3897 texturePacked, level);
3898 }
3899 }
3900
3901 // GL_EXT_instanced_arrays
DrawArraysInstancedEXT(GLenum mode,GLint start,GLsizei count,GLsizei primcount)3902 void GL_APIENTRY DrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount)
3903 {
3904 Context *context = GetValidGlobalContext();
3905 EVENT("glDrawArraysInstancedEXT",
3906 "context = %d, GLenum mode = %s, GLint start = %d, GLsizei count = %d, GLsizei primcount "
3907 "= %d",
3908 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, count, primcount);
3909
3910 if (context)
3911 {
3912 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
3913 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3914 bool isCallValid =
3915 (context->skipValidation() ||
3916 ValidateDrawArraysInstancedEXT(context, modePacked, start, count, primcount));
3917 if (isCallValid)
3918 {
3919 context->drawArraysInstanced(modePacked, start, count, primcount);
3920 }
3921 ANGLE_CAPTURE(DrawArraysInstancedEXT, isCallValid, context, modePacked, start, count,
3922 primcount);
3923 }
3924 }
3925
DrawElementsInstancedEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)3926 void GL_APIENTRY DrawElementsInstancedEXT(GLenum mode,
3927 GLsizei count,
3928 GLenum type,
3929 const void *indices,
3930 GLsizei primcount)
3931 {
3932 Context *context = GetValidGlobalContext();
3933 EVENT("glDrawElementsInstancedEXT",
3934 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
3935 "*indices = 0x%016" PRIxPTR ", GLsizei primcount = %d",
3936 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
3937 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount);
3938
3939 if (context)
3940 {
3941 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
3942 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
3943 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3944 bool isCallValid = (context->skipValidation() ||
3945 ValidateDrawElementsInstancedEXT(context, modePacked, count, typePacked,
3946 indices, primcount));
3947 if (isCallValid)
3948 {
3949 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
3950 }
3951 ANGLE_CAPTURE(DrawElementsInstancedEXT, isCallValid, context, modePacked, count, typePacked,
3952 indices, primcount);
3953 }
3954 }
3955
VertexAttribDivisorEXT(GLuint index,GLuint divisor)3956 void GL_APIENTRY VertexAttribDivisorEXT(GLuint index, GLuint divisor)
3957 {
3958 Context *context = GetValidGlobalContext();
3959 EVENT("glVertexAttribDivisorEXT", "context = %d, GLuint index = %u, GLuint divisor = %u",
3960 CID(context), index, divisor);
3961
3962 if (context)
3963 {
3964 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3965 bool isCallValid =
3966 (context->skipValidation() || ValidateVertexAttribDivisorEXT(context, index, divisor));
3967 if (isCallValid)
3968 {
3969 context->vertexAttribDivisor(index, divisor);
3970 }
3971 ANGLE_CAPTURE(VertexAttribDivisorEXT, isCallValid, context, index, divisor);
3972 }
3973 }
3974
3975 // GL_EXT_map_buffer_range
FlushMappedBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length)3976 void GL_APIENTRY FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
3977 {
3978 Context *context = GetValidGlobalContext();
3979 EVENT("glFlushMappedBufferRangeEXT",
3980 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu",
3981 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
3982 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
3983
3984 if (context)
3985 {
3986 BufferBinding targetPacked = FromGL<BufferBinding>(target);
3987 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
3988 bool isCallValid =
3989 (context->skipValidation() ||
3990 ValidateFlushMappedBufferRangeEXT(context, targetPacked, offset, length));
3991 if (isCallValid)
3992 {
3993 context->flushMappedBufferRange(targetPacked, offset, length);
3994 }
3995 ANGLE_CAPTURE(FlushMappedBufferRangeEXT, isCallValid, context, targetPacked, offset,
3996 length);
3997 }
3998 }
3999
MapBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)4000 void *GL_APIENTRY MapBufferRangeEXT(GLenum target,
4001 GLintptr offset,
4002 GLsizeiptr length,
4003 GLbitfield access)
4004 {
4005 Context *context = GetValidGlobalContext();
4006 EVENT("glMapBufferRangeEXT",
4007 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu, "
4008 "GLbitfield access = %s",
4009 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
4010 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
4011 GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
4012
4013 void *returnValue;
4014 if (context)
4015 {
4016 BufferBinding targetPacked = FromGL<BufferBinding>(target);
4017 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4018 bool isCallValid =
4019 (context->skipValidation() ||
4020 ValidateMapBufferRangeEXT(context, targetPacked, offset, length, access));
4021 if (isCallValid)
4022 {
4023 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
4024 }
4025 else
4026 {
4027 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRangeEXT, void *>();
4028 }
4029 ANGLE_CAPTURE(MapBufferRangeEXT, isCallValid, context, targetPacked, offset, length, access,
4030 returnValue);
4031 }
4032 else
4033 {
4034 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRangeEXT, void *>();
4035 }
4036 return returnValue;
4037 }
4038
4039 // GL_EXT_memory_object
BufferStorageMemEXT(GLenum target,GLsizeiptr size,GLuint memory,GLuint64 offset)4040 void GL_APIENTRY BufferStorageMemEXT(GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset)
4041 {
4042 Context *context = GetValidGlobalContext();
4043 EVENT("glBufferStorageMemEXT",
4044 "context = %d, GLenum target = %s, GLsizeiptr size = %llu, GLuint memory = %u, GLuint64 "
4045 "offset = %llu",
4046 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
4047 static_cast<unsigned long long>(size), memory, static_cast<unsigned long long>(offset));
4048
4049 if (context)
4050 {
4051 TextureType targetPacked = FromGL<TextureType>(target);
4052 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
4053 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4054 bool isCallValid =
4055 (context->skipValidation() ||
4056 ValidateBufferStorageMemEXT(context, targetPacked, size, memoryPacked, offset));
4057 if (isCallValid)
4058 {
4059 context->bufferStorageMem(targetPacked, size, memoryPacked, offset);
4060 }
4061 ANGLE_CAPTURE(BufferStorageMemEXT, isCallValid, context, targetPacked, size, memoryPacked,
4062 offset);
4063 }
4064 }
4065
CreateMemoryObjectsEXT(GLsizei n,GLuint * memoryObjects)4066 void GL_APIENTRY CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
4067 {
4068 Context *context = GetValidGlobalContext();
4069 EVENT("glCreateMemoryObjectsEXT",
4070 "context = %d, GLsizei n = %d, GLuint *memoryObjects = 0x%016" PRIxPTR "", CID(context),
4071 n, (uintptr_t)memoryObjects);
4072
4073 if (context)
4074 {
4075 MemoryObjectID *memoryObjectsPacked = FromGL<MemoryObjectID *>(memoryObjects);
4076 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4077 bool isCallValid = (context->skipValidation() ||
4078 ValidateCreateMemoryObjectsEXT(context, n, memoryObjectsPacked));
4079 if (isCallValid)
4080 {
4081 context->createMemoryObjects(n, memoryObjectsPacked);
4082 }
4083 ANGLE_CAPTURE(CreateMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
4084 }
4085 }
4086
DeleteMemoryObjectsEXT(GLsizei n,const GLuint * memoryObjects)4087 void GL_APIENTRY DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
4088 {
4089 Context *context = GetValidGlobalContext();
4090 EVENT("glDeleteMemoryObjectsEXT",
4091 "context = %d, GLsizei n = %d, const GLuint *memoryObjects = 0x%016" PRIxPTR "",
4092 CID(context), n, (uintptr_t)memoryObjects);
4093
4094 if (context)
4095 {
4096 const MemoryObjectID *memoryObjectsPacked = FromGL<const MemoryObjectID *>(memoryObjects);
4097 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4098 bool isCallValid = (context->skipValidation() ||
4099 ValidateDeleteMemoryObjectsEXT(context, n, memoryObjectsPacked));
4100 if (isCallValid)
4101 {
4102 context->deleteMemoryObjects(n, memoryObjectsPacked);
4103 }
4104 ANGLE_CAPTURE(DeleteMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
4105 }
4106 }
4107
GetMemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,GLint * params)4108 void GL_APIENTRY GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
4109 {
4110 Context *context = GetValidGlobalContext();
4111 EVENT(
4112 "glGetMemoryObjectParameterivEXT",
4113 "context = %d, GLuint memoryObject = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
4114 "",
4115 CID(context), memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
4116 (uintptr_t)params);
4117
4118 if (context)
4119 {
4120 MemoryObjectID memoryObjectPacked = FromGL<MemoryObjectID>(memoryObject);
4121 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4122 bool isCallValid =
4123 (context->skipValidation() ||
4124 ValidateGetMemoryObjectParameterivEXT(context, memoryObjectPacked, pname, params));
4125 if (isCallValid)
4126 {
4127 context->getMemoryObjectParameteriv(memoryObjectPacked, pname, params);
4128 }
4129 ANGLE_CAPTURE(GetMemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked,
4130 pname, params);
4131 }
4132 }
4133
GetUnsignedBytevEXT(GLenum pname,GLubyte * data)4134 void GL_APIENTRY GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
4135 {
4136 Context *context = GetValidGlobalContext();
4137 EVENT("glGetUnsignedBytevEXT",
4138 "context = %d, GLenum pname = %s, GLubyte *data = 0x%016" PRIxPTR "", CID(context),
4139 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
4140
4141 if (context)
4142 {
4143 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4144 bool isCallValid =
4145 (context->skipValidation() || ValidateGetUnsignedBytevEXT(context, pname, data));
4146 if (isCallValid)
4147 {
4148 context->getUnsignedBytev(pname, data);
4149 }
4150 ANGLE_CAPTURE(GetUnsignedBytevEXT, isCallValid, context, pname, data);
4151 }
4152 }
4153
GetUnsignedBytei_vEXT(GLenum target,GLuint index,GLubyte * data)4154 void GL_APIENTRY GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
4155 {
4156 Context *context = GetValidGlobalContext();
4157 EVENT("glGetUnsignedBytei_vEXT",
4158 "context = %d, GLenum target = %s, GLuint index = %u, GLubyte *data = 0x%016" PRIxPTR "",
4159 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, (uintptr_t)data);
4160
4161 if (context)
4162 {
4163 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4164 bool isCallValid = (context->skipValidation() ||
4165 ValidateGetUnsignedBytei_vEXT(context, target, index, data));
4166 if (isCallValid)
4167 {
4168 context->getUnsignedBytei_v(target, index, data);
4169 }
4170 ANGLE_CAPTURE(GetUnsignedBytei_vEXT, isCallValid, context, target, index, data);
4171 }
4172 }
4173
IsMemoryObjectEXT(GLuint memoryObject)4174 GLboolean GL_APIENTRY IsMemoryObjectEXT(GLuint memoryObject)
4175 {
4176 Context *context = GetValidGlobalContext();
4177 EVENT("glIsMemoryObjectEXT", "context = %d, GLuint memoryObject = %u", CID(context),
4178 memoryObject);
4179
4180 GLboolean returnValue;
4181 if (context)
4182 {
4183 MemoryObjectID memoryObjectPacked = FromGL<MemoryObjectID>(memoryObject);
4184 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4185 bool isCallValid =
4186 (context->skipValidation() || ValidateIsMemoryObjectEXT(context, memoryObjectPacked));
4187 if (isCallValid)
4188 {
4189 returnValue = context->isMemoryObject(memoryObjectPacked);
4190 }
4191 else
4192 {
4193 returnValue = GetDefaultReturnValue<EntryPoint::IsMemoryObjectEXT, GLboolean>();
4194 }
4195 ANGLE_CAPTURE(IsMemoryObjectEXT, isCallValid, context, memoryObjectPacked, returnValue);
4196 }
4197 else
4198 {
4199 returnValue = GetDefaultReturnValue<EntryPoint::IsMemoryObjectEXT, GLboolean>();
4200 }
4201 return returnValue;
4202 }
4203
MemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,const GLint * params)4204 void GL_APIENTRY MemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, const GLint *params)
4205 {
4206 Context *context = GetValidGlobalContext();
4207 EVENT("glMemoryObjectParameterivEXT",
4208 "context = %d, GLuint memoryObject = %u, GLenum pname = %s, const GLint *params = "
4209 "0x%016" PRIxPTR "",
4210 CID(context), memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
4211 (uintptr_t)params);
4212
4213 if (context)
4214 {
4215 MemoryObjectID memoryObjectPacked = FromGL<MemoryObjectID>(memoryObject);
4216 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4217 bool isCallValid =
4218 (context->skipValidation() ||
4219 ValidateMemoryObjectParameterivEXT(context, memoryObjectPacked, pname, params));
4220 if (isCallValid)
4221 {
4222 context->memoryObjectParameteriv(memoryObjectPacked, pname, params);
4223 }
4224 ANGLE_CAPTURE(MemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked, pname,
4225 params);
4226 }
4227 }
4228
TexStorageMem2DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset)4229 void GL_APIENTRY TexStorageMem2DEXT(GLenum target,
4230 GLsizei levels,
4231 GLenum internalFormat,
4232 GLsizei width,
4233 GLsizei height,
4234 GLuint memory,
4235 GLuint64 offset)
4236 {
4237 Context *context = GetValidGlobalContext();
4238 EVENT("glTexStorageMem2DEXT",
4239 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalFormat = %s, "
4240 "GLsizei width = %d, GLsizei height = %d, GLuint memory = %u, GLuint64 offset = %llu",
4241 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
4242 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory,
4243 static_cast<unsigned long long>(offset));
4244
4245 if (context)
4246 {
4247 TextureType targetPacked = FromGL<TextureType>(target);
4248 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
4249 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4250 bool isCallValid =
4251 (context->skipValidation() ||
4252 ValidateTexStorageMem2DEXT(context, targetPacked, levels, internalFormat, width,
4253 height, memoryPacked, offset));
4254 if (isCallValid)
4255 {
4256 context->texStorageMem2D(targetPacked, levels, internalFormat, width, height,
4257 memoryPacked, offset);
4258 }
4259 ANGLE_CAPTURE(TexStorageMem2DEXT, isCallValid, context, targetPacked, levels,
4260 internalFormat, width, height, memoryPacked, offset);
4261 }
4262 }
4263
TexStorageMem2DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)4264 void GL_APIENTRY TexStorageMem2DMultisampleEXT(GLenum target,
4265 GLsizei samples,
4266 GLenum internalFormat,
4267 GLsizei width,
4268 GLsizei height,
4269 GLboolean fixedSampleLocations,
4270 GLuint memory,
4271 GLuint64 offset)
4272 {
4273 Context *context = GetValidGlobalContext();
4274 EVENT("glTexStorageMem2DMultisampleEXT",
4275 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalFormat = %s, "
4276 "GLsizei width = %d, GLsizei height = %d, GLboolean fixedSampleLocations = %s, GLuint "
4277 "memory = %u, GLuint64 offset = %llu",
4278 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
4279 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height,
4280 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
4281
4282 if (context)
4283 {
4284 TextureType targetPacked = FromGL<TextureType>(target);
4285 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
4286 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4287 bool isCallValid =
4288 (context->skipValidation() || ValidateTexStorageMem2DMultisampleEXT(
4289 context, targetPacked, samples, internalFormat, width,
4290 height, fixedSampleLocations, memoryPacked, offset));
4291 if (isCallValid)
4292 {
4293 context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
4294 height, fixedSampleLocations, memoryPacked, offset);
4295 }
4296 ANGLE_CAPTURE(TexStorageMem2DMultisampleEXT, isCallValid, context, targetPacked, samples,
4297 internalFormat, width, height, fixedSampleLocations, memoryPacked, offset);
4298 }
4299 }
4300
TexStorageMem3DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset)4301 void GL_APIENTRY TexStorageMem3DEXT(GLenum target,
4302 GLsizei levels,
4303 GLenum internalFormat,
4304 GLsizei width,
4305 GLsizei height,
4306 GLsizei depth,
4307 GLuint memory,
4308 GLuint64 offset)
4309 {
4310 Context *context = GetValidGlobalContext();
4311 EVENT("glTexStorageMem3DEXT",
4312 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalFormat = %s, "
4313 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLuint memory = %u, "
4314 "GLuint64 offset = %llu",
4315 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
4316 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory,
4317 static_cast<unsigned long long>(offset));
4318
4319 if (context)
4320 {
4321 TextureType targetPacked = FromGL<TextureType>(target);
4322 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
4323 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4324 bool isCallValid =
4325 (context->skipValidation() ||
4326 ValidateTexStorageMem3DEXT(context, targetPacked, levels, internalFormat, width,
4327 height, depth, memoryPacked, offset));
4328 if (isCallValid)
4329 {
4330 context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
4331 memoryPacked, offset);
4332 }
4333 ANGLE_CAPTURE(TexStorageMem3DEXT, isCallValid, context, targetPacked, levels,
4334 internalFormat, width, height, depth, memoryPacked, offset);
4335 }
4336 }
4337
TexStorageMem3DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)4338 void GL_APIENTRY TexStorageMem3DMultisampleEXT(GLenum target,
4339 GLsizei samples,
4340 GLenum internalFormat,
4341 GLsizei width,
4342 GLsizei height,
4343 GLsizei depth,
4344 GLboolean fixedSampleLocations,
4345 GLuint memory,
4346 GLuint64 offset)
4347 {
4348 Context *context = GetValidGlobalContext();
4349 EVENT("glTexStorageMem3DMultisampleEXT",
4350 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalFormat = %s, "
4351 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLboolean "
4352 "fixedSampleLocations = %s, GLuint memory = %u, GLuint64 offset = %llu",
4353 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
4354 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth,
4355 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
4356
4357 if (context)
4358 {
4359 TextureType targetPacked = FromGL<TextureType>(target);
4360 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
4361 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4362 bool isCallValid = (context->skipValidation() ||
4363 ValidateTexStorageMem3DMultisampleEXT(
4364 context, targetPacked, samples, internalFormat, width, height,
4365 depth, fixedSampleLocations, memoryPacked, offset));
4366 if (isCallValid)
4367 {
4368 context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
4369 height, depth, fixedSampleLocations, memoryPacked,
4370 offset);
4371 }
4372 ANGLE_CAPTURE(TexStorageMem3DMultisampleEXT, isCallValid, context, targetPacked, samples,
4373 internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
4374 offset);
4375 }
4376 }
4377
4378 // GL_EXT_memory_object_fd
ImportMemoryFdEXT(GLuint memory,GLuint64 size,GLenum handleType,GLint fd)4379 void GL_APIENTRY ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
4380 {
4381 Context *context = GetValidGlobalContext();
4382 EVENT("glImportMemoryFdEXT",
4383 "context = %d, GLuint memory = %u, GLuint64 size = %llu, GLenum handleType = %s, GLint "
4384 "fd = %d",
4385 CID(context), memory, static_cast<unsigned long long>(size),
4386 GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
4387
4388 if (context)
4389 {
4390 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
4391 HandleType handleTypePacked = FromGL<HandleType>(handleType);
4392 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4393 bool isCallValid =
4394 (context->skipValidation() ||
4395 ValidateImportMemoryFdEXT(context, memoryPacked, size, handleTypePacked, fd));
4396 if (isCallValid)
4397 {
4398 context->importMemoryFd(memoryPacked, size, handleTypePacked, fd);
4399 }
4400 ANGLE_CAPTURE(ImportMemoryFdEXT, isCallValid, context, memoryPacked, size, handleTypePacked,
4401 fd);
4402 }
4403 }
4404
4405 // GL_EXT_multisampled_render_to_texture
FramebufferTexture2DMultisampleEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)4406 void GL_APIENTRY FramebufferTexture2DMultisampleEXT(GLenum target,
4407 GLenum attachment,
4408 GLenum textarget,
4409 GLuint texture,
4410 GLint level,
4411 GLsizei samples)
4412 {
4413 Context *context = GetValidGlobalContext();
4414 EVENT("glFramebufferTexture2DMultisampleEXT",
4415 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
4416 "texture = %u, GLint level = %d, GLsizei samples = %d",
4417 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
4418 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
4419 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, samples);
4420
4421 if (context)
4422 {
4423 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4424 bool isCallValid = (context->skipValidation() ||
4425 ValidateFramebufferTexture2DMultisampleEXT(
4426 context, target, attachment, textarget, texture, level, samples));
4427 if (isCallValid)
4428 {
4429 context->framebufferTexture2DMultisample(target, attachment, textarget, texture, level,
4430 samples);
4431 }
4432 ANGLE_CAPTURE(FramebufferTexture2DMultisampleEXT, isCallValid, context, target, attachment,
4433 textarget, texture, level, samples);
4434 }
4435 }
4436
RenderbufferStorageMultisampleEXT(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)4437 void GL_APIENTRY RenderbufferStorageMultisampleEXT(GLenum target,
4438 GLsizei samples,
4439 GLenum internalformat,
4440 GLsizei width,
4441 GLsizei height)
4442 {
4443 Context *context = GetValidGlobalContext();
4444 EVENT("glRenderbufferStorageMultisampleEXT",
4445 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
4446 "GLsizei width = %d, GLsizei height = %d",
4447 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
4448 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
4449
4450 if (context)
4451 {
4452 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4453 bool isCallValid = (context->skipValidation() ||
4454 ValidateRenderbufferStorageMultisampleEXT(
4455 context, target, samples, internalformat, width, height));
4456 if (isCallValid)
4457 {
4458 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
4459 }
4460 ANGLE_CAPTURE(RenderbufferStorageMultisampleEXT, isCallValid, context, target, samples,
4461 internalformat, width, height);
4462 }
4463 }
4464
4465 // GL_EXT_occlusion_query_boolean
4466 // BeginQueryEXT is already defined.
4467
4468 // DeleteQueriesEXT is already defined.
4469
4470 // EndQueryEXT is already defined.
4471
4472 // GenQueriesEXT is already defined.
4473
4474 // GetQueryObjectuivEXT is already defined.
4475
4476 // GetQueryivEXT is already defined.
4477
4478 // IsQueryEXT is already defined.
4479
4480 // GL_EXT_read_format_bgra
4481
4482 // GL_EXT_robustness
GetGraphicsResetStatusEXT()4483 GLenum GL_APIENTRY GetGraphicsResetStatusEXT()
4484 {
4485 Context *context = GetGlobalContext();
4486 EVENT("glGetGraphicsResetStatusEXT", "context = %d", CID(context));
4487
4488 GLenum returnValue;
4489 if (context)
4490 {
4491 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4492 bool isCallValid =
4493 (context->skipValidation() || ValidateGetGraphicsResetStatusEXT(context));
4494 if (isCallValid)
4495 {
4496 returnValue = context->getGraphicsResetStatus();
4497 }
4498 else
4499 {
4500 returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatusEXT, GLenum>();
4501 }
4502 ANGLE_CAPTURE(GetGraphicsResetStatusEXT, isCallValid, context, returnValue);
4503 }
4504 else
4505 {
4506 returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatusEXT, GLenum>();
4507 }
4508 return returnValue;
4509 }
4510
GetnUniformfvEXT(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)4511 void GL_APIENTRY GetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
4512 {
4513 Context *context = GetValidGlobalContext();
4514 EVENT("glGetnUniformfvEXT",
4515 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLfloat "
4516 "*params = 0x%016" PRIxPTR "",
4517 CID(context), program, location, bufSize, (uintptr_t)params);
4518
4519 if (context)
4520 {
4521 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
4522 UniformLocation locationPacked = FromGL<UniformLocation>(location);
4523 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4524 bool isCallValid =
4525 (context->skipValidation() ||
4526 ValidateGetnUniformfvEXT(context, programPacked, locationPacked, bufSize, params));
4527 if (isCallValid)
4528 {
4529 context->getnUniformfv(programPacked, locationPacked, bufSize, params);
4530 }
4531 ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
4532 bufSize, params);
4533 }
4534 }
4535
GetnUniformivEXT(GLuint program,GLint location,GLsizei bufSize,GLint * params)4536 void GL_APIENTRY GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
4537 {
4538 Context *context = GetValidGlobalContext();
4539 EVENT("glGetnUniformivEXT",
4540 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLint "
4541 "*params = 0x%016" PRIxPTR "",
4542 CID(context), program, location, bufSize, (uintptr_t)params);
4543
4544 if (context)
4545 {
4546 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
4547 UniformLocation locationPacked = FromGL<UniformLocation>(location);
4548 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4549 bool isCallValid =
4550 (context->skipValidation() ||
4551 ValidateGetnUniformivEXT(context, programPacked, locationPacked, bufSize, params));
4552 if (isCallValid)
4553 {
4554 context->getnUniformiv(programPacked, locationPacked, bufSize, params);
4555 }
4556 ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
4557 bufSize, params);
4558 }
4559 }
4560
ReadnPixelsEXT(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)4561 void GL_APIENTRY ReadnPixelsEXT(GLint x,
4562 GLint y,
4563 GLsizei width,
4564 GLsizei height,
4565 GLenum format,
4566 GLenum type,
4567 GLsizei bufSize,
4568 void *data)
4569 {
4570 Context *context = GetValidGlobalContext();
4571 EVENT("glReadnPixelsEXT",
4572 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
4573 "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, void *data = 0x%016" PRIxPTR
4574 "",
4575 CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
4576 GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data);
4577
4578 if (context)
4579 {
4580 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4581 bool isCallValid =
4582 (context->skipValidation() ||
4583 ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data));
4584 if (isCallValid)
4585 {
4586 context->readnPixels(x, y, width, height, format, type, bufSize, data);
4587 }
4588 ANGLE_CAPTURE(ReadnPixelsEXT, isCallValid, context, x, y, width, height, format, type,
4589 bufSize, data);
4590 }
4591 }
4592
4593 // GL_EXT_sRGB
4594
4595 // GL_EXT_semaphore
DeleteSemaphoresEXT(GLsizei n,const GLuint * semaphores)4596 void GL_APIENTRY DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
4597 {
4598 Context *context = GetValidGlobalContext();
4599 EVENT("glDeleteSemaphoresEXT",
4600 "context = %d, GLsizei n = %d, const GLuint *semaphores = 0x%016" PRIxPTR "",
4601 CID(context), n, (uintptr_t)semaphores);
4602
4603 if (context)
4604 {
4605 const SemaphoreID *semaphoresPacked = FromGL<const SemaphoreID *>(semaphores);
4606 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4607 bool isCallValid = (context->skipValidation() ||
4608 ValidateDeleteSemaphoresEXT(context, n, semaphoresPacked));
4609 if (isCallValid)
4610 {
4611 context->deleteSemaphores(n, semaphoresPacked);
4612 }
4613 ANGLE_CAPTURE(DeleteSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
4614 }
4615 }
4616
GenSemaphoresEXT(GLsizei n,GLuint * semaphores)4617 void GL_APIENTRY GenSemaphoresEXT(GLsizei n, GLuint *semaphores)
4618 {
4619 Context *context = GetValidGlobalContext();
4620 EVENT("glGenSemaphoresEXT",
4621 "context = %d, GLsizei n = %d, GLuint *semaphores = 0x%016" PRIxPTR "", CID(context), n,
4622 (uintptr_t)semaphores);
4623
4624 if (context)
4625 {
4626 SemaphoreID *semaphoresPacked = FromGL<SemaphoreID *>(semaphores);
4627 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4628 bool isCallValid =
4629 (context->skipValidation() || ValidateGenSemaphoresEXT(context, n, semaphoresPacked));
4630 if (isCallValid)
4631 {
4632 context->genSemaphores(n, semaphoresPacked);
4633 }
4634 ANGLE_CAPTURE(GenSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
4635 }
4636 }
4637
GetSemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,GLuint64 * params)4638 void GL_APIENTRY GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
4639 {
4640 Context *context = GetValidGlobalContext();
4641 EVENT(
4642 "glGetSemaphoreParameterui64vEXT",
4643 "context = %d, GLuint semaphore = %u, GLenum pname = %s, GLuint64 *params = 0x%016" PRIxPTR
4644 "",
4645 CID(context), semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname),
4646 (uintptr_t)params);
4647
4648 if (context)
4649 {
4650 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
4651 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4652 bool isCallValid =
4653 (context->skipValidation() ||
4654 ValidateGetSemaphoreParameterui64vEXT(context, semaphorePacked, pname, params));
4655 if (isCallValid)
4656 {
4657 context->getSemaphoreParameterui64v(semaphorePacked, pname, params);
4658 }
4659 ANGLE_CAPTURE(GetSemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
4660 params);
4661 }
4662 }
4663
IsSemaphoreEXT(GLuint semaphore)4664 GLboolean GL_APIENTRY IsSemaphoreEXT(GLuint semaphore)
4665 {
4666 Context *context = GetValidGlobalContext();
4667 EVENT("glIsSemaphoreEXT", "context = %d, GLuint semaphore = %u", CID(context), semaphore);
4668
4669 GLboolean returnValue;
4670 if (context)
4671 {
4672 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
4673 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4674 bool isCallValid =
4675 (context->skipValidation() || ValidateIsSemaphoreEXT(context, semaphorePacked));
4676 if (isCallValid)
4677 {
4678 returnValue = context->isSemaphore(semaphorePacked);
4679 }
4680 else
4681 {
4682 returnValue = GetDefaultReturnValue<EntryPoint::IsSemaphoreEXT, GLboolean>();
4683 }
4684 ANGLE_CAPTURE(IsSemaphoreEXT, isCallValid, context, semaphorePacked, returnValue);
4685 }
4686 else
4687 {
4688 returnValue = GetDefaultReturnValue<EntryPoint::IsSemaphoreEXT, GLboolean>();
4689 }
4690 return returnValue;
4691 }
4692
SemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,const GLuint64 * params)4693 void GL_APIENTRY SemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, const GLuint64 *params)
4694 {
4695 Context *context = GetValidGlobalContext();
4696 EVENT("glSemaphoreParameterui64vEXT",
4697 "context = %d, GLuint semaphore = %u, GLenum pname = %s, const GLuint64 *params = "
4698 "0x%016" PRIxPTR "",
4699 CID(context), semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname),
4700 (uintptr_t)params);
4701
4702 if (context)
4703 {
4704 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
4705 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4706 bool isCallValid =
4707 (context->skipValidation() ||
4708 ValidateSemaphoreParameterui64vEXT(context, semaphorePacked, pname, params));
4709 if (isCallValid)
4710 {
4711 context->semaphoreParameterui64v(semaphorePacked, pname, params);
4712 }
4713 ANGLE_CAPTURE(SemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
4714 params);
4715 }
4716 }
4717
SignalSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * dstLayouts)4718 void GL_APIENTRY SignalSemaphoreEXT(GLuint semaphore,
4719 GLuint numBufferBarriers,
4720 const GLuint *buffers,
4721 GLuint numTextureBarriers,
4722 const GLuint *textures,
4723 const GLenum *dstLayouts)
4724 {
4725 Context *context = GetValidGlobalContext();
4726 EVENT("glSignalSemaphoreEXT",
4727 "context = %d, GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint "
4728 "*buffers = 0x%016" PRIxPTR
4729 ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
4730 ", const GLenum *dstLayouts = 0x%016" PRIxPTR "",
4731 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
4732 (uintptr_t)textures, (uintptr_t)dstLayouts);
4733
4734 if (context)
4735 {
4736 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
4737 const BufferID *buffersPacked = FromGL<const BufferID *>(buffers);
4738 const TextureID *texturesPacked = FromGL<const TextureID *>(textures);
4739 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4740 bool isCallValid =
4741 (context->skipValidation() ||
4742 ValidateSignalSemaphoreEXT(context, semaphorePacked, numBufferBarriers, buffersPacked,
4743 numTextureBarriers, texturesPacked, dstLayouts));
4744 if (isCallValid)
4745 {
4746 context->signalSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
4747 numTextureBarriers, texturesPacked, dstLayouts);
4748 }
4749 ANGLE_CAPTURE(SignalSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
4750 buffersPacked, numTextureBarriers, texturesPacked, dstLayouts);
4751 }
4752 }
4753
WaitSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * srcLayouts)4754 void GL_APIENTRY WaitSemaphoreEXT(GLuint semaphore,
4755 GLuint numBufferBarriers,
4756 const GLuint *buffers,
4757 GLuint numTextureBarriers,
4758 const GLuint *textures,
4759 const GLenum *srcLayouts)
4760 {
4761 Context *context = GetValidGlobalContext();
4762 EVENT("glWaitSemaphoreEXT",
4763 "context = %d, GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint "
4764 "*buffers = 0x%016" PRIxPTR
4765 ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
4766 ", const GLenum *srcLayouts = 0x%016" PRIxPTR "",
4767 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
4768 (uintptr_t)textures, (uintptr_t)srcLayouts);
4769
4770 if (context)
4771 {
4772 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
4773 const BufferID *buffersPacked = FromGL<const BufferID *>(buffers);
4774 const TextureID *texturesPacked = FromGL<const TextureID *>(textures);
4775 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4776 bool isCallValid =
4777 (context->skipValidation() ||
4778 ValidateWaitSemaphoreEXT(context, semaphorePacked, numBufferBarriers, buffersPacked,
4779 numTextureBarriers, texturesPacked, srcLayouts));
4780 if (isCallValid)
4781 {
4782 context->waitSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
4783 numTextureBarriers, texturesPacked, srcLayouts);
4784 }
4785 ANGLE_CAPTURE(WaitSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
4786 buffersPacked, numTextureBarriers, texturesPacked, srcLayouts);
4787 }
4788 }
4789
4790 // GetUnsignedBytei_vEXT is already defined.
4791
4792 // GetUnsignedBytevEXT is already defined.
4793
4794 // GL_EXT_semaphore_fd
ImportSemaphoreFdEXT(GLuint semaphore,GLenum handleType,GLint fd)4795 void GL_APIENTRY ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
4796 {
4797 Context *context = GetValidGlobalContext();
4798 EVENT("glImportSemaphoreFdEXT",
4799 "context = %d, GLuint semaphore = %u, GLenum handleType = %s, GLint fd = %d",
4800 CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
4801
4802 if (context)
4803 {
4804 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
4805 HandleType handleTypePacked = FromGL<HandleType>(handleType);
4806 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4807 bool isCallValid =
4808 (context->skipValidation() ||
4809 ValidateImportSemaphoreFdEXT(context, semaphorePacked, handleTypePacked, fd));
4810 if (isCallValid)
4811 {
4812 context->importSemaphoreFd(semaphorePacked, handleTypePacked, fd);
4813 }
4814 ANGLE_CAPTURE(ImportSemaphoreFdEXT, isCallValid, context, semaphorePacked, handleTypePacked,
4815 fd);
4816 }
4817 }
4818
4819 // GL_EXT_texture_compression_bptc
4820
4821 // GL_EXT_texture_compression_dxt1
4822
4823 // GL_EXT_texture_compression_rgtc
4824
4825 // GL_EXT_texture_compression_s3tc
4826
4827 // GL_EXT_texture_compression_s3tc_srgb
4828
4829 // GL_EXT_texture_cube_map_array
4830
4831 // GL_EXT_texture_filter_anisotropic
4832
4833 // GL_EXT_texture_format_BGRA8888
4834
4835 // GL_EXT_texture_sRGB_R8
4836
4837 // GL_EXT_texture_storage
TexStorage1DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)4838 void GL_APIENTRY TexStorage1DEXT(GLenum target,
4839 GLsizei levels,
4840 GLenum internalformat,
4841 GLsizei width)
4842 {
4843 Context *context = GetValidGlobalContext();
4844 EVENT("glTexStorage1DEXT",
4845 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
4846 "GLsizei width = %d",
4847 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
4848 GLenumToString(GLenumGroup::InternalFormat, internalformat), width);
4849
4850 if (context)
4851 {
4852 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4853 bool isCallValid =
4854 (context->skipValidation() ||
4855 ValidateTexStorage1DEXT(context, target, levels, internalformat, width));
4856 if (isCallValid)
4857 {
4858 context->texStorage1D(target, levels, internalformat, width);
4859 }
4860 ANGLE_CAPTURE(TexStorage1DEXT, isCallValid, context, target, levels, internalformat, width);
4861 }
4862 }
4863
4864 void GL_APIENTRY
TexStorage2DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)4865 TexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
4866 {
4867 Context *context = GetValidGlobalContext();
4868 EVENT("glTexStorage2DEXT",
4869 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
4870 "GLsizei width = %d, GLsizei height = %d",
4871 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
4872 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
4873
4874 if (context)
4875 {
4876 TextureType targetPacked = FromGL<TextureType>(target);
4877 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4878 bool isCallValid =
4879 (context->skipValidation() ||
4880 ValidateTexStorage2DEXT(context, targetPacked, levels, internalformat, width, height));
4881 if (isCallValid)
4882 {
4883 context->texStorage2D(targetPacked, levels, internalformat, width, height);
4884 }
4885 ANGLE_CAPTURE(TexStorage2DEXT, isCallValid, context, targetPacked, levels, internalformat,
4886 width, height);
4887 }
4888 }
4889
TexStorage3DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)4890 void GL_APIENTRY TexStorage3DEXT(GLenum target,
4891 GLsizei levels,
4892 GLenum internalformat,
4893 GLsizei width,
4894 GLsizei height,
4895 GLsizei depth)
4896 {
4897 Context *context = GetValidGlobalContext();
4898 EVENT("glTexStorage3DEXT",
4899 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
4900 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d",
4901 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
4902 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth);
4903
4904 if (context)
4905 {
4906 TextureType targetPacked = FromGL<TextureType>(target);
4907 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4908 bool isCallValid = (context->skipValidation() ||
4909 ValidateTexStorage3DEXT(context, targetPacked, levels, internalformat,
4910 width, height, depth));
4911 if (isCallValid)
4912 {
4913 context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
4914 }
4915 ANGLE_CAPTURE(TexStorage3DEXT, isCallValid, context, targetPacked, levels, internalformat,
4916 width, height, depth);
4917 }
4918 }
4919
4920 // GL_KHR_debug
DebugMessageCallbackKHR(GLDEBUGPROCKHR callback,const void * userParam)4921 void GL_APIENTRY DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
4922 {
4923 Context *context = GetValidGlobalContext();
4924 EVENT("glDebugMessageCallbackKHR",
4925 "context = %d, GLDEBUGPROCKHR callback = 0x%016" PRIxPTR
4926 ", const void *userParam = 0x%016" PRIxPTR "",
4927 CID(context), (uintptr_t)callback, (uintptr_t)userParam);
4928
4929 if (context)
4930 {
4931 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4932 bool isCallValid = (context->skipValidation() ||
4933 ValidateDebugMessageCallbackKHR(context, callback, userParam));
4934 if (isCallValid)
4935 {
4936 context->debugMessageCallback(callback, userParam);
4937 }
4938 ANGLE_CAPTURE(DebugMessageCallbackKHR, isCallValid, context, callback, userParam);
4939 }
4940 }
4941
DebugMessageControlKHR(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)4942 void GL_APIENTRY DebugMessageControlKHR(GLenum source,
4943 GLenum type,
4944 GLenum severity,
4945 GLsizei count,
4946 const GLuint *ids,
4947 GLboolean enabled)
4948 {
4949 Context *context = GetValidGlobalContext();
4950 EVENT("glDebugMessageControlKHR",
4951 "context = %d, GLenum source = %s, GLenum type = %s, GLenum severity = %s, GLsizei count "
4952 "= %d, const GLuint *ids = 0x%016" PRIxPTR ", GLboolean enabled = %s",
4953 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
4954 GLenumToString(GLenumGroup::DebugType, type),
4955 GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids,
4956 GLbooleanToString(enabled));
4957
4958 if (context)
4959 {
4960 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4961 bool isCallValid =
4962 (context->skipValidation() ||
4963 ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled));
4964 if (isCallValid)
4965 {
4966 context->debugMessageControl(source, type, severity, count, ids, enabled);
4967 }
4968 ANGLE_CAPTURE(DebugMessageControlKHR, isCallValid, context, source, type, severity, count,
4969 ids, enabled);
4970 }
4971 }
4972
DebugMessageInsertKHR(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)4973 void GL_APIENTRY DebugMessageInsertKHR(GLenum source,
4974 GLenum type,
4975 GLuint id,
4976 GLenum severity,
4977 GLsizei length,
4978 const GLchar *buf)
4979 {
4980 Context *context = GetValidGlobalContext();
4981 EVENT("glDebugMessageInsertKHR",
4982 "context = %d, GLenum source = %s, GLenum type = %s, GLuint id = %u, GLenum severity = "
4983 "%s, GLsizei length = %d, const GLchar *buf = 0x%016" PRIxPTR "",
4984 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
4985 GLenumToString(GLenumGroup::DebugType, type), id,
4986 GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf);
4987
4988 if (context)
4989 {
4990 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
4991 bool isCallValid =
4992 (context->skipValidation() ||
4993 ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf));
4994 if (isCallValid)
4995 {
4996 context->debugMessageInsert(source, type, id, severity, length, buf);
4997 }
4998 ANGLE_CAPTURE(DebugMessageInsertKHR, isCallValid, context, source, type, id, severity,
4999 length, buf);
5000 }
5001 }
5002
GetDebugMessageLogKHR(GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)5003 GLuint GL_APIENTRY GetDebugMessageLogKHR(GLuint count,
5004 GLsizei bufSize,
5005 GLenum *sources,
5006 GLenum *types,
5007 GLuint *ids,
5008 GLenum *severities,
5009 GLsizei *lengths,
5010 GLchar *messageLog)
5011 {
5012 Context *context = GetValidGlobalContext();
5013 EVENT("glGetDebugMessageLogKHR",
5014 "context = %d, GLuint count = %u, GLsizei bufSize = %d, GLenum *sources = 0x%016" PRIxPTR
5015 ", GLenum *types = 0x%016" PRIxPTR ", GLuint *ids = 0x%016" PRIxPTR
5016 ", GLenum *severities = 0x%016" PRIxPTR ", GLsizei *lengths = 0x%016" PRIxPTR
5017 ", GLchar *messageLog = 0x%016" PRIxPTR "",
5018 CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
5019 (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
5020
5021 GLuint returnValue;
5022 if (context)
5023 {
5024 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5025 bool isCallValid = (context->skipValidation() ||
5026 ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types,
5027 ids, severities, lengths, messageLog));
5028 if (isCallValid)
5029 {
5030 returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
5031 severities, lengths, messageLog);
5032 }
5033 else
5034 {
5035 returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLogKHR, GLuint>();
5036 }
5037 ANGLE_CAPTURE(GetDebugMessageLogKHR, isCallValid, context, count, bufSize, sources, types,
5038 ids, severities, lengths, messageLog, returnValue);
5039 }
5040 else
5041 {
5042 returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLogKHR, GLuint>();
5043 }
5044 return returnValue;
5045 }
5046
5047 void GL_APIENTRY
GetObjectLabelKHR(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)5048 GetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
5049 {
5050 Context *context = GetValidGlobalContext();
5051 EVENT("glGetObjectLabelKHR",
5052 "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei bufSize = %d, GLsizei "
5053 "*length = 0x%016" PRIxPTR ", GLchar *label = 0x%016" PRIxPTR "",
5054 CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize,
5055 (uintptr_t)length, (uintptr_t)label);
5056
5057 if (context)
5058 {
5059 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5060 bool isCallValid =
5061 (context->skipValidation() ||
5062 ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label));
5063 if (isCallValid)
5064 {
5065 context->getObjectLabel(identifier, name, bufSize, length, label);
5066 }
5067 ANGLE_CAPTURE(GetObjectLabelKHR, isCallValid, context, identifier, name, bufSize, length,
5068 label);
5069 }
5070 }
5071
GetObjectPtrLabelKHR(const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)5072 void GL_APIENTRY GetObjectPtrLabelKHR(const void *ptr,
5073 GLsizei bufSize,
5074 GLsizei *length,
5075 GLchar *label)
5076 {
5077 Context *context = GetValidGlobalContext();
5078 EVENT("glGetObjectPtrLabelKHR",
5079 "context = %d, const void *ptr = 0x%016" PRIxPTR
5080 ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
5081 ", GLchar *label = 0x%016" PRIxPTR "",
5082 CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
5083
5084 if (context)
5085 {
5086 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5087 bool isCallValid = (context->skipValidation() ||
5088 ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label));
5089 if (isCallValid)
5090 {
5091 context->getObjectPtrLabel(ptr, bufSize, length, label);
5092 }
5093 ANGLE_CAPTURE(GetObjectPtrLabelKHR, isCallValid, context, ptr, bufSize, length, label);
5094 }
5095 }
5096
GetPointervKHR(GLenum pname,void ** params)5097 void GL_APIENTRY GetPointervKHR(GLenum pname, void **params)
5098 {
5099 Context *context = GetValidGlobalContext();
5100 EVENT("glGetPointervKHR", "context = %d, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
5101 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
5102
5103 if (context)
5104 {
5105 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5106 bool isCallValid =
5107 (context->skipValidation() || ValidateGetPointervKHR(context, pname, params));
5108 if (isCallValid)
5109 {
5110 context->getPointerv(pname, params);
5111 }
5112 ANGLE_CAPTURE(GetPointervKHR, isCallValid, context, pname, params);
5113 }
5114 }
5115
ObjectLabelKHR(GLenum identifier,GLuint name,GLsizei length,const GLchar * label)5116 void GL_APIENTRY ObjectLabelKHR(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
5117 {
5118 Context *context = GetValidGlobalContext();
5119 EVENT("glObjectLabelKHR",
5120 "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei length = %d, const "
5121 "GLchar *label = 0x%016" PRIxPTR "",
5122 CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length,
5123 (uintptr_t)label);
5124
5125 if (context)
5126 {
5127 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5128 bool isCallValid = (context->skipValidation() ||
5129 ValidateObjectLabelKHR(context, identifier, name, length, label));
5130 if (isCallValid)
5131 {
5132 context->objectLabel(identifier, name, length, label);
5133 }
5134 ANGLE_CAPTURE(ObjectLabelKHR, isCallValid, context, identifier, name, length, label);
5135 }
5136 }
5137
ObjectPtrLabelKHR(const void * ptr,GLsizei length,const GLchar * label)5138 void GL_APIENTRY ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
5139 {
5140 Context *context = GetValidGlobalContext();
5141 EVENT("glObjectPtrLabelKHR",
5142 "context = %d, const void *ptr = 0x%016" PRIxPTR
5143 ", GLsizei length = %d, const GLchar *label = 0x%016" PRIxPTR "",
5144 CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
5145
5146 if (context)
5147 {
5148 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5149 bool isCallValid =
5150 (context->skipValidation() || ValidateObjectPtrLabelKHR(context, ptr, length, label));
5151 if (isCallValid)
5152 {
5153 context->objectPtrLabel(ptr, length, label);
5154 }
5155 ANGLE_CAPTURE(ObjectPtrLabelKHR, isCallValid, context, ptr, length, label);
5156 }
5157 }
5158
PopDebugGroupKHR()5159 void GL_APIENTRY PopDebugGroupKHR()
5160 {
5161 Context *context = GetValidGlobalContext();
5162 EVENT("glPopDebugGroupKHR", "context = %d", CID(context));
5163
5164 if (context)
5165 {
5166 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5167 bool isCallValid = (context->skipValidation() || ValidatePopDebugGroupKHR(context));
5168 if (isCallValid)
5169 {
5170 context->popDebugGroup();
5171 }
5172 ANGLE_CAPTURE(PopDebugGroupKHR, isCallValid, context);
5173 }
5174 }
5175
PushDebugGroupKHR(GLenum source,GLuint id,GLsizei length,const GLchar * message)5176 void GL_APIENTRY PushDebugGroupKHR(GLenum source, GLuint id, GLsizei length, const GLchar *message)
5177 {
5178 Context *context = GetValidGlobalContext();
5179 EVENT("glPushDebugGroupKHR",
5180 "context = %d, GLenum source = %s, GLuint id = %u, GLsizei length = %d, const GLchar "
5181 "*message = 0x%016" PRIxPTR "",
5182 CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length,
5183 (uintptr_t)message);
5184
5185 if (context)
5186 {
5187 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5188 bool isCallValid = (context->skipValidation() ||
5189 ValidatePushDebugGroupKHR(context, source, id, length, message));
5190 if (isCallValid)
5191 {
5192 context->pushDebugGroup(source, id, length, message);
5193 }
5194 ANGLE_CAPTURE(PushDebugGroupKHR, isCallValid, context, source, id, length, message);
5195 }
5196 }
5197
5198 // GL_KHR_parallel_shader_compile
MaxShaderCompilerThreadsKHR(GLuint count)5199 void GL_APIENTRY MaxShaderCompilerThreadsKHR(GLuint count)
5200 {
5201 Context *context = GetValidGlobalContext();
5202 EVENT("glMaxShaderCompilerThreadsKHR", "context = %d, GLuint count = %u", CID(context), count);
5203
5204 if (context)
5205 {
5206 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5207 bool isCallValid =
5208 (context->skipValidation() || ValidateMaxShaderCompilerThreadsKHR(context, count));
5209 if (isCallValid)
5210 {
5211 context->maxShaderCompilerThreads(count);
5212 }
5213 ANGLE_CAPTURE(MaxShaderCompilerThreadsKHR, isCallValid, context, count);
5214 }
5215 }
5216
5217 // GL_NV_fence
DeleteFencesNV(GLsizei n,const GLuint * fences)5218 void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint *fences)
5219 {
5220 Context *context = GetValidGlobalContext();
5221 EVENT("glDeleteFencesNV",
5222 "context = %d, GLsizei n = %d, const GLuint *fences = 0x%016" PRIxPTR "", CID(context), n,
5223 (uintptr_t)fences);
5224
5225 if (context)
5226 {
5227 const FenceNVID *fencesPacked = FromGL<const FenceNVID *>(fences);
5228 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5229 bool isCallValid =
5230 (context->skipValidation() || ValidateDeleteFencesNV(context, n, fencesPacked));
5231 if (isCallValid)
5232 {
5233 context->deleteFencesNV(n, fencesPacked);
5234 }
5235 ANGLE_CAPTURE(DeleteFencesNV, isCallValid, context, n, fencesPacked);
5236 }
5237 }
5238
FinishFenceNV(GLuint fence)5239 void GL_APIENTRY FinishFenceNV(GLuint fence)
5240 {
5241 Context *context = GetValidGlobalContext();
5242 EVENT("glFinishFenceNV", "context = %d, GLuint fence = %u", CID(context), fence);
5243
5244 if (context)
5245 {
5246 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
5247 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5248 bool isCallValid =
5249 (context->skipValidation() || ValidateFinishFenceNV(context, fencePacked));
5250 if (isCallValid)
5251 {
5252 context->finishFenceNV(fencePacked);
5253 }
5254 ANGLE_CAPTURE(FinishFenceNV, isCallValid, context, fencePacked);
5255 }
5256 }
5257
GenFencesNV(GLsizei n,GLuint * fences)5258 void GL_APIENTRY GenFencesNV(GLsizei n, GLuint *fences)
5259 {
5260 Context *context = GetValidGlobalContext();
5261 EVENT("glGenFencesNV", "context = %d, GLsizei n = %d, GLuint *fences = 0x%016" PRIxPTR "",
5262 CID(context), n, (uintptr_t)fences);
5263
5264 if (context)
5265 {
5266 FenceNVID *fencesPacked = FromGL<FenceNVID *>(fences);
5267 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5268 bool isCallValid =
5269 (context->skipValidation() || ValidateGenFencesNV(context, n, fencesPacked));
5270 if (isCallValid)
5271 {
5272 context->genFencesNV(n, fencesPacked);
5273 }
5274 ANGLE_CAPTURE(GenFencesNV, isCallValid, context, n, fencesPacked);
5275 }
5276 }
5277
GetFenceivNV(GLuint fence,GLenum pname,GLint * params)5278 void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
5279 {
5280 Context *context = GetValidGlobalContext();
5281 EVENT("glGetFenceivNV",
5282 "context = %d, GLuint fence = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
5283 CID(context), fence, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
5284
5285 if (context)
5286 {
5287 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
5288 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5289 bool isCallValid = (context->skipValidation() ||
5290 ValidateGetFenceivNV(context, fencePacked, pname, params));
5291 if (isCallValid)
5292 {
5293 context->getFenceivNV(fencePacked, pname, params);
5294 }
5295 ANGLE_CAPTURE(GetFenceivNV, isCallValid, context, fencePacked, pname, params);
5296 }
5297 }
5298
IsFenceNV(GLuint fence)5299 GLboolean GL_APIENTRY IsFenceNV(GLuint fence)
5300 {
5301 Context *context = GetValidGlobalContext();
5302 EVENT("glIsFenceNV", "context = %d, GLuint fence = %u", CID(context), fence);
5303
5304 GLboolean returnValue;
5305 if (context)
5306 {
5307 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
5308 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5309 bool isCallValid = (context->skipValidation() || ValidateIsFenceNV(context, fencePacked));
5310 if (isCallValid)
5311 {
5312 returnValue = context->isFenceNV(fencePacked);
5313 }
5314 else
5315 {
5316 returnValue = GetDefaultReturnValue<EntryPoint::IsFenceNV, GLboolean>();
5317 }
5318 ANGLE_CAPTURE(IsFenceNV, isCallValid, context, fencePacked, returnValue);
5319 }
5320 else
5321 {
5322 returnValue = GetDefaultReturnValue<EntryPoint::IsFenceNV, GLboolean>();
5323 }
5324 return returnValue;
5325 }
5326
SetFenceNV(GLuint fence,GLenum condition)5327 void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition)
5328 {
5329 Context *context = GetValidGlobalContext();
5330 EVENT("glSetFenceNV", "context = %d, GLuint fence = %u, GLenum condition = %s", CID(context),
5331 fence, GLenumToString(GLenumGroup::DefaultGroup, condition));
5332
5333 if (context)
5334 {
5335 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
5336 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5337 bool isCallValid =
5338 (context->skipValidation() || ValidateSetFenceNV(context, fencePacked, condition));
5339 if (isCallValid)
5340 {
5341 context->setFenceNV(fencePacked, condition);
5342 }
5343 ANGLE_CAPTURE(SetFenceNV, isCallValid, context, fencePacked, condition);
5344 }
5345 }
5346
TestFenceNV(GLuint fence)5347 GLboolean GL_APIENTRY TestFenceNV(GLuint fence)
5348 {
5349 Context *context = GetValidGlobalContext();
5350 EVENT("glTestFenceNV", "context = %d, GLuint fence = %u", CID(context), fence);
5351
5352 GLboolean returnValue;
5353 if (context)
5354 {
5355 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
5356 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5357 bool isCallValid = (context->skipValidation() || ValidateTestFenceNV(context, fencePacked));
5358 if (isCallValid)
5359 {
5360 returnValue = context->testFenceNV(fencePacked);
5361 }
5362 else
5363 {
5364 returnValue = GetDefaultReturnValue<EntryPoint::TestFenceNV, GLboolean>();
5365 }
5366 ANGLE_CAPTURE(TestFenceNV, isCallValid, context, fencePacked, returnValue);
5367 }
5368 else
5369 {
5370 returnValue = GetDefaultReturnValue<EntryPoint::TestFenceNV, GLboolean>();
5371 }
5372 return returnValue;
5373 }
5374
5375 // GL_OES_EGL_image
EGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image)5376 void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
5377 {
5378 Context *context = GetValidGlobalContext();
5379 EVENT("glEGLImageTargetRenderbufferStorageOES",
5380 "context = %d, GLenum target = %s, GLeglImageOES image = 0x%016" PRIxPTR "", CID(context),
5381 GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
5382
5383 if (context)
5384 {
5385 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5386 bool isCallValid = (context->skipValidation() ||
5387 ValidateEGLImageTargetRenderbufferStorageOES(context, target, image));
5388 if (isCallValid)
5389 {
5390 context->eGLImageTargetRenderbufferStorage(target, image);
5391 }
5392 ANGLE_CAPTURE(EGLImageTargetRenderbufferStorageOES, isCallValid, context, target, image);
5393 }
5394 }
5395
EGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image)5396 void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
5397 {
5398 Context *context = GetValidGlobalContext();
5399 EVENT("glEGLImageTargetTexture2DOES",
5400 "context = %d, GLenum target = %s, GLeglImageOES image = 0x%016" PRIxPTR "", CID(context),
5401 GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
5402
5403 if (context)
5404 {
5405 TextureType targetPacked = FromGL<TextureType>(target);
5406 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5407 bool isCallValid = (context->skipValidation() ||
5408 ValidateEGLImageTargetTexture2DOES(context, targetPacked, image));
5409 if (isCallValid)
5410 {
5411 context->eGLImageTargetTexture2D(targetPacked, image);
5412 }
5413 ANGLE_CAPTURE(EGLImageTargetTexture2DOES, isCallValid, context, targetPacked, image);
5414 }
5415 }
5416
5417 // GL_OES_compressed_ETC1_RGB8_texture
5418
5419 // GL_OES_depth32
5420
5421 // GL_OES_draw_buffers_indexed
BlendEquationSeparateiOES(GLuint buf,GLenum modeRGB,GLenum modeAlpha)5422 void GL_APIENTRY BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
5423 {
5424 Context *context = GetValidGlobalContext();
5425 EVENT("glBlendEquationSeparateiOES",
5426 "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
5427 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
5428 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
5429
5430 if (context)
5431 {
5432 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5433 bool isCallValid = (context->skipValidation() ||
5434 ValidateBlendEquationSeparateiOES(context, buf, modeRGB, modeAlpha));
5435 if (isCallValid)
5436 {
5437 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
5438 }
5439 ANGLE_CAPTURE(BlendEquationSeparateiOES, isCallValid, context, buf, modeRGB, modeAlpha);
5440 }
5441 }
5442
BlendEquationiOES(GLuint buf,GLenum mode)5443 void GL_APIENTRY BlendEquationiOES(GLuint buf, GLenum mode)
5444 {
5445 Context *context = GetValidGlobalContext();
5446 EVENT("glBlendEquationiOES", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context),
5447 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
5448
5449 if (context)
5450 {
5451 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5452 bool isCallValid =
5453 (context->skipValidation() || ValidateBlendEquationiOES(context, buf, mode));
5454 if (isCallValid)
5455 {
5456 context->blendEquationi(buf, mode);
5457 }
5458 ANGLE_CAPTURE(BlendEquationiOES, isCallValid, context, buf, mode);
5459 }
5460 }
5461
5462 void GL_APIENTRY
BlendFuncSeparateiOES(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)5463 BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
5464 {
5465 Context *context = GetValidGlobalContext();
5466 EVENT("glBlendFuncSeparateiOES",
5467 "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
5468 "= %s, GLenum dstAlpha = %s",
5469 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
5470 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
5471 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
5472 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
5473
5474 if (context)
5475 {
5476 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5477 bool isCallValid =
5478 (context->skipValidation() ||
5479 ValidateBlendFuncSeparateiOES(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
5480 if (isCallValid)
5481 {
5482 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
5483 }
5484 ANGLE_CAPTURE(BlendFuncSeparateiOES, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
5485 dstAlpha);
5486 }
5487 }
5488
BlendFunciOES(GLuint buf,GLenum src,GLenum dst)5489 void GL_APIENTRY BlendFunciOES(GLuint buf, GLenum src, GLenum dst)
5490 {
5491 Context *context = GetValidGlobalContext();
5492 EVENT("glBlendFunciOES", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
5493 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
5494 GLenumToString(GLenumGroup::BlendingFactor, dst));
5495
5496 if (context)
5497 {
5498 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5499 bool isCallValid =
5500 (context->skipValidation() || ValidateBlendFunciOES(context, buf, src, dst));
5501 if (isCallValid)
5502 {
5503 context->blendFunci(buf, src, dst);
5504 }
5505 ANGLE_CAPTURE(BlendFunciOES, isCallValid, context, buf, src, dst);
5506 }
5507 }
5508
ColorMaskiOES(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)5509 void GL_APIENTRY ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
5510 {
5511 Context *context = GetValidGlobalContext();
5512 EVENT("glColorMaskiOES",
5513 "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
5514 "GLboolean a = %s",
5515 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
5516 GLbooleanToString(a));
5517
5518 if (context)
5519 {
5520 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5521 bool isCallValid =
5522 (context->skipValidation() || ValidateColorMaskiOES(context, index, r, g, b, a));
5523 if (isCallValid)
5524 {
5525 context->colorMaski(index, r, g, b, a);
5526 }
5527 ANGLE_CAPTURE(ColorMaskiOES, isCallValid, context, index, r, g, b, a);
5528 }
5529 }
5530
DisableiOES(GLenum target,GLuint index)5531 void GL_APIENTRY DisableiOES(GLenum target, GLuint index)
5532 {
5533 Context *context = GetValidGlobalContext();
5534 EVENT("glDisableiOES", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
5535 GLenumToString(GLenumGroup::EnableCap, target), index);
5536
5537 if (context)
5538 {
5539 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5540 bool isCallValid =
5541 (context->skipValidation() || ValidateDisableiOES(context, target, index));
5542 if (isCallValid)
5543 {
5544 context->disablei(target, index);
5545 }
5546 ANGLE_CAPTURE(DisableiOES, isCallValid, context, target, index);
5547 }
5548 }
5549
EnableiOES(GLenum target,GLuint index)5550 void GL_APIENTRY EnableiOES(GLenum target, GLuint index)
5551 {
5552 Context *context = GetValidGlobalContext();
5553 EVENT("glEnableiOES", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
5554 GLenumToString(GLenumGroup::EnableCap, target), index);
5555
5556 if (context)
5557 {
5558 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5559 bool isCallValid =
5560 (context->skipValidation() || ValidateEnableiOES(context, target, index));
5561 if (isCallValid)
5562 {
5563 context->enablei(target, index);
5564 }
5565 ANGLE_CAPTURE(EnableiOES, isCallValid, context, target, index);
5566 }
5567 }
5568
IsEnablediOES(GLenum target,GLuint index)5569 GLboolean GL_APIENTRY IsEnablediOES(GLenum target, GLuint index)
5570 {
5571 Context *context = GetValidGlobalContext();
5572 EVENT("glIsEnablediOES", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
5573 GLenumToString(GLenumGroup::EnableCap, target), index);
5574
5575 GLboolean returnValue;
5576 if (context)
5577 {
5578 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5579 bool isCallValid =
5580 (context->skipValidation() || ValidateIsEnablediOES(context, target, index));
5581 if (isCallValid)
5582 {
5583 returnValue = context->isEnabledi(target, index);
5584 }
5585 else
5586 {
5587 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediOES, GLboolean>();
5588 }
5589 ANGLE_CAPTURE(IsEnablediOES, isCallValid, context, target, index, returnValue);
5590 }
5591 else
5592 {
5593 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediOES, GLboolean>();
5594 }
5595 return returnValue;
5596 }
5597
5598 // GL_OES_draw_elements_base_vertex
DrawElementsBaseVertexOES(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)5599 void GL_APIENTRY DrawElementsBaseVertexOES(GLenum mode,
5600 GLsizei count,
5601 GLenum type,
5602 const void *indices,
5603 GLint basevertex)
5604 {
5605 Context *context = GetValidGlobalContext();
5606 EVENT("glDrawElementsBaseVertexOES",
5607 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
5608 "*indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
5609 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
5610 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
5611
5612 if (context)
5613 {
5614 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
5615 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
5616 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5617 bool isCallValid = (context->skipValidation() ||
5618 ValidateDrawElementsBaseVertexOES(context, modePacked, count,
5619 typePacked, indices, basevertex));
5620 if (isCallValid)
5621 {
5622 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
5623 }
5624 ANGLE_CAPTURE(DrawElementsBaseVertexOES, isCallValid, context, modePacked, count,
5625 typePacked, indices, basevertex);
5626 }
5627 }
5628
DrawElementsInstancedBaseVertexOES(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)5629 void GL_APIENTRY DrawElementsInstancedBaseVertexOES(GLenum mode,
5630 GLsizei count,
5631 GLenum type,
5632 const void *indices,
5633 GLsizei instancecount,
5634 GLint basevertex)
5635 {
5636 Context *context = GetValidGlobalContext();
5637 EVENT("glDrawElementsInstancedBaseVertexOES",
5638 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
5639 "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d, GLint basevertex = %d",
5640 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
5641 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
5642 basevertex);
5643
5644 if (context)
5645 {
5646 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
5647 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
5648 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5649 bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexOES(
5650 context, modePacked, count, typePacked,
5651 indices, instancecount, basevertex));
5652 if (isCallValid)
5653 {
5654 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
5655 instancecount, basevertex);
5656 }
5657 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexOES, isCallValid, context, modePacked, count,
5658 typePacked, indices, instancecount, basevertex);
5659 }
5660 }
5661
DrawRangeElementsBaseVertexOES(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)5662 void GL_APIENTRY DrawRangeElementsBaseVertexOES(GLenum mode,
5663 GLuint start,
5664 GLuint end,
5665 GLsizei count,
5666 GLenum type,
5667 const void *indices,
5668 GLint basevertex)
5669 {
5670 Context *context = GetValidGlobalContext();
5671 EVENT("glDrawRangeElementsBaseVertexOES",
5672 "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
5673 "GLenum type = %s, const void *indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
5674 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
5675 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
5676
5677 if (context)
5678 {
5679 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
5680 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
5681 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5682 bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertexOES(
5683 context, modePacked, start, end, count,
5684 typePacked, indices, basevertex));
5685 if (isCallValid)
5686 {
5687 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
5688 basevertex);
5689 }
5690 ANGLE_CAPTURE(DrawRangeElementsBaseVertexOES, isCallValid, context, modePacked, start, end,
5691 count, typePacked, indices, basevertex);
5692 }
5693 }
5694
5695 // MultiDrawElementsBaseVertexEXT is already defined.
5696
5697 // GL_OES_draw_texture
DrawTexfOES(GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)5698 void GL_APIENTRY DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
5699 {
5700 Context *context = GetValidGlobalContext();
5701 EVENT("glDrawTexfOES",
5702 "context = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat width = %f, "
5703 "GLfloat height = %f",
5704 CID(context), x, y, z, width, height);
5705
5706 if (context)
5707 {
5708 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5709 bool isCallValid =
5710 (context->skipValidation() || ValidateDrawTexfOES(context, x, y, z, width, height));
5711 if (isCallValid)
5712 {
5713 context->drawTexf(x, y, z, width, height);
5714 }
5715 ANGLE_CAPTURE(DrawTexfOES, isCallValid, context, x, y, z, width, height);
5716 }
5717 }
5718
DrawTexfvOES(const GLfloat * coords)5719 void GL_APIENTRY DrawTexfvOES(const GLfloat *coords)
5720 {
5721 Context *context = GetValidGlobalContext();
5722 EVENT("glDrawTexfvOES", "context = %d, const GLfloat *coords = 0x%016" PRIxPTR "", CID(context),
5723 (uintptr_t)coords);
5724
5725 if (context)
5726 {
5727 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5728 bool isCallValid = (context->skipValidation() || ValidateDrawTexfvOES(context, coords));
5729 if (isCallValid)
5730 {
5731 context->drawTexfv(coords);
5732 }
5733 ANGLE_CAPTURE(DrawTexfvOES, isCallValid, context, coords);
5734 }
5735 }
5736
DrawTexiOES(GLint x,GLint y,GLint z,GLint width,GLint height)5737 void GL_APIENTRY DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
5738 {
5739 Context *context = GetValidGlobalContext();
5740 EVENT("glDrawTexiOES",
5741 "context = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height "
5742 "= %d",
5743 CID(context), x, y, z, width, height);
5744
5745 if (context)
5746 {
5747 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5748 bool isCallValid =
5749 (context->skipValidation() || ValidateDrawTexiOES(context, x, y, z, width, height));
5750 if (isCallValid)
5751 {
5752 context->drawTexi(x, y, z, width, height);
5753 }
5754 ANGLE_CAPTURE(DrawTexiOES, isCallValid, context, x, y, z, width, height);
5755 }
5756 }
5757
DrawTexivOES(const GLint * coords)5758 void GL_APIENTRY DrawTexivOES(const GLint *coords)
5759 {
5760 Context *context = GetValidGlobalContext();
5761 EVENT("glDrawTexivOES", "context = %d, const GLint *coords = 0x%016" PRIxPTR "", CID(context),
5762 (uintptr_t)coords);
5763
5764 if (context)
5765 {
5766 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5767 bool isCallValid = (context->skipValidation() || ValidateDrawTexivOES(context, coords));
5768 if (isCallValid)
5769 {
5770 context->drawTexiv(coords);
5771 }
5772 ANGLE_CAPTURE(DrawTexivOES, isCallValid, context, coords);
5773 }
5774 }
5775
DrawTexsOES(GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)5776 void GL_APIENTRY DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
5777 {
5778 Context *context = GetValidGlobalContext();
5779 EVENT("glDrawTexsOES",
5780 "context = %d, GLshort x = %d, GLshort y = %d, GLshort z = %d, GLshort width = %d, "
5781 "GLshort height = %d",
5782 CID(context), x, y, z, width, height);
5783
5784 if (context)
5785 {
5786 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5787 bool isCallValid =
5788 (context->skipValidation() || ValidateDrawTexsOES(context, x, y, z, width, height));
5789 if (isCallValid)
5790 {
5791 context->drawTexs(x, y, z, width, height);
5792 }
5793 ANGLE_CAPTURE(DrawTexsOES, isCallValid, context, x, y, z, width, height);
5794 }
5795 }
5796
DrawTexsvOES(const GLshort * coords)5797 void GL_APIENTRY DrawTexsvOES(const GLshort *coords)
5798 {
5799 Context *context = GetValidGlobalContext();
5800 EVENT("glDrawTexsvOES", "context = %d, const GLshort *coords = 0x%016" PRIxPTR "", CID(context),
5801 (uintptr_t)coords);
5802
5803 if (context)
5804 {
5805 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5806 bool isCallValid = (context->skipValidation() || ValidateDrawTexsvOES(context, coords));
5807 if (isCallValid)
5808 {
5809 context->drawTexsv(coords);
5810 }
5811 ANGLE_CAPTURE(DrawTexsvOES, isCallValid, context, coords);
5812 }
5813 }
5814
DrawTexxOES(GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)5815 void GL_APIENTRY DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
5816 {
5817 Context *context = GetValidGlobalContext();
5818 EVENT("glDrawTexxOES",
5819 "context = %d, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X, GLfixed width = "
5820 "0x%X, GLfixed height = 0x%X",
5821 CID(context), x, y, z, width, height);
5822
5823 if (context)
5824 {
5825 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5826 bool isCallValid =
5827 (context->skipValidation() || ValidateDrawTexxOES(context, x, y, z, width, height));
5828 if (isCallValid)
5829 {
5830 context->drawTexx(x, y, z, width, height);
5831 }
5832 ANGLE_CAPTURE(DrawTexxOES, isCallValid, context, x, y, z, width, height);
5833 }
5834 }
5835
DrawTexxvOES(const GLfixed * coords)5836 void GL_APIENTRY DrawTexxvOES(const GLfixed *coords)
5837 {
5838 Context *context = GetValidGlobalContext();
5839 EVENT("glDrawTexxvOES", "context = %d, const GLfixed *coords = 0x%016" PRIxPTR "", CID(context),
5840 (uintptr_t)coords);
5841
5842 if (context)
5843 {
5844 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5845 bool isCallValid = (context->skipValidation() || ValidateDrawTexxvOES(context, coords));
5846 if (isCallValid)
5847 {
5848 context->drawTexxv(coords);
5849 }
5850 ANGLE_CAPTURE(DrawTexxvOES, isCallValid, context, coords);
5851 }
5852 }
5853
5854 // GL_OES_framebuffer_object
BindFramebufferOES(GLenum target,GLuint framebuffer)5855 void GL_APIENTRY BindFramebufferOES(GLenum target, GLuint framebuffer)
5856 {
5857 Context *context = GetValidGlobalContext();
5858 EVENT("glBindFramebufferOES", "context = %d, GLenum target = %s, GLuint framebuffer = %u",
5859 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer);
5860
5861 if (context)
5862 {
5863 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
5864 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5865 bool isCallValid = (context->skipValidation() ||
5866 ValidateBindFramebufferOES(context, target, framebufferPacked));
5867 if (isCallValid)
5868 {
5869 context->bindFramebuffer(target, framebufferPacked);
5870 }
5871 ANGLE_CAPTURE(BindFramebufferOES, isCallValid, context, target, framebufferPacked);
5872 }
5873 }
5874
BindRenderbufferOES(GLenum target,GLuint renderbuffer)5875 void GL_APIENTRY BindRenderbufferOES(GLenum target, GLuint renderbuffer)
5876 {
5877 Context *context = GetValidGlobalContext();
5878 EVENT("glBindRenderbufferOES", "context = %d, GLenum target = %s, GLuint renderbuffer = %u",
5879 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer);
5880
5881 if (context)
5882 {
5883 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
5884 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5885 bool isCallValid = (context->skipValidation() ||
5886 ValidateBindRenderbufferOES(context, target, renderbufferPacked));
5887 if (isCallValid)
5888 {
5889 context->bindRenderbuffer(target, renderbufferPacked);
5890 }
5891 ANGLE_CAPTURE(BindRenderbufferOES, isCallValid, context, target, renderbufferPacked);
5892 }
5893 }
5894
CheckFramebufferStatusOES(GLenum target)5895 GLenum GL_APIENTRY CheckFramebufferStatusOES(GLenum target)
5896 {
5897 Context *context = GetValidGlobalContext();
5898 EVENT("glCheckFramebufferStatusOES", "context = %d, GLenum target = %s", CID(context),
5899 GLenumToString(GLenumGroup::FramebufferTarget, target));
5900
5901 GLenum returnValue;
5902 if (context)
5903 {
5904 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5905 bool isCallValid =
5906 (context->skipValidation() || ValidateCheckFramebufferStatusOES(context, target));
5907 if (isCallValid)
5908 {
5909 returnValue = context->checkFramebufferStatus(target);
5910 }
5911 else
5912 {
5913 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatusOES, GLenum>();
5914 }
5915 ANGLE_CAPTURE(CheckFramebufferStatusOES, isCallValid, context, target, returnValue);
5916 }
5917 else
5918 {
5919 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatusOES, GLenum>();
5920 }
5921 return returnValue;
5922 }
5923
DeleteFramebuffersOES(GLsizei n,const GLuint * framebuffers)5924 void GL_APIENTRY DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
5925 {
5926 Context *context = GetValidGlobalContext();
5927 EVENT("glDeleteFramebuffersOES",
5928 "context = %d, GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR "",
5929 CID(context), n, (uintptr_t)framebuffers);
5930
5931 if (context)
5932 {
5933 const FramebufferID *framebuffersPacked = FromGL<const FramebufferID *>(framebuffers);
5934 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5935 bool isCallValid = (context->skipValidation() ||
5936 ValidateDeleteFramebuffersOES(context, n, framebuffersPacked));
5937 if (isCallValid)
5938 {
5939 context->deleteFramebuffers(n, framebuffersPacked);
5940 }
5941 ANGLE_CAPTURE(DeleteFramebuffersOES, isCallValid, context, n, framebuffersPacked);
5942 }
5943 }
5944
DeleteRenderbuffersOES(GLsizei n,const GLuint * renderbuffers)5945 void GL_APIENTRY DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
5946 {
5947 Context *context = GetValidGlobalContext();
5948 EVENT("glDeleteRenderbuffersOES",
5949 "context = %d, GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR "",
5950 CID(context), n, (uintptr_t)renderbuffers);
5951
5952 if (context)
5953 {
5954 const RenderbufferID *renderbuffersPacked = FromGL<const RenderbufferID *>(renderbuffers);
5955 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5956 bool isCallValid = (context->skipValidation() ||
5957 ValidateDeleteRenderbuffersOES(context, n, renderbuffersPacked));
5958 if (isCallValid)
5959 {
5960 context->deleteRenderbuffers(n, renderbuffersPacked);
5961 }
5962 ANGLE_CAPTURE(DeleteRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
5963 }
5964 }
5965
FramebufferRenderbufferOES(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)5966 void GL_APIENTRY FramebufferRenderbufferOES(GLenum target,
5967 GLenum attachment,
5968 GLenum renderbuffertarget,
5969 GLuint renderbuffer)
5970 {
5971 Context *context = GetValidGlobalContext();
5972 EVENT("glFramebufferRenderbufferOES",
5973 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum renderbuffertarget = "
5974 "%s, GLuint renderbuffer = %u",
5975 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
5976 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
5977 GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer);
5978
5979 if (context)
5980 {
5981 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
5982 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
5983 bool isCallValid =
5984 (context->skipValidation() ||
5985 ValidateFramebufferRenderbufferOES(context, target, attachment, renderbuffertarget,
5986 renderbufferPacked));
5987 if (isCallValid)
5988 {
5989 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
5990 renderbufferPacked);
5991 }
5992 ANGLE_CAPTURE(FramebufferRenderbufferOES, isCallValid, context, target, attachment,
5993 renderbuffertarget, renderbufferPacked);
5994 }
5995 }
5996
FramebufferTexture2DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)5997 void GL_APIENTRY FramebufferTexture2DOES(GLenum target,
5998 GLenum attachment,
5999 GLenum textarget,
6000 GLuint texture,
6001 GLint level)
6002 {
6003 Context *context = GetValidGlobalContext();
6004 EVENT("glFramebufferTexture2DOES",
6005 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
6006 "texture = %u, GLint level = %d",
6007 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
6008 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
6009 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
6010
6011 if (context)
6012 {
6013 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
6014 TextureID texturePacked = FromGL<TextureID>(texture);
6015 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6016 bool isCallValid = (context->skipValidation() ||
6017 ValidateFramebufferTexture2DOES(context, target, attachment,
6018 textargetPacked, texturePacked, level));
6019 if (isCallValid)
6020 {
6021 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
6022 level);
6023 }
6024 ANGLE_CAPTURE(FramebufferTexture2DOES, isCallValid, context, target, attachment,
6025 textargetPacked, texturePacked, level);
6026 }
6027 }
6028
GenFramebuffersOES(GLsizei n,GLuint * framebuffers)6029 void GL_APIENTRY GenFramebuffersOES(GLsizei n, GLuint *framebuffers)
6030 {
6031 Context *context = GetValidGlobalContext();
6032 EVENT("glGenFramebuffersOES",
6033 "context = %d, GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR "", CID(context), n,
6034 (uintptr_t)framebuffers);
6035
6036 if (context)
6037 {
6038 FramebufferID *framebuffersPacked = FromGL<FramebufferID *>(framebuffers);
6039 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6040 bool isCallValid = (context->skipValidation() ||
6041 ValidateGenFramebuffersOES(context, n, framebuffersPacked));
6042 if (isCallValid)
6043 {
6044 context->genFramebuffers(n, framebuffersPacked);
6045 }
6046 ANGLE_CAPTURE(GenFramebuffersOES, isCallValid, context, n, framebuffersPacked);
6047 }
6048 }
6049
GenRenderbuffersOES(GLsizei n,GLuint * renderbuffers)6050 void GL_APIENTRY GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
6051 {
6052 Context *context = GetValidGlobalContext();
6053 EVENT("glGenRenderbuffersOES",
6054 "context = %d, GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR "", CID(context),
6055 n, (uintptr_t)renderbuffers);
6056
6057 if (context)
6058 {
6059 RenderbufferID *renderbuffersPacked = FromGL<RenderbufferID *>(renderbuffers);
6060 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6061 bool isCallValid = (context->skipValidation() ||
6062 ValidateGenRenderbuffersOES(context, n, renderbuffersPacked));
6063 if (isCallValid)
6064 {
6065 context->genRenderbuffers(n, renderbuffersPacked);
6066 }
6067 ANGLE_CAPTURE(GenRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
6068 }
6069 }
6070
GenerateMipmapOES(GLenum target)6071 void GL_APIENTRY GenerateMipmapOES(GLenum target)
6072 {
6073 Context *context = GetValidGlobalContext();
6074 EVENT("glGenerateMipmapOES", "context = %d, GLenum target = %s", CID(context),
6075 GLenumToString(GLenumGroup::TextureTarget, target));
6076
6077 if (context)
6078 {
6079 TextureType targetPacked = FromGL<TextureType>(target);
6080 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6081 bool isCallValid =
6082 (context->skipValidation() || ValidateGenerateMipmapOES(context, targetPacked));
6083 if (isCallValid)
6084 {
6085 context->generateMipmap(targetPacked);
6086 }
6087 ANGLE_CAPTURE(GenerateMipmapOES, isCallValid, context, targetPacked);
6088 }
6089 }
6090
GetFramebufferAttachmentParameterivOES(GLenum target,GLenum attachment,GLenum pname,GLint * params)6091 void GL_APIENTRY GetFramebufferAttachmentParameterivOES(GLenum target,
6092 GLenum attachment,
6093 GLenum pname,
6094 GLint *params)
6095 {
6096 Context *context = GetValidGlobalContext();
6097 EVENT("glGetFramebufferAttachmentParameterivOES",
6098 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLint "
6099 "*params = 0x%016" PRIxPTR "",
6100 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
6101 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
6102 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
6103 (uintptr_t)params);
6104
6105 if (context)
6106 {
6107 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6108 bool isCallValid =
6109 (context->skipValidation() || ValidateGetFramebufferAttachmentParameterivOES(
6110 context, target, attachment, pname, params));
6111 if (isCallValid)
6112 {
6113 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
6114 }
6115 ANGLE_CAPTURE(GetFramebufferAttachmentParameterivOES, isCallValid, context, target,
6116 attachment, pname, params);
6117 }
6118 }
6119
GetRenderbufferParameterivOES(GLenum target,GLenum pname,GLint * params)6120 void GL_APIENTRY GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
6121 {
6122 Context *context = GetValidGlobalContext();
6123 EVENT("glGetRenderbufferParameterivOES",
6124 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
6125 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
6126 GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params);
6127
6128 if (context)
6129 {
6130 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6131 bool isCallValid = (context->skipValidation() ||
6132 ValidateGetRenderbufferParameterivOES(context, target, pname, params));
6133 if (isCallValid)
6134 {
6135 context->getRenderbufferParameteriv(target, pname, params);
6136 }
6137 ANGLE_CAPTURE(GetRenderbufferParameterivOES, isCallValid, context, target, pname, params);
6138 }
6139 }
6140
IsFramebufferOES(GLuint framebuffer)6141 GLboolean GL_APIENTRY IsFramebufferOES(GLuint framebuffer)
6142 {
6143 Context *context = GetValidGlobalContext();
6144 EVENT("glIsFramebufferOES", "context = %d, GLuint framebuffer = %u", CID(context), framebuffer);
6145
6146 GLboolean returnValue;
6147 if (context)
6148 {
6149 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
6150 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6151 bool isCallValid =
6152 (context->skipValidation() || ValidateIsFramebufferOES(context, framebufferPacked));
6153 if (isCallValid)
6154 {
6155 returnValue = context->isFramebuffer(framebufferPacked);
6156 }
6157 else
6158 {
6159 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebufferOES, GLboolean>();
6160 }
6161 ANGLE_CAPTURE(IsFramebufferOES, isCallValid, context, framebufferPacked, returnValue);
6162 }
6163 else
6164 {
6165 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebufferOES, GLboolean>();
6166 }
6167 return returnValue;
6168 }
6169
IsRenderbufferOES(GLuint renderbuffer)6170 GLboolean GL_APIENTRY IsRenderbufferOES(GLuint renderbuffer)
6171 {
6172 Context *context = GetValidGlobalContext();
6173 EVENT("glIsRenderbufferOES", "context = %d, GLuint renderbuffer = %u", CID(context),
6174 renderbuffer);
6175
6176 GLboolean returnValue;
6177 if (context)
6178 {
6179 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
6180 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6181 bool isCallValid =
6182 (context->skipValidation() || ValidateIsRenderbufferOES(context, renderbufferPacked));
6183 if (isCallValid)
6184 {
6185 returnValue = context->isRenderbuffer(renderbufferPacked);
6186 }
6187 else
6188 {
6189 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbufferOES, GLboolean>();
6190 }
6191 ANGLE_CAPTURE(IsRenderbufferOES, isCallValid, context, renderbufferPacked, returnValue);
6192 }
6193 else
6194 {
6195 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbufferOES, GLboolean>();
6196 }
6197 return returnValue;
6198 }
6199
RenderbufferStorageOES(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)6200 void GL_APIENTRY RenderbufferStorageOES(GLenum target,
6201 GLenum internalformat,
6202 GLsizei width,
6203 GLsizei height)
6204 {
6205 Context *context = GetValidGlobalContext();
6206 EVENT("glRenderbufferStorageOES",
6207 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLsizei width = %d, "
6208 "GLsizei height = %d",
6209 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
6210 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
6211
6212 if (context)
6213 {
6214 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6215 bool isCallValid =
6216 (context->skipValidation() ||
6217 ValidateRenderbufferStorageOES(context, target, internalformat, width, height));
6218 if (isCallValid)
6219 {
6220 context->renderbufferStorage(target, internalformat, width, height);
6221 }
6222 ANGLE_CAPTURE(RenderbufferStorageOES, isCallValid, context, target, internalformat, width,
6223 height);
6224 }
6225 }
6226
6227 // GL_OES_get_program_binary
GetProgramBinaryOES(GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)6228 void GL_APIENTRY GetProgramBinaryOES(GLuint program,
6229 GLsizei bufSize,
6230 GLsizei *length,
6231 GLenum *binaryFormat,
6232 void *binary)
6233 {
6234 Context *context = GetValidGlobalContext();
6235 EVENT(
6236 "glGetProgramBinaryOES",
6237 "context = %d, GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
6238 ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR "",
6239 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
6240 (uintptr_t)binary);
6241
6242 if (context)
6243 {
6244 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
6245 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6246 bool isCallValid = (context->skipValidation() ||
6247 ValidateGetProgramBinaryOES(context, programPacked, bufSize, length,
6248 binaryFormat, binary));
6249 if (isCallValid)
6250 {
6251 context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
6252 }
6253 ANGLE_CAPTURE(GetProgramBinaryOES, isCallValid, context, programPacked, bufSize, length,
6254 binaryFormat, binary);
6255 }
6256 }
6257
ProgramBinaryOES(GLuint program,GLenum binaryFormat,const void * binary,GLint length)6258 void GL_APIENTRY ProgramBinaryOES(GLuint program,
6259 GLenum binaryFormat,
6260 const void *binary,
6261 GLint length)
6262 {
6263 Context *context = GetValidGlobalContext();
6264 EVENT("glProgramBinaryOES",
6265 "context = %d, GLuint program = %u, GLenum binaryFormat = %s, const void *binary = "
6266 "0x%016" PRIxPTR ", GLint length = %d",
6267 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat),
6268 (uintptr_t)binary, length);
6269
6270 if (context)
6271 {
6272 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
6273 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6274 bool isCallValid =
6275 (context->skipValidation() ||
6276 ValidateProgramBinaryOES(context, programPacked, binaryFormat, binary, length));
6277 if (isCallValid)
6278 {
6279 context->programBinary(programPacked, binaryFormat, binary, length);
6280 }
6281 ANGLE_CAPTURE(ProgramBinaryOES, isCallValid, context, programPacked, binaryFormat, binary,
6282 length);
6283 }
6284 }
6285
6286 // GL_OES_mapbuffer
GetBufferPointervOES(GLenum target,GLenum pname,void ** params)6287 void GL_APIENTRY GetBufferPointervOES(GLenum target, GLenum pname, void **params)
6288 {
6289 Context *context = GetValidGlobalContext();
6290 EVENT("glGetBufferPointervOES",
6291 "context = %d, GLenum target = %s, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
6292 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
6293 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
6294
6295 if (context)
6296 {
6297 BufferBinding targetPacked = FromGL<BufferBinding>(target);
6298 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6299 bool isCallValid = (context->skipValidation() ||
6300 ValidateGetBufferPointervOES(context, targetPacked, pname, params));
6301 if (isCallValid)
6302 {
6303 context->getBufferPointerv(targetPacked, pname, params);
6304 }
6305 ANGLE_CAPTURE(GetBufferPointervOES, isCallValid, context, targetPacked, pname, params);
6306 }
6307 }
6308
MapBufferOES(GLenum target,GLenum access)6309 void *GL_APIENTRY MapBufferOES(GLenum target, GLenum access)
6310 {
6311 Context *context = GetValidGlobalContext();
6312 EVENT("glMapBufferOES", "context = %d, GLenum target = %s, GLenum access = %s", CID(context),
6313 GLenumToString(GLenumGroup::BufferTargetARB, target),
6314 GLenumToString(GLenumGroup::BufferAccessARB, access));
6315
6316 void *returnValue;
6317 if (context)
6318 {
6319 BufferBinding targetPacked = FromGL<BufferBinding>(target);
6320 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6321 bool isCallValid =
6322 (context->skipValidation() || ValidateMapBufferOES(context, targetPacked, access));
6323 if (isCallValid)
6324 {
6325 returnValue = context->mapBuffer(targetPacked, access);
6326 }
6327 else
6328 {
6329 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferOES, void *>();
6330 }
6331 ANGLE_CAPTURE(MapBufferOES, isCallValid, context, targetPacked, access, returnValue);
6332 }
6333 else
6334 {
6335 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferOES, void *>();
6336 }
6337 return returnValue;
6338 }
6339
UnmapBufferOES(GLenum target)6340 GLboolean GL_APIENTRY UnmapBufferOES(GLenum target)
6341 {
6342 Context *context = GetValidGlobalContext();
6343 EVENT("glUnmapBufferOES", "context = %d, GLenum target = %s", CID(context),
6344 GLenumToString(GLenumGroup::DefaultGroup, target));
6345
6346 GLboolean returnValue;
6347 if (context)
6348 {
6349 BufferBinding targetPacked = FromGL<BufferBinding>(target);
6350 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6351 bool isCallValid =
6352 (context->skipValidation() || ValidateUnmapBufferOES(context, targetPacked));
6353 if (isCallValid)
6354 {
6355 returnValue = context->unmapBuffer(targetPacked);
6356 }
6357 else
6358 {
6359 returnValue = GetDefaultReturnValue<EntryPoint::UnmapBufferOES, GLboolean>();
6360 }
6361 ANGLE_CAPTURE(UnmapBufferOES, isCallValid, context, targetPacked, returnValue);
6362 }
6363 else
6364 {
6365 returnValue = GetDefaultReturnValue<EntryPoint::UnmapBufferOES, GLboolean>();
6366 }
6367 return returnValue;
6368 }
6369
6370 // GL_OES_matrix_palette
CurrentPaletteMatrixOES(GLuint matrixpaletteindex)6371 void GL_APIENTRY CurrentPaletteMatrixOES(GLuint matrixpaletteindex)
6372 {
6373 Context *context = GetValidGlobalContext();
6374 EVENT("glCurrentPaletteMatrixOES", "context = %d, GLuint matrixpaletteindex = %u", CID(context),
6375 matrixpaletteindex);
6376
6377 if (context)
6378 {
6379 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6380 bool isCallValid = (context->skipValidation() ||
6381 ValidateCurrentPaletteMatrixOES(context, matrixpaletteindex));
6382 if (isCallValid)
6383 {
6384 context->currentPaletteMatrix(matrixpaletteindex);
6385 }
6386 ANGLE_CAPTURE(CurrentPaletteMatrixOES, isCallValid, context, matrixpaletteindex);
6387 }
6388 }
6389
LoadPaletteFromModelViewMatrixOES()6390 void GL_APIENTRY LoadPaletteFromModelViewMatrixOES()
6391 {
6392 Context *context = GetValidGlobalContext();
6393 EVENT("glLoadPaletteFromModelViewMatrixOES", "context = %d", CID(context));
6394
6395 if (context)
6396 {
6397 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6398 bool isCallValid =
6399 (context->skipValidation() || ValidateLoadPaletteFromModelViewMatrixOES(context));
6400 if (isCallValid)
6401 {
6402 context->loadPaletteFromModelViewMatrix();
6403 }
6404 ANGLE_CAPTURE(LoadPaletteFromModelViewMatrixOES, isCallValid, context);
6405 }
6406 }
6407
MatrixIndexPointerOES(GLint size,GLenum type,GLsizei stride,const void * pointer)6408 void GL_APIENTRY MatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
6409 {
6410 Context *context = GetValidGlobalContext();
6411 EVENT("glMatrixIndexPointerOES",
6412 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
6413 "*pointer = 0x%016" PRIxPTR "",
6414 CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
6415 (uintptr_t)pointer);
6416
6417 if (context)
6418 {
6419 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6420 bool isCallValid = (context->skipValidation() ||
6421 ValidateMatrixIndexPointerOES(context, size, type, stride, pointer));
6422 if (isCallValid)
6423 {
6424 context->matrixIndexPointer(size, type, stride, pointer);
6425 }
6426 ANGLE_CAPTURE(MatrixIndexPointerOES, isCallValid, context, size, type, stride, pointer);
6427 }
6428 }
6429
WeightPointerOES(GLint size,GLenum type,GLsizei stride,const void * pointer)6430 void GL_APIENTRY WeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
6431 {
6432 Context *context = GetValidGlobalContext();
6433 EVENT("glWeightPointerOES",
6434 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
6435 "*pointer = 0x%016" PRIxPTR "",
6436 CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
6437 (uintptr_t)pointer);
6438
6439 if (context)
6440 {
6441 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6442 bool isCallValid = (context->skipValidation() ||
6443 ValidateWeightPointerOES(context, size, type, stride, pointer));
6444 if (isCallValid)
6445 {
6446 context->weightPointer(size, type, stride, pointer);
6447 }
6448 ANGLE_CAPTURE(WeightPointerOES, isCallValid, context, size, type, stride, pointer);
6449 }
6450 }
6451
6452 // GL_OES_point_size_array
PointSizePointerOES(GLenum type,GLsizei stride,const void * pointer)6453 void GL_APIENTRY PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
6454 {
6455 Context *context = GetValidGlobalContext();
6456 EVENT(
6457 "glPointSizePointerOES",
6458 "context = %d, GLenum type = %s, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR
6459 "",
6460 CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), stride, (uintptr_t)pointer);
6461
6462 if (context)
6463 {
6464 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
6465 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6466 bool isCallValid = (context->skipValidation() ||
6467 ValidatePointSizePointerOES(context, typePacked, stride, pointer));
6468 if (isCallValid)
6469 {
6470 context->pointSizePointer(typePacked, stride, pointer);
6471 }
6472 ANGLE_CAPTURE(PointSizePointerOES, isCallValid, context, typePacked, stride, pointer);
6473 }
6474 }
6475
6476 // GL_OES_query_matrix
QueryMatrixxOES(GLfixed * mantissa,GLint * exponent)6477 GLbitfield GL_APIENTRY QueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
6478 {
6479 Context *context = GetValidGlobalContext();
6480 EVENT("glQueryMatrixxOES",
6481 "context = %d, GLfixed *mantissa = 0x%016" PRIxPTR ", GLint *exponent = 0x%016" PRIxPTR
6482 "",
6483 CID(context), (uintptr_t)mantissa, (uintptr_t)exponent);
6484
6485 GLbitfield returnValue;
6486 if (context)
6487 {
6488 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6489 bool isCallValid =
6490 (context->skipValidation() || ValidateQueryMatrixxOES(context, mantissa, exponent));
6491 if (isCallValid)
6492 {
6493 returnValue = context->queryMatrixx(mantissa, exponent);
6494 }
6495 else
6496 {
6497 returnValue = GetDefaultReturnValue<EntryPoint::QueryMatrixxOES, GLbitfield>();
6498 }
6499 ANGLE_CAPTURE(QueryMatrixxOES, isCallValid, context, mantissa, exponent, returnValue);
6500 }
6501 else
6502 {
6503 returnValue = GetDefaultReturnValue<EntryPoint::QueryMatrixxOES, GLbitfield>();
6504 }
6505 return returnValue;
6506 }
6507
6508 // GL_OES_texture_3D
CompressedTexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)6509 void GL_APIENTRY CompressedTexImage3DOES(GLenum target,
6510 GLint level,
6511 GLenum internalformat,
6512 GLsizei width,
6513 GLsizei height,
6514 GLsizei depth,
6515 GLint border,
6516 GLsizei imageSize,
6517 const void *data)
6518 {
6519 Context *context = GetValidGlobalContext();
6520 EVENT("glCompressedTexImage3DOES",
6521 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
6522 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei "
6523 "imageSize = %d, const void *data = 0x%016" PRIxPTR "",
6524 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
6525 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
6526 imageSize, (uintptr_t)data);
6527
6528 if (context)
6529 {
6530 TextureTarget targetPacked = FromGL<TextureTarget>(target);
6531 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6532 bool isCallValid =
6533 (context->skipValidation() ||
6534 ValidateCompressedTexImage3DOES(context, targetPacked, level, internalformat, width,
6535 height, depth, border, imageSize, data));
6536 if (isCallValid)
6537 {
6538 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
6539 border, imageSize, data);
6540 }
6541 ANGLE_CAPTURE(CompressedTexImage3DOES, isCallValid, context, targetPacked, level,
6542 internalformat, width, height, depth, border, imageSize, data);
6543 }
6544 }
6545
CompressedTexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)6546 void GL_APIENTRY CompressedTexSubImage3DOES(GLenum target,
6547 GLint level,
6548 GLint xoffset,
6549 GLint yoffset,
6550 GLint zoffset,
6551 GLsizei width,
6552 GLsizei height,
6553 GLsizei depth,
6554 GLenum format,
6555 GLsizei imageSize,
6556 const void *data)
6557 {
6558 Context *context = GetValidGlobalContext();
6559 EVENT("glCompressedTexSubImage3DOES",
6560 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
6561 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
6562 "GLenum format = %s, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR "",
6563 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
6564 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
6565 imageSize, (uintptr_t)data);
6566
6567 if (context)
6568 {
6569 TextureTarget targetPacked = FromGL<TextureTarget>(target);
6570 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6571 bool isCallValid = (context->skipValidation() ||
6572 ValidateCompressedTexSubImage3DOES(
6573 context, targetPacked, level, xoffset, yoffset, zoffset, width,
6574 height, depth, format, imageSize, data));
6575 if (isCallValid)
6576 {
6577 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
6578 height, depth, format, imageSize, data);
6579 }
6580 ANGLE_CAPTURE(CompressedTexSubImage3DOES, isCallValid, context, targetPacked, level,
6581 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
6582 }
6583 }
6584
CopyTexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)6585 void GL_APIENTRY CopyTexSubImage3DOES(GLenum target,
6586 GLint level,
6587 GLint xoffset,
6588 GLint yoffset,
6589 GLint zoffset,
6590 GLint x,
6591 GLint y,
6592 GLsizei width,
6593 GLsizei height)
6594 {
6595 Context *context = GetValidGlobalContext();
6596 EVENT("glCopyTexSubImage3DOES",
6597 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
6598 "%d, GLint zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height "
6599 "= %d",
6600 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
6601 zoffset, x, y, width, height);
6602
6603 if (context)
6604 {
6605 TextureTarget targetPacked = FromGL<TextureTarget>(target);
6606 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6607 bool isCallValid = (context->skipValidation() ||
6608 ValidateCopyTexSubImage3DOES(context, targetPacked, level, xoffset,
6609 yoffset, zoffset, x, y, width, height));
6610 if (isCallValid)
6611 {
6612 context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
6613 height);
6614 }
6615 ANGLE_CAPTURE(CopyTexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset,
6616 yoffset, zoffset, x, y, width, height);
6617 }
6618 }
6619
FramebufferTexture3DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)6620 void GL_APIENTRY FramebufferTexture3DOES(GLenum target,
6621 GLenum attachment,
6622 GLenum textarget,
6623 GLuint texture,
6624 GLint level,
6625 GLint zoffset)
6626 {
6627 Context *context = GetValidGlobalContext();
6628 EVENT("glFramebufferTexture3DOES",
6629 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
6630 "texture = %u, GLint level = %d, GLint zoffset = %d",
6631 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
6632 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
6633 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset);
6634
6635 if (context)
6636 {
6637 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
6638 TextureID texturePacked = FromGL<TextureID>(texture);
6639 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6640 bool isCallValid =
6641 (context->skipValidation() ||
6642 ValidateFramebufferTexture3DOES(context, target, attachment, textargetPacked,
6643 texturePacked, level, zoffset));
6644 if (isCallValid)
6645 {
6646 context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
6647 zoffset);
6648 }
6649 ANGLE_CAPTURE(FramebufferTexture3DOES, isCallValid, context, target, attachment,
6650 textargetPacked, texturePacked, level, zoffset);
6651 }
6652 }
6653
TexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)6654 void GL_APIENTRY TexImage3DOES(GLenum target,
6655 GLint level,
6656 GLenum internalformat,
6657 GLsizei width,
6658 GLsizei height,
6659 GLsizei depth,
6660 GLint border,
6661 GLenum format,
6662 GLenum type,
6663 const void *pixels)
6664 {
6665 Context *context = GetValidGlobalContext();
6666 EVENT("glTexImage3DOES",
6667 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
6668 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = "
6669 "%s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
6670 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
6671 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
6672 GLenumToString(GLenumGroup::PixelFormat, format),
6673 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
6674
6675 if (context)
6676 {
6677 TextureTarget targetPacked = FromGL<TextureTarget>(target);
6678 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6679 bool isCallValid =
6680 (context->skipValidation() ||
6681 ValidateTexImage3DOES(context, targetPacked, level, internalformat, width, height,
6682 depth, border, format, type, pixels));
6683 if (isCallValid)
6684 {
6685 context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
6686 format, type, pixels);
6687 }
6688 ANGLE_CAPTURE(TexImage3DOES, isCallValid, context, targetPacked, level, internalformat,
6689 width, height, depth, border, format, type, pixels);
6690 }
6691 }
6692
TexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)6693 void GL_APIENTRY TexSubImage3DOES(GLenum target,
6694 GLint level,
6695 GLint xoffset,
6696 GLint yoffset,
6697 GLint zoffset,
6698 GLsizei width,
6699 GLsizei height,
6700 GLsizei depth,
6701 GLenum format,
6702 GLenum type,
6703 const void *pixels)
6704 {
6705 Context *context = GetValidGlobalContext();
6706 EVENT("glTexSubImage3DOES",
6707 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
6708 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
6709 "GLenum format = %s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
6710 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
6711 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
6712 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
6713
6714 if (context)
6715 {
6716 TextureTarget targetPacked = FromGL<TextureTarget>(target);
6717 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6718 bool isCallValid =
6719 (context->skipValidation() ||
6720 ValidateTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset,
6721 width, height, depth, format, type, pixels));
6722 if (isCallValid)
6723 {
6724 context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
6725 depth, format, type, pixels);
6726 }
6727 ANGLE_CAPTURE(TexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset, yoffset,
6728 zoffset, width, height, depth, format, type, pixels);
6729 }
6730 }
6731
6732 // GL_OES_texture_border_clamp
GetSamplerParameterIivOES(GLuint sampler,GLenum pname,GLint * params)6733 void GL_APIENTRY GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
6734 {
6735 Context *context = GetValidGlobalContext();
6736 EVENT("glGetSamplerParameterIivOES",
6737 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
6738 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
6739 (uintptr_t)params);
6740
6741 if (context)
6742 {
6743 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
6744 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6745 bool isCallValid =
6746 (context->skipValidation() ||
6747 ValidateGetSamplerParameterIivOES(context, samplerPacked, pname, params));
6748 if (isCallValid)
6749 {
6750 context->getSamplerParameterIiv(samplerPacked, pname, params);
6751 }
6752 ANGLE_CAPTURE(GetSamplerParameterIivOES, isCallValid, context, samplerPacked, pname,
6753 params);
6754 }
6755 }
6756
GetSamplerParameterIuivOES(GLuint sampler,GLenum pname,GLuint * params)6757 void GL_APIENTRY GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
6758 {
6759 Context *context = GetValidGlobalContext();
6760 EVENT("glGetSamplerParameterIuivOES",
6761 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR
6762 "",
6763 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
6764 (uintptr_t)params);
6765
6766 if (context)
6767 {
6768 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
6769 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6770 bool isCallValid =
6771 (context->skipValidation() ||
6772 ValidateGetSamplerParameterIuivOES(context, samplerPacked, pname, params));
6773 if (isCallValid)
6774 {
6775 context->getSamplerParameterIuiv(samplerPacked, pname, params);
6776 }
6777 ANGLE_CAPTURE(GetSamplerParameterIuivOES, isCallValid, context, samplerPacked, pname,
6778 params);
6779 }
6780 }
6781
GetTexParameterIivOES(GLenum target,GLenum pname,GLint * params)6782 void GL_APIENTRY GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
6783 {
6784 Context *context = GetValidGlobalContext();
6785 EVENT("glGetTexParameterIivOES",
6786 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
6787 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
6788 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
6789
6790 if (context)
6791 {
6792 TextureType targetPacked = FromGL<TextureType>(target);
6793 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6794 bool isCallValid = (context->skipValidation() ||
6795 ValidateGetTexParameterIivOES(context, targetPacked, pname, params));
6796 if (isCallValid)
6797 {
6798 context->getTexParameterIiv(targetPacked, pname, params);
6799 }
6800 ANGLE_CAPTURE(GetTexParameterIivOES, isCallValid, context, targetPacked, pname, params);
6801 }
6802 }
6803
GetTexParameterIuivOES(GLenum target,GLenum pname,GLuint * params)6804 void GL_APIENTRY GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
6805 {
6806 Context *context = GetValidGlobalContext();
6807 EVENT("glGetTexParameterIuivOES",
6808 "context = %d, GLenum target = %s, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
6809 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
6810 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
6811
6812 if (context)
6813 {
6814 TextureType targetPacked = FromGL<TextureType>(target);
6815 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6816 bool isCallValid = (context->skipValidation() ||
6817 ValidateGetTexParameterIuivOES(context, targetPacked, pname, params));
6818 if (isCallValid)
6819 {
6820 context->getTexParameterIuiv(targetPacked, pname, params);
6821 }
6822 ANGLE_CAPTURE(GetTexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
6823 }
6824 }
6825
SamplerParameterIivOES(GLuint sampler,GLenum pname,const GLint * param)6826 void GL_APIENTRY SamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
6827 {
6828 Context *context = GetValidGlobalContext();
6829 EVENT(
6830 "glSamplerParameterIivOES",
6831 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
6832 "",
6833 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
6834 (uintptr_t)param);
6835
6836 if (context)
6837 {
6838 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
6839 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6840 bool isCallValid = (context->skipValidation() ||
6841 ValidateSamplerParameterIivOES(context, samplerPacked, pname, param));
6842 if (isCallValid)
6843 {
6844 context->samplerParameterIiv(samplerPacked, pname, param);
6845 }
6846 ANGLE_CAPTURE(SamplerParameterIivOES, isCallValid, context, samplerPacked, pname, param);
6847 }
6848 }
6849
SamplerParameterIuivOES(GLuint sampler,GLenum pname,const GLuint * param)6850 void GL_APIENTRY SamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
6851 {
6852 Context *context = GetValidGlobalContext();
6853 EVENT(
6854 "glSamplerParameterIuivOES",
6855 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLuint *param = 0x%016" PRIxPTR
6856 "",
6857 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
6858 (uintptr_t)param);
6859
6860 if (context)
6861 {
6862 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
6863 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6864 bool isCallValid = (context->skipValidation() ||
6865 ValidateSamplerParameterIuivOES(context, samplerPacked, pname, param));
6866 if (isCallValid)
6867 {
6868 context->samplerParameterIuiv(samplerPacked, pname, param);
6869 }
6870 ANGLE_CAPTURE(SamplerParameterIuivOES, isCallValid, context, samplerPacked, pname, param);
6871 }
6872 }
6873
TexParameterIivOES(GLenum target,GLenum pname,const GLint * params)6874 void GL_APIENTRY TexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
6875 {
6876 Context *context = GetValidGlobalContext();
6877 EVENT(
6878 "glTexParameterIivOES",
6879 "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
6880 "",
6881 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
6882 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
6883
6884 if (context)
6885 {
6886 TextureType targetPacked = FromGL<TextureType>(target);
6887 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6888 bool isCallValid = (context->skipValidation() ||
6889 ValidateTexParameterIivOES(context, targetPacked, pname, params));
6890 if (isCallValid)
6891 {
6892 context->texParameterIiv(targetPacked, pname, params);
6893 }
6894 ANGLE_CAPTURE(TexParameterIivOES, isCallValid, context, targetPacked, pname, params);
6895 }
6896 }
6897
TexParameterIuivOES(GLenum target,GLenum pname,const GLuint * params)6898 void GL_APIENTRY TexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
6899 {
6900 Context *context = GetValidGlobalContext();
6901 EVENT(
6902 "glTexParameterIuivOES",
6903 "context = %d, GLenum target = %s, GLenum pname = %s, const GLuint *params = 0x%016" PRIxPTR
6904 "",
6905 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
6906 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
6907
6908 if (context)
6909 {
6910 TextureType targetPacked = FromGL<TextureType>(target);
6911 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6912 bool isCallValid = (context->skipValidation() ||
6913 ValidateTexParameterIuivOES(context, targetPacked, pname, params));
6914 if (isCallValid)
6915 {
6916 context->texParameterIuiv(targetPacked, pname, params);
6917 }
6918 ANGLE_CAPTURE(TexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
6919 }
6920 }
6921
6922 // GL_OES_texture_cube_map
GetTexGenfvOES(GLenum coord,GLenum pname,GLfloat * params)6923 void GL_APIENTRY GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
6924 {
6925 Context *context = GetValidGlobalContext();
6926 EVENT("glGetTexGenfvOES",
6927 "context = %d, GLenum coord = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
6928 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
6929 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
6930
6931 if (context)
6932 {
6933 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6934 bool isCallValid =
6935 (context->skipValidation() || ValidateGetTexGenfvOES(context, coord, pname, params));
6936 if (isCallValid)
6937 {
6938 context->getTexGenfv(coord, pname, params);
6939 }
6940 ANGLE_CAPTURE(GetTexGenfvOES, isCallValid, context, coord, pname, params);
6941 }
6942 }
6943
GetTexGenivOES(GLenum coord,GLenum pname,GLint * params)6944 void GL_APIENTRY GetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
6945 {
6946 Context *context = GetValidGlobalContext();
6947 EVENT("glGetTexGenivOES",
6948 "context = %d, GLenum coord = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
6949 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
6950 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
6951
6952 if (context)
6953 {
6954 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6955 bool isCallValid =
6956 (context->skipValidation() || ValidateGetTexGenivOES(context, coord, pname, params));
6957 if (isCallValid)
6958 {
6959 context->getTexGeniv(coord, pname, params);
6960 }
6961 ANGLE_CAPTURE(GetTexGenivOES, isCallValid, context, coord, pname, params);
6962 }
6963 }
6964
GetTexGenxvOES(GLenum coord,GLenum pname,GLfixed * params)6965 void GL_APIENTRY GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
6966 {
6967 Context *context = GetValidGlobalContext();
6968 EVENT("glGetTexGenxvOES",
6969 "context = %d, GLenum coord = %s, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR "",
6970 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
6971 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
6972
6973 if (context)
6974 {
6975 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6976 bool isCallValid =
6977 (context->skipValidation() || ValidateGetTexGenxvOES(context, coord, pname, params));
6978 if (isCallValid)
6979 {
6980 context->getTexGenxv(coord, pname, params);
6981 }
6982 ANGLE_CAPTURE(GetTexGenxvOES, isCallValid, context, coord, pname, params);
6983 }
6984 }
6985
TexGenfOES(GLenum coord,GLenum pname,GLfloat param)6986 void GL_APIENTRY TexGenfOES(GLenum coord, GLenum pname, GLfloat param)
6987 {
6988 Context *context = GetValidGlobalContext();
6989 EVENT("glTexGenfOES", "context = %d, GLenum coord = %s, GLenum pname = %s, GLfloat param = %f",
6990 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
6991 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
6992
6993 if (context)
6994 {
6995 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
6996 bool isCallValid =
6997 (context->skipValidation() || ValidateTexGenfOES(context, coord, pname, param));
6998 if (isCallValid)
6999 {
7000 context->texGenf(coord, pname, param);
7001 }
7002 ANGLE_CAPTURE(TexGenfOES, isCallValid, context, coord, pname, param);
7003 }
7004 }
7005
TexGenfvOES(GLenum coord,GLenum pname,const GLfloat * params)7006 void GL_APIENTRY TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
7007 {
7008 Context *context = GetValidGlobalContext();
7009 EVENT(
7010 "glTexGenfvOES",
7011 "context = %d, GLenum coord = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR
7012 "",
7013 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
7014 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
7015
7016 if (context)
7017 {
7018 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7019 bool isCallValid =
7020 (context->skipValidation() || ValidateTexGenfvOES(context, coord, pname, params));
7021 if (isCallValid)
7022 {
7023 context->texGenfv(coord, pname, params);
7024 }
7025 ANGLE_CAPTURE(TexGenfvOES, isCallValid, context, coord, pname, params);
7026 }
7027 }
7028
TexGeniOES(GLenum coord,GLenum pname,GLint param)7029 void GL_APIENTRY TexGeniOES(GLenum coord, GLenum pname, GLint param)
7030 {
7031 Context *context = GetValidGlobalContext();
7032 EVENT("glTexGeniOES", "context = %d, GLenum coord = %s, GLenum pname = %s, GLint param = %d",
7033 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
7034 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
7035
7036 if (context)
7037 {
7038 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7039 bool isCallValid =
7040 (context->skipValidation() || ValidateTexGeniOES(context, coord, pname, param));
7041 if (isCallValid)
7042 {
7043 context->texGeni(coord, pname, param);
7044 }
7045 ANGLE_CAPTURE(TexGeniOES, isCallValid, context, coord, pname, param);
7046 }
7047 }
7048
TexGenivOES(GLenum coord,GLenum pname,const GLint * params)7049 void GL_APIENTRY TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
7050 {
7051 Context *context = GetValidGlobalContext();
7052 EVENT("glTexGenivOES",
7053 "context = %d, GLenum coord = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
7054 "",
7055 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
7056 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
7057
7058 if (context)
7059 {
7060 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7061 bool isCallValid =
7062 (context->skipValidation() || ValidateTexGenivOES(context, coord, pname, params));
7063 if (isCallValid)
7064 {
7065 context->texGeniv(coord, pname, params);
7066 }
7067 ANGLE_CAPTURE(TexGenivOES, isCallValid, context, coord, pname, params);
7068 }
7069 }
7070
TexGenxOES(GLenum coord,GLenum pname,GLfixed param)7071 void GL_APIENTRY TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
7072 {
7073 Context *context = GetValidGlobalContext();
7074 EVENT("glTexGenxOES",
7075 "context = %d, GLenum coord = %s, GLenum pname = %s, GLfixed param = 0x%X", CID(context),
7076 GLenumToString(GLenumGroup::TextureCoordName, coord),
7077 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
7078
7079 if (context)
7080 {
7081 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7082 bool isCallValid =
7083 (context->skipValidation() || ValidateTexGenxOES(context, coord, pname, param));
7084 if (isCallValid)
7085 {
7086 context->texGenx(coord, pname, param);
7087 }
7088 ANGLE_CAPTURE(TexGenxOES, isCallValid, context, coord, pname, param);
7089 }
7090 }
7091
TexGenxvOES(GLenum coord,GLenum pname,const GLfixed * params)7092 void GL_APIENTRY TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
7093 {
7094 Context *context = GetValidGlobalContext();
7095 EVENT(
7096 "glTexGenxvOES",
7097 "context = %d, GLenum coord = %s, GLenum pname = %s, const GLfixed *params = 0x%016" PRIxPTR
7098 "",
7099 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
7100 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
7101
7102 if (context)
7103 {
7104 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7105 bool isCallValid =
7106 (context->skipValidation() || ValidateTexGenxvOES(context, coord, pname, params));
7107 if (isCallValid)
7108 {
7109 context->texGenxv(coord, pname, params);
7110 }
7111 ANGLE_CAPTURE(TexGenxvOES, isCallValid, context, coord, pname, params);
7112 }
7113 }
7114
7115 // GL_OES_texture_cube_map_array
7116
7117 // GL_OES_texture_half_float
7118
7119 // GL_OES_texture_storage_multisample_2d_array
TexStorage3DMultisampleOES(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)7120 void GL_APIENTRY TexStorage3DMultisampleOES(GLenum target,
7121 GLsizei samples,
7122 GLenum internalformat,
7123 GLsizei width,
7124 GLsizei height,
7125 GLsizei depth,
7126 GLboolean fixedsamplelocations)
7127 {
7128 Context *context = GetValidGlobalContext();
7129 EVENT("glTexStorage3DMultisampleOES",
7130 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
7131 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLboolean "
7132 "fixedsamplelocations = %s",
7133 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
7134 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth,
7135 GLbooleanToString(fixedsamplelocations));
7136
7137 if (context)
7138 {
7139 TextureType targetPacked = FromGL<TextureType>(target);
7140 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7141 bool isCallValid =
7142 (context->skipValidation() ||
7143 ValidateTexStorage3DMultisampleOES(context, targetPacked, samples, internalformat,
7144 width, height, depth, fixedsamplelocations));
7145 if (isCallValid)
7146 {
7147 context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
7148 depth, fixedsamplelocations);
7149 }
7150 ANGLE_CAPTURE(TexStorage3DMultisampleOES, isCallValid, context, targetPacked, samples,
7151 internalformat, width, height, depth, fixedsamplelocations);
7152 }
7153 }
7154
7155 // GL_OES_vertex_array_object
BindVertexArrayOES(GLuint array)7156 void GL_APIENTRY BindVertexArrayOES(GLuint array)
7157 {
7158 Context *context = GetValidGlobalContext();
7159 EVENT("glBindVertexArrayOES", "context = %d, GLuint array = %u", CID(context), array);
7160
7161 if (context)
7162 {
7163 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
7164 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7165 bool isCallValid =
7166 (context->skipValidation() || ValidateBindVertexArrayOES(context, arrayPacked));
7167 if (isCallValid)
7168 {
7169 context->bindVertexArray(arrayPacked);
7170 }
7171 ANGLE_CAPTURE(BindVertexArrayOES, isCallValid, context, arrayPacked);
7172 }
7173 }
7174
DeleteVertexArraysOES(GLsizei n,const GLuint * arrays)7175 void GL_APIENTRY DeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
7176 {
7177 Context *context = GetValidGlobalContext();
7178 EVENT("glDeleteVertexArraysOES",
7179 "context = %d, GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR "", CID(context), n,
7180 (uintptr_t)arrays);
7181
7182 if (context)
7183 {
7184 const VertexArrayID *arraysPacked = FromGL<const VertexArrayID *>(arrays);
7185 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7186 bool isCallValid =
7187 (context->skipValidation() || ValidateDeleteVertexArraysOES(context, n, arraysPacked));
7188 if (isCallValid)
7189 {
7190 context->deleteVertexArrays(n, arraysPacked);
7191 }
7192 ANGLE_CAPTURE(DeleteVertexArraysOES, isCallValid, context, n, arraysPacked);
7193 }
7194 }
7195
GenVertexArraysOES(GLsizei n,GLuint * arrays)7196 void GL_APIENTRY GenVertexArraysOES(GLsizei n, GLuint *arrays)
7197 {
7198 Context *context = GetValidGlobalContext();
7199 EVENT("glGenVertexArraysOES",
7200 "context = %d, GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR "", CID(context), n,
7201 (uintptr_t)arrays);
7202
7203 if (context)
7204 {
7205 VertexArrayID *arraysPacked = FromGL<VertexArrayID *>(arrays);
7206 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7207 bool isCallValid =
7208 (context->skipValidation() || ValidateGenVertexArraysOES(context, n, arraysPacked));
7209 if (isCallValid)
7210 {
7211 context->genVertexArrays(n, arraysPacked);
7212 }
7213 ANGLE_CAPTURE(GenVertexArraysOES, isCallValid, context, n, arraysPacked);
7214 }
7215 }
7216
IsVertexArrayOES(GLuint array)7217 GLboolean GL_APIENTRY IsVertexArrayOES(GLuint array)
7218 {
7219 Context *context = GetValidGlobalContext();
7220 EVENT("glIsVertexArrayOES", "context = %d, GLuint array = %u", CID(context), array);
7221
7222 GLboolean returnValue;
7223 if (context)
7224 {
7225 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
7226 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7227 bool isCallValid =
7228 (context->skipValidation() || ValidateIsVertexArrayOES(context, arrayPacked));
7229 if (isCallValid)
7230 {
7231 returnValue = context->isVertexArray(arrayPacked);
7232 }
7233 else
7234 {
7235 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArrayOES, GLboolean>();
7236 }
7237 ANGLE_CAPTURE(IsVertexArrayOES, isCallValid, context, arrayPacked, returnValue);
7238 }
7239 else
7240 {
7241 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArrayOES, GLboolean>();
7242 }
7243 return returnValue;
7244 }
7245
7246 // GL_OVR_multiview
FramebufferTextureMultiviewOVR(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint baseViewIndex,GLsizei numViews)7247 void GL_APIENTRY FramebufferTextureMultiviewOVR(GLenum target,
7248 GLenum attachment,
7249 GLuint texture,
7250 GLint level,
7251 GLint baseViewIndex,
7252 GLsizei numViews)
7253 {
7254 Context *context = GetValidGlobalContext();
7255 EVENT("glFramebufferTextureMultiviewOVR",
7256 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
7257 "level = %d, GLint baseViewIndex = %d, GLsizei numViews = %d",
7258 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
7259 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level,
7260 baseViewIndex, numViews);
7261
7262 if (context)
7263 {
7264 TextureID texturePacked = FromGL<TextureID>(texture);
7265 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7266 bool isCallValid =
7267 (context->skipValidation() ||
7268 ValidateFramebufferTextureMultiviewOVR(context, target, attachment, texturePacked,
7269 level, baseViewIndex, numViews));
7270 if (isCallValid)
7271 {
7272 context->framebufferTextureMultiview(target, attachment, texturePacked, level,
7273 baseViewIndex, numViews);
7274 }
7275 ANGLE_CAPTURE(FramebufferTextureMultiviewOVR, isCallValid, context, target, attachment,
7276 texturePacked, level, baseViewIndex, numViews);
7277 }
7278 }
7279
7280 // GL_OVR_multiview2
7281
7282 // EGL_ANGLE_explicit_context
ActiveShaderProgramContextANGLE(GLeglContext ctx,GLuint pipeline,GLuint program)7283 void GL_APIENTRY ActiveShaderProgramContextANGLE(GLeglContext ctx, GLuint pipeline, GLuint program)
7284 {
7285 Context *context = static_cast<gl::Context *>(ctx);
7286 EVENT("glActiveShaderProgram", "context = %d, GLuint pipeline = %u, GLuint program = %u",
7287 CID(context), pipeline, program);
7288
7289 if (context)
7290 {
7291 ASSERT(context == GetValidGlobalContext());
7292 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
7293 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
7294 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7295 bool isCallValid = (context->skipValidation() ||
7296 ValidateActiveShaderProgram(context, pipelinePacked, programPacked));
7297 if (isCallValid)
7298 {
7299 context->activeShaderProgram(pipelinePacked, programPacked);
7300 }
7301 ANGLE_CAPTURE(ActiveShaderProgram, isCallValid, context, pipelinePacked, programPacked);
7302 }
7303 }
7304
ActiveTextureContextANGLE(GLeglContext ctx,GLenum texture)7305 void GL_APIENTRY ActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
7306 {
7307 Context *context = static_cast<gl::Context *>(ctx);
7308 EVENT("glActiveTexture", "context = %d, GLenum texture = %s", CID(context),
7309 GLenumToString(GLenumGroup::TextureUnit, texture));
7310
7311 if (context)
7312 {
7313 ASSERT(context == GetValidGlobalContext());
7314 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7315 bool isCallValid = (context->skipValidation() || ValidateActiveTexture(context, texture));
7316 if (isCallValid)
7317 {
7318 context->activeTexture(texture);
7319 }
7320 ANGLE_CAPTURE(ActiveTexture, isCallValid, context, texture);
7321 }
7322 }
7323
AlphaFuncContextANGLE(GLeglContext ctx,GLenum func,GLfloat ref)7324 void GL_APIENTRY AlphaFuncContextANGLE(GLeglContext ctx, GLenum func, GLfloat ref)
7325 {
7326 Context *context = static_cast<gl::Context *>(ctx);
7327 EVENT("glAlphaFunc", "context = %d, GLenum func = %s, GLfloat ref = %f", CID(context),
7328 GLenumToString(GLenumGroup::AlphaFunction, func), ref);
7329
7330 if (context)
7331 {
7332 ASSERT(context == GetValidGlobalContext());
7333 AlphaTestFunc funcPacked = FromGL<AlphaTestFunc>(func);
7334 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7335 bool isCallValid =
7336 (context->skipValidation() || ValidateAlphaFunc(context, funcPacked, ref));
7337 if (isCallValid)
7338 {
7339 context->alphaFunc(funcPacked, ref);
7340 }
7341 ANGLE_CAPTURE(AlphaFunc, isCallValid, context, funcPacked, ref);
7342 }
7343 }
7344
AlphaFuncxContextANGLE(GLeglContext ctx,GLenum func,GLfixed ref)7345 void GL_APIENTRY AlphaFuncxContextANGLE(GLeglContext ctx, GLenum func, GLfixed ref)
7346 {
7347 Context *context = static_cast<gl::Context *>(ctx);
7348 EVENT("glAlphaFuncx", "context = %d, GLenum func = %s, GLfixed ref = 0x%X", CID(context),
7349 GLenumToString(GLenumGroup::AlphaFunction, func), ref);
7350
7351 if (context)
7352 {
7353 ASSERT(context == GetValidGlobalContext());
7354 AlphaTestFunc funcPacked = FromGL<AlphaTestFunc>(func);
7355 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7356 bool isCallValid =
7357 (context->skipValidation() || ValidateAlphaFuncx(context, funcPacked, ref));
7358 if (isCallValid)
7359 {
7360 context->alphaFuncx(funcPacked, ref);
7361 }
7362 ANGLE_CAPTURE(AlphaFuncx, isCallValid, context, funcPacked, ref);
7363 }
7364 }
7365
AttachShaderContextANGLE(GLeglContext ctx,GLuint program,GLuint shader)7366 void GL_APIENTRY AttachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
7367 {
7368 Context *context = static_cast<gl::Context *>(ctx);
7369 EVENT("glAttachShader", "context = %d, GLuint program = %u, GLuint shader = %u", CID(context),
7370 program, shader);
7371
7372 if (context)
7373 {
7374 ASSERT(context == GetValidGlobalContext());
7375 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
7376 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
7377 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7378 bool isCallValid = (context->skipValidation() ||
7379 ValidateAttachShader(context, programPacked, shaderPacked));
7380 if (isCallValid)
7381 {
7382 context->attachShader(programPacked, shaderPacked);
7383 }
7384 ANGLE_CAPTURE(AttachShader, isCallValid, context, programPacked, shaderPacked);
7385 }
7386 }
7387
BeginQueryContextANGLE(GLeglContext ctx,GLenum target,GLuint id)7388 void GL_APIENTRY BeginQueryContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
7389 {
7390 Context *context = static_cast<gl::Context *>(ctx);
7391 EVENT("glBeginQuery", "context = %d, GLenum target = %s, GLuint id = %u", CID(context),
7392 GLenumToString(GLenumGroup::QueryTarget, target), id);
7393
7394 if (context)
7395 {
7396 ASSERT(context == GetValidGlobalContext());
7397 QueryType targetPacked = FromGL<QueryType>(target);
7398 QueryID idPacked = FromGL<QueryID>(id);
7399 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7400 bool isCallValid =
7401 (context->skipValidation() || ValidateBeginQuery(context, targetPacked, idPacked));
7402 if (isCallValid)
7403 {
7404 context->beginQuery(targetPacked, idPacked);
7405 }
7406 ANGLE_CAPTURE(BeginQuery, isCallValid, context, targetPacked, idPacked);
7407 }
7408 }
7409
BeginQueryEXTContextANGLE(GLeglContext ctx,GLenum target,GLuint id)7410 void GL_APIENTRY BeginQueryEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
7411 {
7412 Context *context = static_cast<gl::Context *>(ctx);
7413 EVENT("glBeginQueryEXT", "context = %d, GLenum target = %s, GLuint id = %u", CID(context),
7414 GLenumToString(GLenumGroup::QueryTarget, target), id);
7415
7416 if (context)
7417 {
7418 ASSERT(context == GetValidGlobalContext());
7419 QueryType targetPacked = FromGL<QueryType>(target);
7420 QueryID idPacked = FromGL<QueryID>(id);
7421 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7422 bool isCallValid =
7423 (context->skipValidation() || ValidateBeginQueryEXT(context, targetPacked, idPacked));
7424 if (isCallValid)
7425 {
7426 context->beginQuery(targetPacked, idPacked);
7427 }
7428 ANGLE_CAPTURE(BeginQueryEXT, isCallValid, context, targetPacked, idPacked);
7429 }
7430 }
7431
BeginTransformFeedbackContextANGLE(GLeglContext ctx,GLenum primitiveMode)7432 void GL_APIENTRY BeginTransformFeedbackContextANGLE(GLeglContext ctx, GLenum primitiveMode)
7433 {
7434 Context *context = static_cast<gl::Context *>(ctx);
7435 EVENT("glBeginTransformFeedback", "context = %d, GLenum primitiveMode = %s", CID(context),
7436 GLenumToString(GLenumGroup::PrimitiveType, primitiveMode));
7437
7438 if (context)
7439 {
7440 ASSERT(context == GetValidGlobalContext());
7441 PrimitiveMode primitiveModePacked = FromGL<PrimitiveMode>(primitiveMode);
7442 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7443 bool isCallValid = (context->skipValidation() ||
7444 ValidateBeginTransformFeedback(context, primitiveModePacked));
7445 if (isCallValid)
7446 {
7447 context->beginTransformFeedback(primitiveModePacked);
7448 }
7449 ANGLE_CAPTURE(BeginTransformFeedback, isCallValid, context, primitiveModePacked);
7450 }
7451 }
7452
BindAttribLocationContextANGLE(GLeglContext ctx,GLuint program,GLuint index,const GLchar * name)7453 void GL_APIENTRY BindAttribLocationContextANGLE(GLeglContext ctx,
7454 GLuint program,
7455 GLuint index,
7456 const GLchar *name)
7457 {
7458 Context *context = static_cast<gl::Context *>(ctx);
7459 EVENT(
7460 "glBindAttribLocation",
7461 "context = %d, GLuint program = %u, GLuint index = %u, const GLchar *name = 0x%016" PRIxPTR
7462 "",
7463 CID(context), program, index, (uintptr_t)name);
7464
7465 if (context)
7466 {
7467 ASSERT(context == GetValidGlobalContext());
7468 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
7469 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7470 bool isCallValid = (context->skipValidation() ||
7471 ValidateBindAttribLocation(context, programPacked, index, name));
7472 if (isCallValid)
7473 {
7474 context->bindAttribLocation(programPacked, index, name);
7475 }
7476 ANGLE_CAPTURE(BindAttribLocation, isCallValid, context, programPacked, index, name);
7477 }
7478 }
7479
BindBufferContextANGLE(GLeglContext ctx,GLenum target,GLuint buffer)7480 void GL_APIENTRY BindBufferContextANGLE(GLeglContext ctx, GLenum target, GLuint buffer)
7481 {
7482 Context *context = static_cast<gl::Context *>(ctx);
7483 EVENT("glBindBuffer", "context = %d, GLenum target = %s, GLuint buffer = %u", CID(context),
7484 GLenumToString(GLenumGroup::BufferTargetARB, target), buffer);
7485
7486 if (context)
7487 {
7488 ASSERT(context == GetValidGlobalContext());
7489 BufferBinding targetPacked = FromGL<BufferBinding>(target);
7490 BufferID bufferPacked = FromGL<BufferID>(buffer);
7491 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7492 bool isCallValid =
7493 (context->skipValidation() || ValidateBindBuffer(context, targetPacked, bufferPacked));
7494 if (isCallValid)
7495 {
7496 context->bindBuffer(targetPacked, bufferPacked);
7497 }
7498 ANGLE_CAPTURE(BindBuffer, isCallValid, context, targetPacked, bufferPacked);
7499 }
7500 }
7501
BindBufferBaseContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLuint buffer)7502 void GL_APIENTRY BindBufferBaseContextANGLE(GLeglContext ctx,
7503 GLenum target,
7504 GLuint index,
7505 GLuint buffer)
7506 {
7507 Context *context = static_cast<gl::Context *>(ctx);
7508 EVENT("glBindBufferBase",
7509 "context = %d, GLenum target = %s, GLuint index = %u, GLuint buffer = %u", CID(context),
7510 GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer);
7511
7512 if (context)
7513 {
7514 ASSERT(context == GetValidGlobalContext());
7515 BufferBinding targetPacked = FromGL<BufferBinding>(target);
7516 BufferID bufferPacked = FromGL<BufferID>(buffer);
7517 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7518 bool isCallValid = (context->skipValidation() ||
7519 ValidateBindBufferBase(context, targetPacked, index, bufferPacked));
7520 if (isCallValid)
7521 {
7522 context->bindBufferBase(targetPacked, index, bufferPacked);
7523 }
7524 ANGLE_CAPTURE(BindBufferBase, isCallValid, context, targetPacked, index, bufferPacked);
7525 }
7526 }
7527
BindBufferRangeContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size)7528 void GL_APIENTRY BindBufferRangeContextANGLE(GLeglContext ctx,
7529 GLenum target,
7530 GLuint index,
7531 GLuint buffer,
7532 GLintptr offset,
7533 GLsizeiptr size)
7534 {
7535 Context *context = static_cast<gl::Context *>(ctx);
7536 EVENT("glBindBufferRange",
7537 "context = %d, GLenum target = %s, GLuint index = %u, GLuint buffer = %u, GLintptr "
7538 "offset = %llu, GLsizeiptr size = %llu",
7539 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer,
7540 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
7541
7542 if (context)
7543 {
7544 ASSERT(context == GetValidGlobalContext());
7545 BufferBinding targetPacked = FromGL<BufferBinding>(target);
7546 BufferID bufferPacked = FromGL<BufferID>(buffer);
7547 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7548 bool isCallValid =
7549 (context->skipValidation() ||
7550 ValidateBindBufferRange(context, targetPacked, index, bufferPacked, offset, size));
7551 if (isCallValid)
7552 {
7553 context->bindBufferRange(targetPacked, index, bufferPacked, offset, size);
7554 }
7555 ANGLE_CAPTURE(BindBufferRange, isCallValid, context, targetPacked, index, bufferPacked,
7556 offset, size);
7557 }
7558 }
7559
BindFragDataLocationEXTContextANGLE(GLeglContext ctx,GLuint program,GLuint color,const GLchar * name)7560 void GL_APIENTRY BindFragDataLocationEXTContextANGLE(GLeglContext ctx,
7561 GLuint program,
7562 GLuint color,
7563 const GLchar *name)
7564 {
7565 Context *context = static_cast<gl::Context *>(ctx);
7566 EVENT(
7567 "glBindFragDataLocationEXT",
7568 "context = %d, GLuint program = %u, GLuint color = %u, const GLchar *name = 0x%016" PRIxPTR
7569 "",
7570 CID(context), program, color, (uintptr_t)name);
7571
7572 if (context)
7573 {
7574 ASSERT(context == GetValidGlobalContext());
7575 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
7576 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7577 bool isCallValid = (context->skipValidation() ||
7578 ValidateBindFragDataLocationEXT(context, programPacked, color, name));
7579 if (isCallValid)
7580 {
7581 context->bindFragDataLocation(programPacked, color, name);
7582 }
7583 ANGLE_CAPTURE(BindFragDataLocationEXT, isCallValid, context, programPacked, color, name);
7584 }
7585 }
7586
BindFragDataLocationIndexedEXTContextANGLE(GLeglContext ctx,GLuint program,GLuint colorNumber,GLuint index,const GLchar * name)7587 void GL_APIENTRY BindFragDataLocationIndexedEXTContextANGLE(GLeglContext ctx,
7588 GLuint program,
7589 GLuint colorNumber,
7590 GLuint index,
7591 const GLchar *name)
7592 {
7593 Context *context = static_cast<gl::Context *>(ctx);
7594 EVENT("glBindFragDataLocationIndexedEXT",
7595 "context = %d, GLuint program = %u, GLuint colorNumber = %u, GLuint index = %u, const "
7596 "GLchar *name = 0x%016" PRIxPTR "",
7597 CID(context), program, colorNumber, index, (uintptr_t)name);
7598
7599 if (context)
7600 {
7601 ASSERT(context == GetValidGlobalContext());
7602 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
7603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7604 bool isCallValid =
7605 (context->skipValidation() || ValidateBindFragDataLocationIndexedEXT(
7606 context, programPacked, colorNumber, index, name));
7607 if (isCallValid)
7608 {
7609 context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
7610 }
7611 ANGLE_CAPTURE(BindFragDataLocationIndexedEXT, isCallValid, context, programPacked,
7612 colorNumber, index, name);
7613 }
7614 }
7615
BindFramebufferContextANGLE(GLeglContext ctx,GLenum target,GLuint framebuffer)7616 void GL_APIENTRY BindFramebufferContextANGLE(GLeglContext ctx, GLenum target, GLuint framebuffer)
7617 {
7618 Context *context = static_cast<gl::Context *>(ctx);
7619 EVENT("glBindFramebuffer", "context = %d, GLenum target = %s, GLuint framebuffer = %u",
7620 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer);
7621
7622 if (context)
7623 {
7624 ASSERT(context == GetValidGlobalContext());
7625 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
7626 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7627 bool isCallValid = (context->skipValidation() ||
7628 ValidateBindFramebuffer(context, target, framebufferPacked));
7629 if (isCallValid)
7630 {
7631 context->bindFramebuffer(target, framebufferPacked);
7632 }
7633 ANGLE_CAPTURE(BindFramebuffer, isCallValid, context, target, framebufferPacked);
7634 }
7635 }
7636
BindFramebufferOESContextANGLE(GLeglContext ctx,GLenum target,GLuint framebuffer)7637 void GL_APIENTRY BindFramebufferOESContextANGLE(GLeglContext ctx, GLenum target, GLuint framebuffer)
7638 {
7639 Context *context = static_cast<gl::Context *>(ctx);
7640 EVENT("glBindFramebufferOES", "context = %d, GLenum target = %s, GLuint framebuffer = %u",
7641 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer);
7642
7643 if (context)
7644 {
7645 ASSERT(context == GetValidGlobalContext());
7646 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
7647 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7648 bool isCallValid = (context->skipValidation() ||
7649 ValidateBindFramebufferOES(context, target, framebufferPacked));
7650 if (isCallValid)
7651 {
7652 context->bindFramebuffer(target, framebufferPacked);
7653 }
7654 ANGLE_CAPTURE(BindFramebufferOES, isCallValid, context, target, framebufferPacked);
7655 }
7656 }
7657
BindImageTextureContextANGLE(GLeglContext ctx,GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)7658 void GL_APIENTRY BindImageTextureContextANGLE(GLeglContext ctx,
7659 GLuint unit,
7660 GLuint texture,
7661 GLint level,
7662 GLboolean layered,
7663 GLint layer,
7664 GLenum access,
7665 GLenum format)
7666 {
7667 Context *context = static_cast<gl::Context *>(ctx);
7668 EVENT("glBindImageTexture",
7669 "context = %d, GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean "
7670 "layered = %s, GLint layer = %d, GLenum access = %s, GLenum format = %s",
7671 CID(context), unit, texture, level, GLbooleanToString(layered), layer,
7672 GLenumToString(GLenumGroup::BufferAccessARB, access),
7673 GLenumToString(GLenumGroup::InternalFormat, format));
7674
7675 if (context)
7676 {
7677 ASSERT(context == GetValidGlobalContext());
7678 TextureID texturePacked = FromGL<TextureID>(texture);
7679 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7680 bool isCallValid = (context->skipValidation() ||
7681 ValidateBindImageTexture(context, unit, texturePacked, level, layered,
7682 layer, access, format));
7683 if (isCallValid)
7684 {
7685 context->bindImageTexture(unit, texturePacked, level, layered, layer, access, format);
7686 }
7687 ANGLE_CAPTURE(BindImageTexture, isCallValid, context, unit, texturePacked, level, layered,
7688 layer, access, format);
7689 }
7690 }
7691
BindProgramPipelineContextANGLE(GLeglContext ctx,GLuint pipeline)7692 void GL_APIENTRY BindProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
7693 {
7694 Context *context = static_cast<gl::Context *>(ctx);
7695 EVENT("glBindProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), pipeline);
7696
7697 if (context)
7698 {
7699 ASSERT(context == GetValidGlobalContext());
7700 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
7701 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7702 bool isCallValid =
7703 (context->skipValidation() || ValidateBindProgramPipeline(context, pipelinePacked));
7704 if (isCallValid)
7705 {
7706 context->bindProgramPipeline(pipelinePacked);
7707 }
7708 ANGLE_CAPTURE(BindProgramPipeline, isCallValid, context, pipelinePacked);
7709 }
7710 }
7711
BindRenderbufferContextANGLE(GLeglContext ctx,GLenum target,GLuint renderbuffer)7712 void GL_APIENTRY BindRenderbufferContextANGLE(GLeglContext ctx, GLenum target, GLuint renderbuffer)
7713 {
7714 Context *context = static_cast<gl::Context *>(ctx);
7715 EVENT("glBindRenderbuffer", "context = %d, GLenum target = %s, GLuint renderbuffer = %u",
7716 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer);
7717
7718 if (context)
7719 {
7720 ASSERT(context == GetValidGlobalContext());
7721 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
7722 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7723 bool isCallValid = (context->skipValidation() ||
7724 ValidateBindRenderbuffer(context, target, renderbufferPacked));
7725 if (isCallValid)
7726 {
7727 context->bindRenderbuffer(target, renderbufferPacked);
7728 }
7729 ANGLE_CAPTURE(BindRenderbuffer, isCallValid, context, target, renderbufferPacked);
7730 }
7731 }
7732
BindRenderbufferOESContextANGLE(GLeglContext ctx,GLenum target,GLuint renderbuffer)7733 void GL_APIENTRY BindRenderbufferOESContextANGLE(GLeglContext ctx,
7734 GLenum target,
7735 GLuint renderbuffer)
7736 {
7737 Context *context = static_cast<gl::Context *>(ctx);
7738 EVENT("glBindRenderbufferOES", "context = %d, GLenum target = %s, GLuint renderbuffer = %u",
7739 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer);
7740
7741 if (context)
7742 {
7743 ASSERT(context == GetValidGlobalContext());
7744 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
7745 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7746 bool isCallValid = (context->skipValidation() ||
7747 ValidateBindRenderbufferOES(context, target, renderbufferPacked));
7748 if (isCallValid)
7749 {
7750 context->bindRenderbuffer(target, renderbufferPacked);
7751 }
7752 ANGLE_CAPTURE(BindRenderbufferOES, isCallValid, context, target, renderbufferPacked);
7753 }
7754 }
7755
BindSamplerContextANGLE(GLeglContext ctx,GLuint unit,GLuint sampler)7756 void GL_APIENTRY BindSamplerContextANGLE(GLeglContext ctx, GLuint unit, GLuint sampler)
7757 {
7758 Context *context = static_cast<gl::Context *>(ctx);
7759 EVENT("glBindSampler", "context = %d, GLuint unit = %u, GLuint sampler = %u", CID(context),
7760 unit, sampler);
7761
7762 if (context)
7763 {
7764 ASSERT(context == GetValidGlobalContext());
7765 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
7766 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7767 bool isCallValid =
7768 (context->skipValidation() || ValidateBindSampler(context, unit, samplerPacked));
7769 if (isCallValid)
7770 {
7771 context->bindSampler(unit, samplerPacked);
7772 }
7773 ANGLE_CAPTURE(BindSampler, isCallValid, context, unit, samplerPacked);
7774 }
7775 }
7776
BindTextureContextANGLE(GLeglContext ctx,GLenum target,GLuint texture)7777 void GL_APIENTRY BindTextureContextANGLE(GLeglContext ctx, GLenum target, GLuint texture)
7778 {
7779 Context *context = static_cast<gl::Context *>(ctx);
7780 EVENT("glBindTexture", "context = %d, GLenum target = %s, GLuint texture = %u", CID(context),
7781 GLenumToString(GLenumGroup::TextureTarget, target), texture);
7782
7783 if (context)
7784 {
7785 ASSERT(context == GetValidGlobalContext());
7786 TextureType targetPacked = FromGL<TextureType>(target);
7787 TextureID texturePacked = FromGL<TextureID>(texture);
7788 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7789 bool isCallValid = (context->skipValidation() ||
7790 ValidateBindTexture(context, targetPacked, texturePacked));
7791 if (isCallValid)
7792 {
7793 context->bindTexture(targetPacked, texturePacked);
7794 }
7795 ANGLE_CAPTURE(BindTexture, isCallValid, context, targetPacked, texturePacked);
7796 }
7797 }
7798
BindTransformFeedbackContextANGLE(GLeglContext ctx,GLenum target,GLuint id)7799 void GL_APIENTRY BindTransformFeedbackContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
7800 {
7801 Context *context = static_cast<gl::Context *>(ctx);
7802 EVENT("glBindTransformFeedback", "context = %d, GLenum target = %s, GLuint id = %u",
7803 CID(context), GLenumToString(GLenumGroup::BindTransformFeedbackTarget, target), id);
7804
7805 if (context)
7806 {
7807 ASSERT(context == GetValidGlobalContext());
7808 TransformFeedbackID idPacked = FromGL<TransformFeedbackID>(id);
7809 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7810 bool isCallValid =
7811 (context->skipValidation() || ValidateBindTransformFeedback(context, target, idPacked));
7812 if (isCallValid)
7813 {
7814 context->bindTransformFeedback(target, idPacked);
7815 }
7816 ANGLE_CAPTURE(BindTransformFeedback, isCallValid, context, target, idPacked);
7817 }
7818 }
7819
BindVertexArrayContextANGLE(GLeglContext ctx,GLuint array)7820 void GL_APIENTRY BindVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
7821 {
7822 Context *context = static_cast<gl::Context *>(ctx);
7823 EVENT("glBindVertexArray", "context = %d, GLuint array = %u", CID(context), array);
7824
7825 if (context)
7826 {
7827 ASSERT(context == GetValidGlobalContext());
7828 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
7829 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7830 bool isCallValid =
7831 (context->skipValidation() || ValidateBindVertexArray(context, arrayPacked));
7832 if (isCallValid)
7833 {
7834 context->bindVertexArray(arrayPacked);
7835 }
7836 ANGLE_CAPTURE(BindVertexArray, isCallValid, context, arrayPacked);
7837 }
7838 }
7839
BindVertexArrayOESContextANGLE(GLeglContext ctx,GLuint array)7840 void GL_APIENTRY BindVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
7841 {
7842 Context *context = static_cast<gl::Context *>(ctx);
7843 EVENT("glBindVertexArrayOES", "context = %d, GLuint array = %u", CID(context), array);
7844
7845 if (context)
7846 {
7847 ASSERT(context == GetValidGlobalContext());
7848 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
7849 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7850 bool isCallValid =
7851 (context->skipValidation() || ValidateBindVertexArrayOES(context, arrayPacked));
7852 if (isCallValid)
7853 {
7854 context->bindVertexArray(arrayPacked);
7855 }
7856 ANGLE_CAPTURE(BindVertexArrayOES, isCallValid, context, arrayPacked);
7857 }
7858 }
7859
BindVertexBufferContextANGLE(GLeglContext ctx,GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride)7860 void GL_APIENTRY BindVertexBufferContextANGLE(GLeglContext ctx,
7861 GLuint bindingindex,
7862 GLuint buffer,
7863 GLintptr offset,
7864 GLsizei stride)
7865 {
7866 Context *context = static_cast<gl::Context *>(ctx);
7867 EVENT("glBindVertexBuffer",
7868 "context = %d, GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %llu, "
7869 "GLsizei stride = %d",
7870 CID(context), bindingindex, buffer, static_cast<unsigned long long>(offset), stride);
7871
7872 if (context)
7873 {
7874 ASSERT(context == GetValidGlobalContext());
7875 BufferID bufferPacked = FromGL<BufferID>(buffer);
7876 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7877 bool isCallValid =
7878 (context->skipValidation() ||
7879 ValidateBindVertexBuffer(context, bindingindex, bufferPacked, offset, stride));
7880 if (isCallValid)
7881 {
7882 context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride);
7883 }
7884 ANGLE_CAPTURE(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset,
7885 stride);
7886 }
7887 }
7888
BlendBarrierContextANGLE(GLeglContext ctx)7889 void GL_APIENTRY BlendBarrierContextANGLE(GLeglContext ctx)
7890 {
7891 Context *context = static_cast<gl::Context *>(ctx);
7892 EVENT("glBlendBarrier", "context = %d", CID(context));
7893
7894 if (context)
7895 {
7896 ASSERT(context == GetValidGlobalContext());
7897 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7898 bool isCallValid = (context->skipValidation() || ValidateBlendBarrier(context));
7899 if (isCallValid)
7900 {
7901 context->blendBarrier();
7902 }
7903 ANGLE_CAPTURE(BlendBarrier, isCallValid, context);
7904 }
7905 }
7906
7907 void GL_APIENTRY
BlendColorContextANGLE(GLeglContext ctx,GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)7908 BlendColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
7909 {
7910 Context *context = static_cast<gl::Context *>(ctx);
7911 EVENT(
7912 "glBlendColor",
7913 "context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
7914 CID(context), red, green, blue, alpha);
7915
7916 if (context)
7917 {
7918 ASSERT(context == GetValidGlobalContext());
7919 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7920 bool isCallValid =
7921 (context->skipValidation() || ValidateBlendColor(context, red, green, blue, alpha));
7922 if (isCallValid)
7923 {
7924 context->blendColor(red, green, blue, alpha);
7925 }
7926 ANGLE_CAPTURE(BlendColor, isCallValid, context, red, green, blue, alpha);
7927 }
7928 }
7929
BlendEquationContextANGLE(GLeglContext ctx,GLenum mode)7930 void GL_APIENTRY BlendEquationContextANGLE(GLeglContext ctx, GLenum mode)
7931 {
7932 Context *context = static_cast<gl::Context *>(ctx);
7933 EVENT("glBlendEquation", "context = %d, GLenum mode = %s", CID(context),
7934 GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
7935
7936 if (context)
7937 {
7938 ASSERT(context == GetValidGlobalContext());
7939 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7940 bool isCallValid = (context->skipValidation() || ValidateBlendEquation(context, mode));
7941 if (isCallValid)
7942 {
7943 context->blendEquation(mode);
7944 }
7945 ANGLE_CAPTURE(BlendEquation, isCallValid, context, mode);
7946 }
7947 }
7948
BlendEquationSeparateContextANGLE(GLeglContext ctx,GLenum modeRGB,GLenum modeAlpha)7949 void GL_APIENTRY BlendEquationSeparateContextANGLE(GLeglContext ctx,
7950 GLenum modeRGB,
7951 GLenum modeAlpha)
7952 {
7953 Context *context = static_cast<gl::Context *>(ctx);
7954 EVENT("glBlendEquationSeparate", "context = %d, GLenum modeRGB = %s, GLenum modeAlpha = %s",
7955 CID(context), GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
7956 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
7957
7958 if (context)
7959 {
7960 ASSERT(context == GetValidGlobalContext());
7961 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7962 bool isCallValid = (context->skipValidation() ||
7963 ValidateBlendEquationSeparate(context, modeRGB, modeAlpha));
7964 if (isCallValid)
7965 {
7966 context->blendEquationSeparate(modeRGB, modeAlpha);
7967 }
7968 ANGLE_CAPTURE(BlendEquationSeparate, isCallValid, context, modeRGB, modeAlpha);
7969 }
7970 }
7971
BlendEquationSeparateiContextANGLE(GLeglContext ctx,GLuint buf,GLenum modeRGB,GLenum modeAlpha)7972 void GL_APIENTRY BlendEquationSeparateiContextANGLE(GLeglContext ctx,
7973 GLuint buf,
7974 GLenum modeRGB,
7975 GLenum modeAlpha)
7976 {
7977 Context *context = static_cast<gl::Context *>(ctx);
7978 EVENT("glBlendEquationSeparatei",
7979 "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
7980 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
7981 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
7982
7983 if (context)
7984 {
7985 ASSERT(context == GetValidGlobalContext());
7986 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
7987 bool isCallValid = (context->skipValidation() ||
7988 ValidateBlendEquationSeparatei(context, buf, modeRGB, modeAlpha));
7989 if (isCallValid)
7990 {
7991 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
7992 }
7993 ANGLE_CAPTURE(BlendEquationSeparatei, isCallValid, context, buf, modeRGB, modeAlpha);
7994 }
7995 }
7996
BlendEquationSeparateiEXTContextANGLE(GLeglContext ctx,GLuint buf,GLenum modeRGB,GLenum modeAlpha)7997 void GL_APIENTRY BlendEquationSeparateiEXTContextANGLE(GLeglContext ctx,
7998 GLuint buf,
7999 GLenum modeRGB,
8000 GLenum modeAlpha)
8001 {
8002 Context *context = static_cast<gl::Context *>(ctx);
8003 EVENT("glBlendEquationSeparateiEXT",
8004 "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
8005 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
8006 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
8007
8008 if (context)
8009 {
8010 ASSERT(context == GetValidGlobalContext());
8011 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8012 bool isCallValid = (context->skipValidation() ||
8013 ValidateBlendEquationSeparateiEXT(context, buf, modeRGB, modeAlpha));
8014 if (isCallValid)
8015 {
8016 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
8017 }
8018 ANGLE_CAPTURE(BlendEquationSeparateiEXT, isCallValid, context, buf, modeRGB, modeAlpha);
8019 }
8020 }
8021
BlendEquationSeparateiOESContextANGLE(GLeglContext ctx,GLuint buf,GLenum modeRGB,GLenum modeAlpha)8022 void GL_APIENTRY BlendEquationSeparateiOESContextANGLE(GLeglContext ctx,
8023 GLuint buf,
8024 GLenum modeRGB,
8025 GLenum modeAlpha)
8026 {
8027 Context *context = static_cast<gl::Context *>(ctx);
8028 EVENT("glBlendEquationSeparateiOES",
8029 "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
8030 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
8031 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
8032
8033 if (context)
8034 {
8035 ASSERT(context == GetValidGlobalContext());
8036 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8037 bool isCallValid = (context->skipValidation() ||
8038 ValidateBlendEquationSeparateiOES(context, buf, modeRGB, modeAlpha));
8039 if (isCallValid)
8040 {
8041 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
8042 }
8043 ANGLE_CAPTURE(BlendEquationSeparateiOES, isCallValid, context, buf, modeRGB, modeAlpha);
8044 }
8045 }
8046
BlendEquationiContextANGLE(GLeglContext ctx,GLuint buf,GLenum mode)8047 void GL_APIENTRY BlendEquationiContextANGLE(GLeglContext ctx, GLuint buf, GLenum mode)
8048 {
8049 Context *context = static_cast<gl::Context *>(ctx);
8050 EVENT("glBlendEquationi", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context), buf,
8051 GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
8052
8053 if (context)
8054 {
8055 ASSERT(context == GetValidGlobalContext());
8056 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8057 bool isCallValid =
8058 (context->skipValidation() || ValidateBlendEquationi(context, buf, mode));
8059 if (isCallValid)
8060 {
8061 context->blendEquationi(buf, mode);
8062 }
8063 ANGLE_CAPTURE(BlendEquationi, isCallValid, context, buf, mode);
8064 }
8065 }
8066
BlendEquationiEXTContextANGLE(GLeglContext ctx,GLuint buf,GLenum mode)8067 void GL_APIENTRY BlendEquationiEXTContextANGLE(GLeglContext ctx, GLuint buf, GLenum mode)
8068 {
8069 Context *context = static_cast<gl::Context *>(ctx);
8070 EVENT("glBlendEquationiEXT", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context),
8071 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
8072
8073 if (context)
8074 {
8075 ASSERT(context == GetValidGlobalContext());
8076 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8077 bool isCallValid =
8078 (context->skipValidation() || ValidateBlendEquationiEXT(context, buf, mode));
8079 if (isCallValid)
8080 {
8081 context->blendEquationi(buf, mode);
8082 }
8083 ANGLE_CAPTURE(BlendEquationiEXT, isCallValid, context, buf, mode);
8084 }
8085 }
8086
BlendEquationiOESContextANGLE(GLeglContext ctx,GLuint buf,GLenum mode)8087 void GL_APIENTRY BlendEquationiOESContextANGLE(GLeglContext ctx, GLuint buf, GLenum mode)
8088 {
8089 Context *context = static_cast<gl::Context *>(ctx);
8090 EVENT("glBlendEquationiOES", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context),
8091 buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
8092
8093 if (context)
8094 {
8095 ASSERT(context == GetValidGlobalContext());
8096 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8097 bool isCallValid =
8098 (context->skipValidation() || ValidateBlendEquationiOES(context, buf, mode));
8099 if (isCallValid)
8100 {
8101 context->blendEquationi(buf, mode);
8102 }
8103 ANGLE_CAPTURE(BlendEquationiOES, isCallValid, context, buf, mode);
8104 }
8105 }
8106
BlendFuncContextANGLE(GLeglContext ctx,GLenum sfactor,GLenum dfactor)8107 void GL_APIENTRY BlendFuncContextANGLE(GLeglContext ctx, GLenum sfactor, GLenum dfactor)
8108 {
8109 Context *context = static_cast<gl::Context *>(ctx);
8110 EVENT("glBlendFunc", "context = %d, GLenum sfactor = %s, GLenum dfactor = %s", CID(context),
8111 GLenumToString(GLenumGroup::BlendingFactor, sfactor),
8112 GLenumToString(GLenumGroup::BlendingFactor, dfactor));
8113
8114 if (context)
8115 {
8116 ASSERT(context == GetValidGlobalContext());
8117 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8118 bool isCallValid =
8119 (context->skipValidation() || ValidateBlendFunc(context, sfactor, dfactor));
8120 if (isCallValid)
8121 {
8122 context->blendFunc(sfactor, dfactor);
8123 }
8124 ANGLE_CAPTURE(BlendFunc, isCallValid, context, sfactor, dfactor);
8125 }
8126 }
8127
BlendFuncSeparateContextANGLE(GLeglContext ctx,GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha)8128 void GL_APIENTRY BlendFuncSeparateContextANGLE(GLeglContext ctx,
8129 GLenum sfactorRGB,
8130 GLenum dfactorRGB,
8131 GLenum sfactorAlpha,
8132 GLenum dfactorAlpha)
8133 {
8134 Context *context = static_cast<gl::Context *>(ctx);
8135 EVENT("glBlendFuncSeparate",
8136 "context = %d, GLenum sfactorRGB = %s, GLenum dfactorRGB = %s, GLenum sfactorAlpha = %s, "
8137 "GLenum dfactorAlpha = %s",
8138 CID(context), GLenumToString(GLenumGroup::BlendingFactor, sfactorRGB),
8139 GLenumToString(GLenumGroup::BlendingFactor, dfactorRGB),
8140 GLenumToString(GLenumGroup::BlendingFactor, sfactorAlpha),
8141 GLenumToString(GLenumGroup::BlendingFactor, dfactorAlpha));
8142
8143 if (context)
8144 {
8145 ASSERT(context == GetValidGlobalContext());
8146 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8147 bool isCallValid =
8148 (context->skipValidation() || ValidateBlendFuncSeparate(context, sfactorRGB, dfactorRGB,
8149 sfactorAlpha, dfactorAlpha));
8150 if (isCallValid)
8151 {
8152 context->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
8153 }
8154 ANGLE_CAPTURE(BlendFuncSeparate, isCallValid, context, sfactorRGB, dfactorRGB, sfactorAlpha,
8155 dfactorAlpha);
8156 }
8157 }
8158
BlendFuncSeparateiContextANGLE(GLeglContext ctx,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)8159 void GL_APIENTRY BlendFuncSeparateiContextANGLE(GLeglContext ctx,
8160 GLuint buf,
8161 GLenum srcRGB,
8162 GLenum dstRGB,
8163 GLenum srcAlpha,
8164 GLenum dstAlpha)
8165 {
8166 Context *context = static_cast<gl::Context *>(ctx);
8167 EVENT("glBlendFuncSeparatei",
8168 "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
8169 "= %s, GLenum dstAlpha = %s",
8170 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
8171 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
8172 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
8173 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
8174
8175 if (context)
8176 {
8177 ASSERT(context == GetValidGlobalContext());
8178 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8179 bool isCallValid =
8180 (context->skipValidation() ||
8181 ValidateBlendFuncSeparatei(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
8182 if (isCallValid)
8183 {
8184 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
8185 }
8186 ANGLE_CAPTURE(BlendFuncSeparatei, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
8187 dstAlpha);
8188 }
8189 }
8190
BlendFuncSeparateiEXTContextANGLE(GLeglContext ctx,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)8191 void GL_APIENTRY BlendFuncSeparateiEXTContextANGLE(GLeglContext ctx,
8192 GLuint buf,
8193 GLenum srcRGB,
8194 GLenum dstRGB,
8195 GLenum srcAlpha,
8196 GLenum dstAlpha)
8197 {
8198 Context *context = static_cast<gl::Context *>(ctx);
8199 EVENT("glBlendFuncSeparateiEXT",
8200 "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
8201 "= %s, GLenum dstAlpha = %s",
8202 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
8203 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
8204 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
8205 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
8206
8207 if (context)
8208 {
8209 ASSERT(context == GetValidGlobalContext());
8210 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8211 bool isCallValid =
8212 (context->skipValidation() ||
8213 ValidateBlendFuncSeparateiEXT(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
8214 if (isCallValid)
8215 {
8216 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
8217 }
8218 ANGLE_CAPTURE(BlendFuncSeparateiEXT, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
8219 dstAlpha);
8220 }
8221 }
8222
BlendFuncSeparateiOESContextANGLE(GLeglContext ctx,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)8223 void GL_APIENTRY BlendFuncSeparateiOESContextANGLE(GLeglContext ctx,
8224 GLuint buf,
8225 GLenum srcRGB,
8226 GLenum dstRGB,
8227 GLenum srcAlpha,
8228 GLenum dstAlpha)
8229 {
8230 Context *context = static_cast<gl::Context *>(ctx);
8231 EVENT("glBlendFuncSeparateiOES",
8232 "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
8233 "= %s, GLenum dstAlpha = %s",
8234 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
8235 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
8236 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
8237 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
8238
8239 if (context)
8240 {
8241 ASSERT(context == GetValidGlobalContext());
8242 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8243 bool isCallValid =
8244 (context->skipValidation() ||
8245 ValidateBlendFuncSeparateiOES(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
8246 if (isCallValid)
8247 {
8248 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
8249 }
8250 ANGLE_CAPTURE(BlendFuncSeparateiOES, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
8251 dstAlpha);
8252 }
8253 }
8254
BlendFunciContextANGLE(GLeglContext ctx,GLuint buf,GLenum src,GLenum dst)8255 void GL_APIENTRY BlendFunciContextANGLE(GLeglContext ctx, GLuint buf, GLenum src, GLenum dst)
8256 {
8257 Context *context = static_cast<gl::Context *>(ctx);
8258 EVENT("glBlendFunci", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
8259 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
8260 GLenumToString(GLenumGroup::BlendingFactor, dst));
8261
8262 if (context)
8263 {
8264 ASSERT(context == GetValidGlobalContext());
8265 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8266 bool isCallValid =
8267 (context->skipValidation() || ValidateBlendFunci(context, buf, src, dst));
8268 if (isCallValid)
8269 {
8270 context->blendFunci(buf, src, dst);
8271 }
8272 ANGLE_CAPTURE(BlendFunci, isCallValid, context, buf, src, dst);
8273 }
8274 }
8275
BlendFunciEXTContextANGLE(GLeglContext ctx,GLuint buf,GLenum src,GLenum dst)8276 void GL_APIENTRY BlendFunciEXTContextANGLE(GLeglContext ctx, GLuint buf, GLenum src, GLenum dst)
8277 {
8278 Context *context = static_cast<gl::Context *>(ctx);
8279 EVENT("glBlendFunciEXT", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
8280 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
8281 GLenumToString(GLenumGroup::BlendingFactor, dst));
8282
8283 if (context)
8284 {
8285 ASSERT(context == GetValidGlobalContext());
8286 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8287 bool isCallValid =
8288 (context->skipValidation() || ValidateBlendFunciEXT(context, buf, src, dst));
8289 if (isCallValid)
8290 {
8291 context->blendFunci(buf, src, dst);
8292 }
8293 ANGLE_CAPTURE(BlendFunciEXT, isCallValid, context, buf, src, dst);
8294 }
8295 }
8296
BlendFunciOESContextANGLE(GLeglContext ctx,GLuint buf,GLenum src,GLenum dst)8297 void GL_APIENTRY BlendFunciOESContextANGLE(GLeglContext ctx, GLuint buf, GLenum src, GLenum dst)
8298 {
8299 Context *context = static_cast<gl::Context *>(ctx);
8300 EVENT("glBlendFunciOES", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
8301 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
8302 GLenumToString(GLenumGroup::BlendingFactor, dst));
8303
8304 if (context)
8305 {
8306 ASSERT(context == GetValidGlobalContext());
8307 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8308 bool isCallValid =
8309 (context->skipValidation() || ValidateBlendFunciOES(context, buf, src, dst));
8310 if (isCallValid)
8311 {
8312 context->blendFunci(buf, src, dst);
8313 }
8314 ANGLE_CAPTURE(BlendFunciOES, isCallValid, context, buf, src, dst);
8315 }
8316 }
8317
BlitFramebufferContextANGLE(GLeglContext ctx,GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)8318 void GL_APIENTRY BlitFramebufferContextANGLE(GLeglContext ctx,
8319 GLint srcX0,
8320 GLint srcY0,
8321 GLint srcX1,
8322 GLint srcY1,
8323 GLint dstX0,
8324 GLint dstY0,
8325 GLint dstX1,
8326 GLint dstY1,
8327 GLbitfield mask,
8328 GLenum filter)
8329 {
8330 Context *context = static_cast<gl::Context *>(ctx);
8331 EVENT("glBlitFramebuffer",
8332 "context = %d, GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
8333 "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask "
8334 "= %s, GLenum filter = %s",
8335 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
8336 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
8337 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
8338
8339 if (context)
8340 {
8341 ASSERT(context == GetValidGlobalContext());
8342 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8343 bool isCallValid = (context->skipValidation() ||
8344 ValidateBlitFramebuffer(context, srcX0, srcY0, srcX1, srcY1, dstX0,
8345 dstY0, dstX1, dstY1, mask, filter));
8346 if (isCallValid)
8347 {
8348 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
8349 filter);
8350 }
8351 ANGLE_CAPTURE(BlitFramebuffer, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
8352 dstY0, dstX1, dstY1, mask, filter);
8353 }
8354 }
8355
BlitFramebufferANGLEContextANGLE(GLeglContext ctx,GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)8356 void GL_APIENTRY BlitFramebufferANGLEContextANGLE(GLeglContext ctx,
8357 GLint srcX0,
8358 GLint srcY0,
8359 GLint srcX1,
8360 GLint srcY1,
8361 GLint dstX0,
8362 GLint dstY0,
8363 GLint dstX1,
8364 GLint dstY1,
8365 GLbitfield mask,
8366 GLenum filter)
8367 {
8368 Context *context = static_cast<gl::Context *>(ctx);
8369 EVENT("glBlitFramebufferANGLE",
8370 "context = %d, GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
8371 "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask "
8372 "= %s, GLenum filter = %s",
8373 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
8374 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
8375 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
8376
8377 if (context)
8378 {
8379 ASSERT(context == GetValidGlobalContext());
8380 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8381 bool isCallValid = (context->skipValidation() ||
8382 ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0,
8383 dstY0, dstX1, dstY1, mask, filter));
8384 if (isCallValid)
8385 {
8386 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
8387 filter);
8388 }
8389 ANGLE_CAPTURE(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
8390 dstY0, dstX1, dstY1, mask, filter);
8391 }
8392 }
8393
BufferDataContextANGLE(GLeglContext ctx,GLenum target,GLsizeiptr size,const void * data,GLenum usage)8394 void GL_APIENTRY BufferDataContextANGLE(GLeglContext ctx,
8395 GLenum target,
8396 GLsizeiptr size,
8397 const void *data,
8398 GLenum usage)
8399 {
8400 Context *context = static_cast<gl::Context *>(ctx);
8401 EVENT("glBufferData",
8402 "context = %d, GLenum target = %s, GLsizeiptr size = %llu, const void *data = "
8403 "0x%016" PRIxPTR ", GLenum usage = %s",
8404 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
8405 static_cast<unsigned long long>(size), (uintptr_t)data,
8406 GLenumToString(GLenumGroup::BufferUsageARB, usage));
8407
8408 if (context)
8409 {
8410 ASSERT(context == GetValidGlobalContext());
8411 BufferBinding targetPacked = FromGL<BufferBinding>(target);
8412 BufferUsage usagePacked = FromGL<BufferUsage>(usage);
8413 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8414 bool isCallValid = (context->skipValidation() ||
8415 ValidateBufferData(context, targetPacked, size, data, usagePacked));
8416 if (isCallValid)
8417 {
8418 context->bufferData(targetPacked, size, data, usagePacked);
8419 }
8420 ANGLE_CAPTURE(BufferData, isCallValid, context, targetPacked, size, data, usagePacked);
8421 }
8422 }
8423
BufferStorageMemEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizeiptr size,GLuint memory,GLuint64 offset)8424 void GL_APIENTRY BufferStorageMemEXTContextANGLE(GLeglContext ctx,
8425 GLenum target,
8426 GLsizeiptr size,
8427 GLuint memory,
8428 GLuint64 offset)
8429 {
8430 Context *context = static_cast<gl::Context *>(ctx);
8431 EVENT("glBufferStorageMemEXT",
8432 "context = %d, GLenum target = %s, GLsizeiptr size = %llu, GLuint memory = %u, GLuint64 "
8433 "offset = %llu",
8434 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
8435 static_cast<unsigned long long>(size), memory, static_cast<unsigned long long>(offset));
8436
8437 if (context)
8438 {
8439 ASSERT(context == GetValidGlobalContext());
8440 TextureType targetPacked = FromGL<TextureType>(target);
8441 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
8442 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8443 bool isCallValid =
8444 (context->skipValidation() ||
8445 ValidateBufferStorageMemEXT(context, targetPacked, size, memoryPacked, offset));
8446 if (isCallValid)
8447 {
8448 context->bufferStorageMem(targetPacked, size, memoryPacked, offset);
8449 }
8450 ANGLE_CAPTURE(BufferStorageMemEXT, isCallValid, context, targetPacked, size, memoryPacked,
8451 offset);
8452 }
8453 }
8454
BufferSubDataContextANGLE(GLeglContext ctx,GLenum target,GLintptr offset,GLsizeiptr size,const void * data)8455 void GL_APIENTRY BufferSubDataContextANGLE(GLeglContext ctx,
8456 GLenum target,
8457 GLintptr offset,
8458 GLsizeiptr size,
8459 const void *data)
8460 {
8461 Context *context = static_cast<gl::Context *>(ctx);
8462 EVENT("glBufferSubData",
8463 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr size = %llu, const "
8464 "void *data = 0x%016" PRIxPTR "",
8465 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
8466 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
8467 (uintptr_t)data);
8468
8469 if (context)
8470 {
8471 ASSERT(context == GetValidGlobalContext());
8472 BufferBinding targetPacked = FromGL<BufferBinding>(target);
8473 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8474 bool isCallValid = (context->skipValidation() ||
8475 ValidateBufferSubData(context, targetPacked, offset, size, data));
8476 if (isCallValid)
8477 {
8478 context->bufferSubData(targetPacked, offset, size, data);
8479 }
8480 ANGLE_CAPTURE(BufferSubData, isCallValid, context, targetPacked, offset, size, data);
8481 }
8482 }
8483
CheckFramebufferStatusContextANGLE(GLeglContext ctx,GLenum target)8484 GLenum GL_APIENTRY CheckFramebufferStatusContextANGLE(GLeglContext ctx, GLenum target)
8485 {
8486 Context *context = static_cast<gl::Context *>(ctx);
8487 EVENT("glCheckFramebufferStatus", "context = %d, GLenum target = %s", CID(context),
8488 GLenumToString(GLenumGroup::FramebufferTarget, target));
8489
8490 GLenum returnValue;
8491 if (context)
8492 {
8493 ASSERT(context == GetValidGlobalContext());
8494 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8495 bool isCallValid =
8496 (context->skipValidation() || ValidateCheckFramebufferStatus(context, target));
8497 if (isCallValid)
8498 {
8499 returnValue = context->checkFramebufferStatus(target);
8500 }
8501 else
8502 {
8503 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatus, GLenum>();
8504 }
8505 ANGLE_CAPTURE(CheckFramebufferStatus, isCallValid, context, target, returnValue);
8506 }
8507 else
8508 {
8509 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatus, GLenum>();
8510 }
8511 return returnValue;
8512 }
8513
CheckFramebufferStatusOESContextANGLE(GLeglContext ctx,GLenum target)8514 GLenum GL_APIENTRY CheckFramebufferStatusOESContextANGLE(GLeglContext ctx, GLenum target)
8515 {
8516 Context *context = static_cast<gl::Context *>(ctx);
8517 EVENT("glCheckFramebufferStatusOES", "context = %d, GLenum target = %s", CID(context),
8518 GLenumToString(GLenumGroup::FramebufferTarget, target));
8519
8520 GLenum returnValue;
8521 if (context)
8522 {
8523 ASSERT(context == GetValidGlobalContext());
8524 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8525 bool isCallValid =
8526 (context->skipValidation() || ValidateCheckFramebufferStatusOES(context, target));
8527 if (isCallValid)
8528 {
8529 returnValue = context->checkFramebufferStatus(target);
8530 }
8531 else
8532 {
8533 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatusOES, GLenum>();
8534 }
8535 ANGLE_CAPTURE(CheckFramebufferStatusOES, isCallValid, context, target, returnValue);
8536 }
8537 else
8538 {
8539 returnValue = GetDefaultReturnValue<EntryPoint::CheckFramebufferStatusOES, GLenum>();
8540 }
8541 return returnValue;
8542 }
8543
ClearContextANGLE(GLeglContext ctx,GLbitfield mask)8544 void GL_APIENTRY ClearContextANGLE(GLeglContext ctx, GLbitfield mask)
8545 {
8546 Context *context = static_cast<gl::Context *>(ctx);
8547 EVENT("glClear", "context = %d, GLbitfield mask = %s", CID(context),
8548 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str());
8549
8550 if (context)
8551 {
8552 ASSERT(context == GetValidGlobalContext());
8553 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8554 bool isCallValid = (context->skipValidation() || ValidateClear(context, mask));
8555 if (isCallValid)
8556 {
8557 context->clear(mask);
8558 }
8559 ANGLE_CAPTURE(Clear, isCallValid, context, mask);
8560 }
8561 }
8562
ClearBufferfiContextANGLE(GLeglContext ctx,GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil)8563 void GL_APIENTRY ClearBufferfiContextANGLE(GLeglContext ctx,
8564 GLenum buffer,
8565 GLint drawbuffer,
8566 GLfloat depth,
8567 GLint stencil)
8568 {
8569 Context *context = static_cast<gl::Context *>(ctx);
8570 EVENT("glClearBufferfi",
8571 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, GLfloat depth = %f, GLint "
8572 "stencil = %d",
8573 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, depth, stencil);
8574
8575 if (context)
8576 {
8577 ASSERT(context == GetValidGlobalContext());
8578 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8579 bool isCallValid = (context->skipValidation() ||
8580 ValidateClearBufferfi(context, buffer, drawbuffer, depth, stencil));
8581 if (isCallValid)
8582 {
8583 context->clearBufferfi(buffer, drawbuffer, depth, stencil);
8584 }
8585 ANGLE_CAPTURE(ClearBufferfi, isCallValid, context, buffer, drawbuffer, depth, stencil);
8586 }
8587 }
8588
ClearBufferfvContextANGLE(GLeglContext ctx,GLenum buffer,GLint drawbuffer,const GLfloat * value)8589 void GL_APIENTRY ClearBufferfvContextANGLE(GLeglContext ctx,
8590 GLenum buffer,
8591 GLint drawbuffer,
8592 const GLfloat *value)
8593 {
8594 Context *context = static_cast<gl::Context *>(ctx);
8595 EVENT("glClearBufferfv",
8596 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, const GLfloat *value = "
8597 "0x%016" PRIxPTR "",
8598 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
8599
8600 if (context)
8601 {
8602 ASSERT(context == GetValidGlobalContext());
8603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8604 bool isCallValid = (context->skipValidation() ||
8605 ValidateClearBufferfv(context, buffer, drawbuffer, value));
8606 if (isCallValid)
8607 {
8608 context->clearBufferfv(buffer, drawbuffer, value);
8609 }
8610 ANGLE_CAPTURE(ClearBufferfv, isCallValid, context, buffer, drawbuffer, value);
8611 }
8612 }
8613
ClearBufferivContextANGLE(GLeglContext ctx,GLenum buffer,GLint drawbuffer,const GLint * value)8614 void GL_APIENTRY ClearBufferivContextANGLE(GLeglContext ctx,
8615 GLenum buffer,
8616 GLint drawbuffer,
8617 const GLint *value)
8618 {
8619 Context *context = static_cast<gl::Context *>(ctx);
8620 EVENT("glClearBufferiv",
8621 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, const GLint *value = "
8622 "0x%016" PRIxPTR "",
8623 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
8624
8625 if (context)
8626 {
8627 ASSERT(context == GetValidGlobalContext());
8628 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8629 bool isCallValid = (context->skipValidation() ||
8630 ValidateClearBufferiv(context, buffer, drawbuffer, value));
8631 if (isCallValid)
8632 {
8633 context->clearBufferiv(buffer, drawbuffer, value);
8634 }
8635 ANGLE_CAPTURE(ClearBufferiv, isCallValid, context, buffer, drawbuffer, value);
8636 }
8637 }
8638
ClearBufferuivContextANGLE(GLeglContext ctx,GLenum buffer,GLint drawbuffer,const GLuint * value)8639 void GL_APIENTRY ClearBufferuivContextANGLE(GLeglContext ctx,
8640 GLenum buffer,
8641 GLint drawbuffer,
8642 const GLuint *value)
8643 {
8644 Context *context = static_cast<gl::Context *>(ctx);
8645 EVENT("glClearBufferuiv",
8646 "context = %d, GLenum buffer = %s, GLint drawbuffer = %d, const GLuint *value = "
8647 "0x%016" PRIxPTR "",
8648 CID(context), GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value);
8649
8650 if (context)
8651 {
8652 ASSERT(context == GetValidGlobalContext());
8653 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8654 bool isCallValid = (context->skipValidation() ||
8655 ValidateClearBufferuiv(context, buffer, drawbuffer, value));
8656 if (isCallValid)
8657 {
8658 context->clearBufferuiv(buffer, drawbuffer, value);
8659 }
8660 ANGLE_CAPTURE(ClearBufferuiv, isCallValid, context, buffer, drawbuffer, value);
8661 }
8662 }
8663
8664 void GL_APIENTRY
ClearColorContextANGLE(GLeglContext ctx,GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)8665 ClearColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
8666 {
8667 Context *context = static_cast<gl::Context *>(ctx);
8668 EVENT(
8669 "glClearColor",
8670 "context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
8671 CID(context), red, green, blue, alpha);
8672
8673 if (context)
8674 {
8675 ASSERT(context == GetValidGlobalContext());
8676 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8677 bool isCallValid =
8678 (context->skipValidation() || ValidateClearColor(context, red, green, blue, alpha));
8679 if (isCallValid)
8680 {
8681 context->clearColor(red, green, blue, alpha);
8682 }
8683 ANGLE_CAPTURE(ClearColor, isCallValid, context, red, green, blue, alpha);
8684 }
8685 }
8686
8687 void GL_APIENTRY
ClearColorxContextANGLE(GLeglContext ctx,GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)8688 ClearColorxContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
8689 {
8690 Context *context = static_cast<gl::Context *>(ctx);
8691 EVENT("glClearColorx",
8692 "context = %d, GLfixed red = 0x%X, GLfixed green = 0x%X, GLfixed blue = 0x%X, GLfixed "
8693 "alpha = 0x%X",
8694 CID(context), red, green, blue, alpha);
8695
8696 if (context)
8697 {
8698 ASSERT(context == GetValidGlobalContext());
8699 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8700 bool isCallValid =
8701 (context->skipValidation() || ValidateClearColorx(context, red, green, blue, alpha));
8702 if (isCallValid)
8703 {
8704 context->clearColorx(red, green, blue, alpha);
8705 }
8706 ANGLE_CAPTURE(ClearColorx, isCallValid, context, red, green, blue, alpha);
8707 }
8708 }
8709
ClearDepthfContextANGLE(GLeglContext ctx,GLfloat d)8710 void GL_APIENTRY ClearDepthfContextANGLE(GLeglContext ctx, GLfloat d)
8711 {
8712 Context *context = static_cast<gl::Context *>(ctx);
8713 EVENT("glClearDepthf", "context = %d, GLfloat d = %f", CID(context), d);
8714
8715 if (context)
8716 {
8717 ASSERT(context == GetValidGlobalContext());
8718 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8719 bool isCallValid = (context->skipValidation() || ValidateClearDepthf(context, d));
8720 if (isCallValid)
8721 {
8722 context->clearDepthf(d);
8723 }
8724 ANGLE_CAPTURE(ClearDepthf, isCallValid, context, d);
8725 }
8726 }
8727
ClearDepthxContextANGLE(GLeglContext ctx,GLfixed depth)8728 void GL_APIENTRY ClearDepthxContextANGLE(GLeglContext ctx, GLfixed depth)
8729 {
8730 Context *context = static_cast<gl::Context *>(ctx);
8731 EVENT("glClearDepthx", "context = %d, GLfixed depth = 0x%X", CID(context), depth);
8732
8733 if (context)
8734 {
8735 ASSERT(context == GetValidGlobalContext());
8736 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8737 bool isCallValid = (context->skipValidation() || ValidateClearDepthx(context, depth));
8738 if (isCallValid)
8739 {
8740 context->clearDepthx(depth);
8741 }
8742 ANGLE_CAPTURE(ClearDepthx, isCallValid, context, depth);
8743 }
8744 }
8745
ClearStencilContextANGLE(GLeglContext ctx,GLint s)8746 void GL_APIENTRY ClearStencilContextANGLE(GLeglContext ctx, GLint s)
8747 {
8748 Context *context = static_cast<gl::Context *>(ctx);
8749 EVENT("glClearStencil", "context = %d, GLint s = %d", CID(context), s);
8750
8751 if (context)
8752 {
8753 ASSERT(context == GetValidGlobalContext());
8754 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8755 bool isCallValid = (context->skipValidation() || ValidateClearStencil(context, s));
8756 if (isCallValid)
8757 {
8758 context->clearStencil(s);
8759 }
8760 ANGLE_CAPTURE(ClearStencil, isCallValid, context, s);
8761 }
8762 }
8763
ClientActiveTextureContextANGLE(GLeglContext ctx,GLenum texture)8764 void GL_APIENTRY ClientActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
8765 {
8766 Context *context = static_cast<gl::Context *>(ctx);
8767 EVENT("glClientActiveTexture", "context = %d, GLenum texture = %s", CID(context),
8768 GLenumToString(GLenumGroup::TextureUnit, texture));
8769
8770 if (context)
8771 {
8772 ASSERT(context == GetValidGlobalContext());
8773 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8774 bool isCallValid =
8775 (context->skipValidation() || ValidateClientActiveTexture(context, texture));
8776 if (isCallValid)
8777 {
8778 context->clientActiveTexture(texture);
8779 }
8780 ANGLE_CAPTURE(ClientActiveTexture, isCallValid, context, texture);
8781 }
8782 }
8783
ClientWaitSyncContextANGLE(GLeglContext ctx,GLsync sync,GLbitfield flags,GLuint64 timeout)8784 GLenum GL_APIENTRY ClientWaitSyncContextANGLE(GLeglContext ctx,
8785 GLsync sync,
8786 GLbitfield flags,
8787 GLuint64 timeout)
8788 {
8789 Context *context = static_cast<gl::Context *>(ctx);
8790 EVENT("glClientWaitSync",
8791 "context = %d, GLsync sync = 0x%016" PRIxPTR
8792 ", GLbitfield flags = %s, GLuint64 timeout = %llu",
8793 CID(context), (uintptr_t)sync,
8794 GLbitfieldToString(GLenumGroup::SyncObjectMask, flags).c_str(),
8795 static_cast<unsigned long long>(timeout));
8796
8797 GLenum returnValue;
8798 if (context)
8799 {
8800 ASSERT(context == GetValidGlobalContext());
8801 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8802 bool isCallValid =
8803 (context->skipValidation() || ValidateClientWaitSync(context, sync, flags, timeout));
8804 if (isCallValid)
8805 {
8806 returnValue = context->clientWaitSync(sync, flags, timeout);
8807 }
8808 else
8809 {
8810 returnValue = GetDefaultReturnValue<EntryPoint::ClientWaitSync, GLenum>();
8811 }
8812 ANGLE_CAPTURE(ClientWaitSync, isCallValid, context, sync, flags, timeout, returnValue);
8813 }
8814 else
8815 {
8816 returnValue = GetDefaultReturnValue<EntryPoint::ClientWaitSync, GLenum>();
8817 }
8818 return returnValue;
8819 }
8820
ClipPlanefContextANGLE(GLeglContext ctx,GLenum p,const GLfloat * eqn)8821 void GL_APIENTRY ClipPlanefContextANGLE(GLeglContext ctx, GLenum p, const GLfloat *eqn)
8822 {
8823 Context *context = static_cast<gl::Context *>(ctx);
8824 EVENT("glClipPlanef", "context = %d, GLenum p = %s, const GLfloat *eqn = 0x%016" PRIxPTR "",
8825 CID(context), GLenumToString(GLenumGroup::ClipPlaneName, p), (uintptr_t)eqn);
8826
8827 if (context)
8828 {
8829 ASSERT(context == GetValidGlobalContext());
8830 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8831 bool isCallValid = (context->skipValidation() || ValidateClipPlanef(context, p, eqn));
8832 if (isCallValid)
8833 {
8834 context->clipPlanef(p, eqn);
8835 }
8836 ANGLE_CAPTURE(ClipPlanef, isCallValid, context, p, eqn);
8837 }
8838 }
8839
ClipPlanexContextANGLE(GLeglContext ctx,GLenum plane,const GLfixed * equation)8840 void GL_APIENTRY ClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, const GLfixed *equation)
8841 {
8842 Context *context = static_cast<gl::Context *>(ctx);
8843 EVENT("glClipPlanex",
8844 "context = %d, GLenum plane = %s, const GLfixed *equation = 0x%016" PRIxPTR "",
8845 CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
8846
8847 if (context)
8848 {
8849 ASSERT(context == GetValidGlobalContext());
8850 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8851 bool isCallValid =
8852 (context->skipValidation() || ValidateClipPlanex(context, plane, equation));
8853 if (isCallValid)
8854 {
8855 context->clipPlanex(plane, equation);
8856 }
8857 ANGLE_CAPTURE(ClipPlanex, isCallValid, context, plane, equation);
8858 }
8859 }
8860
8861 void GL_APIENTRY
Color4fContextANGLE(GLeglContext ctx,GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)8862 Color4fContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
8863 {
8864 Context *context = static_cast<gl::Context *>(ctx);
8865 EVENT(
8866 "glColor4f",
8867 "context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
8868 CID(context), red, green, blue, alpha);
8869
8870 if (context)
8871 {
8872 ASSERT(context == GetValidGlobalContext());
8873 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8874 bool isCallValid =
8875 (context->skipValidation() || ValidateColor4f(context, red, green, blue, alpha));
8876 if (isCallValid)
8877 {
8878 context->color4f(red, green, blue, alpha);
8879 }
8880 ANGLE_CAPTURE(Color4f, isCallValid, context, red, green, blue, alpha);
8881 }
8882 }
8883
8884 void GL_APIENTRY
Color4ubContextANGLE(GLeglContext ctx,GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)8885 Color4ubContextANGLE(GLeglContext ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
8886 {
8887 Context *context = static_cast<gl::Context *>(ctx);
8888 EVENT(
8889 "glColor4ub",
8890 "context = %d, GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d, GLubyte alpha = %d",
8891 CID(context), red, green, blue, alpha);
8892
8893 if (context)
8894 {
8895 ASSERT(context == GetValidGlobalContext());
8896 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8897 bool isCallValid =
8898 (context->skipValidation() || ValidateColor4ub(context, red, green, blue, alpha));
8899 if (isCallValid)
8900 {
8901 context->color4ub(red, green, blue, alpha);
8902 }
8903 ANGLE_CAPTURE(Color4ub, isCallValid, context, red, green, blue, alpha);
8904 }
8905 }
8906
8907 void GL_APIENTRY
Color4xContextANGLE(GLeglContext ctx,GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)8908 Color4xContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
8909 {
8910 Context *context = static_cast<gl::Context *>(ctx);
8911 EVENT("glColor4x",
8912 "context = %d, GLfixed red = 0x%X, GLfixed green = 0x%X, GLfixed blue = 0x%X, GLfixed "
8913 "alpha = 0x%X",
8914 CID(context), red, green, blue, alpha);
8915
8916 if (context)
8917 {
8918 ASSERT(context == GetValidGlobalContext());
8919 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8920 bool isCallValid =
8921 (context->skipValidation() || ValidateColor4x(context, red, green, blue, alpha));
8922 if (isCallValid)
8923 {
8924 context->color4x(red, green, blue, alpha);
8925 }
8926 ANGLE_CAPTURE(Color4x, isCallValid, context, red, green, blue, alpha);
8927 }
8928 }
8929
ColorMaskContextANGLE(GLeglContext ctx,GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)8930 void GL_APIENTRY ColorMaskContextANGLE(GLeglContext ctx,
8931 GLboolean red,
8932 GLboolean green,
8933 GLboolean blue,
8934 GLboolean alpha)
8935 {
8936 Context *context = static_cast<gl::Context *>(ctx);
8937 EVENT("glColorMask",
8938 "context = %d, GLboolean red = %s, GLboolean green = %s, GLboolean blue = %s, GLboolean "
8939 "alpha = %s",
8940 CID(context), GLbooleanToString(red), GLbooleanToString(green), GLbooleanToString(blue),
8941 GLbooleanToString(alpha));
8942
8943 if (context)
8944 {
8945 ASSERT(context == GetValidGlobalContext());
8946 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8947 bool isCallValid =
8948 (context->skipValidation() || ValidateColorMask(context, red, green, blue, alpha));
8949 if (isCallValid)
8950 {
8951 context->colorMask(red, green, blue, alpha);
8952 }
8953 ANGLE_CAPTURE(ColorMask, isCallValid, context, red, green, blue, alpha);
8954 }
8955 }
8956
ColorMaskiContextANGLE(GLeglContext ctx,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)8957 void GL_APIENTRY ColorMaskiContextANGLE(GLeglContext ctx,
8958 GLuint index,
8959 GLboolean r,
8960 GLboolean g,
8961 GLboolean b,
8962 GLboolean a)
8963 {
8964 Context *context = static_cast<gl::Context *>(ctx);
8965 EVENT("glColorMaski",
8966 "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
8967 "GLboolean a = %s",
8968 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
8969 GLbooleanToString(a));
8970
8971 if (context)
8972 {
8973 ASSERT(context == GetValidGlobalContext());
8974 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
8975 bool isCallValid =
8976 (context->skipValidation() || ValidateColorMaski(context, index, r, g, b, a));
8977 if (isCallValid)
8978 {
8979 context->colorMaski(index, r, g, b, a);
8980 }
8981 ANGLE_CAPTURE(ColorMaski, isCallValid, context, index, r, g, b, a);
8982 }
8983 }
8984
ColorMaskiEXTContextANGLE(GLeglContext ctx,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)8985 void GL_APIENTRY ColorMaskiEXTContextANGLE(GLeglContext ctx,
8986 GLuint index,
8987 GLboolean r,
8988 GLboolean g,
8989 GLboolean b,
8990 GLboolean a)
8991 {
8992 Context *context = static_cast<gl::Context *>(ctx);
8993 EVENT("glColorMaskiEXT",
8994 "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
8995 "GLboolean a = %s",
8996 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
8997 GLbooleanToString(a));
8998
8999 if (context)
9000 {
9001 ASSERT(context == GetValidGlobalContext());
9002 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9003 bool isCallValid =
9004 (context->skipValidation() || ValidateColorMaskiEXT(context, index, r, g, b, a));
9005 if (isCallValid)
9006 {
9007 context->colorMaski(index, r, g, b, a);
9008 }
9009 ANGLE_CAPTURE(ColorMaskiEXT, isCallValid, context, index, r, g, b, a);
9010 }
9011 }
9012
ColorMaskiOESContextANGLE(GLeglContext ctx,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)9013 void GL_APIENTRY ColorMaskiOESContextANGLE(GLeglContext ctx,
9014 GLuint index,
9015 GLboolean r,
9016 GLboolean g,
9017 GLboolean b,
9018 GLboolean a)
9019 {
9020 Context *context = static_cast<gl::Context *>(ctx);
9021 EVENT("glColorMaskiOES",
9022 "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
9023 "GLboolean a = %s",
9024 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
9025 GLbooleanToString(a));
9026
9027 if (context)
9028 {
9029 ASSERT(context == GetValidGlobalContext());
9030 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9031 bool isCallValid =
9032 (context->skipValidation() || ValidateColorMaskiOES(context, index, r, g, b, a));
9033 if (isCallValid)
9034 {
9035 context->colorMaski(index, r, g, b, a);
9036 }
9037 ANGLE_CAPTURE(ColorMaskiOES, isCallValid, context, index, r, g, b, a);
9038 }
9039 }
9040
ColorPointerContextANGLE(GLeglContext ctx,GLint size,GLenum type,GLsizei stride,const void * pointer)9041 void GL_APIENTRY ColorPointerContextANGLE(GLeglContext ctx,
9042 GLint size,
9043 GLenum type,
9044 GLsizei stride,
9045 const void *pointer)
9046 {
9047 Context *context = static_cast<gl::Context *>(ctx);
9048 EVENT("glColorPointer",
9049 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
9050 "*pointer = 0x%016" PRIxPTR "",
9051 CID(context), size, GLenumToString(GLenumGroup::ColorPointerType, type), stride,
9052 (uintptr_t)pointer);
9053
9054 if (context)
9055 {
9056 ASSERT(context == GetValidGlobalContext());
9057 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
9058 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9059 bool isCallValid = (context->skipValidation() ||
9060 ValidateColorPointer(context, size, typePacked, stride, pointer));
9061 if (isCallValid)
9062 {
9063 context->colorPointer(size, typePacked, stride, pointer);
9064 }
9065 ANGLE_CAPTURE(ColorPointer, isCallValid, context, size, typePacked, stride, pointer);
9066 }
9067 }
9068
CompileShaderContextANGLE(GLeglContext ctx,GLuint shader)9069 void GL_APIENTRY CompileShaderContextANGLE(GLeglContext ctx, GLuint shader)
9070 {
9071 Context *context = static_cast<gl::Context *>(ctx);
9072 EVENT("glCompileShader", "context = %d, GLuint shader = %u", CID(context), shader);
9073
9074 if (context)
9075 {
9076 ASSERT(context == GetValidGlobalContext());
9077 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
9078 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9079 bool isCallValid =
9080 (context->skipValidation() || ValidateCompileShader(context, shaderPacked));
9081 if (isCallValid)
9082 {
9083 context->compileShader(shaderPacked);
9084 }
9085 ANGLE_CAPTURE(CompileShader, isCallValid, context, shaderPacked);
9086 }
9087 }
9088
CompressedTexImage2DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void * data)9089 void GL_APIENTRY CompressedTexImage2DContextANGLE(GLeglContext ctx,
9090 GLenum target,
9091 GLint level,
9092 GLenum internalformat,
9093 GLsizei width,
9094 GLsizei height,
9095 GLint border,
9096 GLsizei imageSize,
9097 const void *data)
9098 {
9099 Context *context = static_cast<gl::Context *>(ctx);
9100 EVENT("glCompressedTexImage2D",
9101 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
9102 "width = %d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const void "
9103 "*data = 0x%016" PRIxPTR "",
9104 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
9105 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, border,
9106 imageSize, (uintptr_t)data);
9107
9108 if (context)
9109 {
9110 ASSERT(context == GetValidGlobalContext());
9111 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9112 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9113 bool isCallValid =
9114 (context->skipValidation() ||
9115 ValidateCompressedTexImage2D(context, targetPacked, level, internalformat, width,
9116 height, border, imageSize, data));
9117 if (isCallValid)
9118 {
9119 context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
9120 border, imageSize, data);
9121 }
9122 ANGLE_CAPTURE(CompressedTexImage2D, isCallValid, context, targetPacked, level,
9123 internalformat, width, height, border, imageSize, data);
9124 }
9125 }
9126
CompressedTexImage3DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)9127 void GL_APIENTRY CompressedTexImage3DContextANGLE(GLeglContext ctx,
9128 GLenum target,
9129 GLint level,
9130 GLenum internalformat,
9131 GLsizei width,
9132 GLsizei height,
9133 GLsizei depth,
9134 GLint border,
9135 GLsizei imageSize,
9136 const void *data)
9137 {
9138 Context *context = static_cast<gl::Context *>(ctx);
9139 EVENT("glCompressedTexImage3D",
9140 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
9141 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei "
9142 "imageSize = %d, const void *data = 0x%016" PRIxPTR "",
9143 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
9144 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
9145 imageSize, (uintptr_t)data);
9146
9147 if (context)
9148 {
9149 ASSERT(context == GetValidGlobalContext());
9150 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9151 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9152 bool isCallValid =
9153 (context->skipValidation() ||
9154 ValidateCompressedTexImage3D(context, targetPacked, level, internalformat, width,
9155 height, depth, border, imageSize, data));
9156 if (isCallValid)
9157 {
9158 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
9159 border, imageSize, data);
9160 }
9161 ANGLE_CAPTURE(CompressedTexImage3D, isCallValid, context, targetPacked, level,
9162 internalformat, width, height, depth, border, imageSize, data);
9163 }
9164 }
9165
CompressedTexImage3DOESContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)9166 void GL_APIENTRY CompressedTexImage3DOESContextANGLE(GLeglContext ctx,
9167 GLenum target,
9168 GLint level,
9169 GLenum internalformat,
9170 GLsizei width,
9171 GLsizei height,
9172 GLsizei depth,
9173 GLint border,
9174 GLsizei imageSize,
9175 const void *data)
9176 {
9177 Context *context = static_cast<gl::Context *>(ctx);
9178 EVENT("glCompressedTexImage3DOES",
9179 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
9180 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei "
9181 "imageSize = %d, const void *data = 0x%016" PRIxPTR "",
9182 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
9183 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
9184 imageSize, (uintptr_t)data);
9185
9186 if (context)
9187 {
9188 ASSERT(context == GetValidGlobalContext());
9189 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9190 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9191 bool isCallValid =
9192 (context->skipValidation() ||
9193 ValidateCompressedTexImage3DOES(context, targetPacked, level, internalformat, width,
9194 height, depth, border, imageSize, data));
9195 if (isCallValid)
9196 {
9197 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
9198 border, imageSize, data);
9199 }
9200 ANGLE_CAPTURE(CompressedTexImage3DOES, isCallValid, context, targetPacked, level,
9201 internalformat, width, height, depth, border, imageSize, data);
9202 }
9203 }
9204
CompressedTexSubImage2DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void * data)9205 void GL_APIENTRY CompressedTexSubImage2DContextANGLE(GLeglContext ctx,
9206 GLenum target,
9207 GLint level,
9208 GLint xoffset,
9209 GLint yoffset,
9210 GLsizei width,
9211 GLsizei height,
9212 GLenum format,
9213 GLsizei imageSize,
9214 const void *data)
9215 {
9216 Context *context = static_cast<gl::Context *>(ctx);
9217 EVENT("glCompressedTexSubImage2D",
9218 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
9219 "%d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLsizei imageSize = "
9220 "%d, const void *data = 0x%016" PRIxPTR "",
9221 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9222 width, height, GLenumToString(GLenumGroup::PixelFormat, format), imageSize,
9223 (uintptr_t)data);
9224
9225 if (context)
9226 {
9227 ASSERT(context == GetValidGlobalContext());
9228 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9229 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9230 bool isCallValid =
9231 (context->skipValidation() ||
9232 ValidateCompressedTexSubImage2D(context, targetPacked, level, xoffset, yoffset, width,
9233 height, format, imageSize, data));
9234 if (isCallValid)
9235 {
9236 context->compressedTexSubImage2D(targetPacked, level, xoffset, yoffset, width, height,
9237 format, imageSize, data);
9238 }
9239 ANGLE_CAPTURE(CompressedTexSubImage2D, isCallValid, context, targetPacked, level, xoffset,
9240 yoffset, width, height, format, imageSize, data);
9241 }
9242 }
9243
CompressedTexSubImage3DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)9244 void GL_APIENTRY CompressedTexSubImage3DContextANGLE(GLeglContext ctx,
9245 GLenum target,
9246 GLint level,
9247 GLint xoffset,
9248 GLint yoffset,
9249 GLint zoffset,
9250 GLsizei width,
9251 GLsizei height,
9252 GLsizei depth,
9253 GLenum format,
9254 GLsizei imageSize,
9255 const void *data)
9256 {
9257 Context *context = static_cast<gl::Context *>(ctx);
9258 EVENT("glCompressedTexSubImage3D",
9259 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
9260 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
9261 "GLenum format = %s, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR "",
9262 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9263 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
9264 imageSize, (uintptr_t)data);
9265
9266 if (context)
9267 {
9268 ASSERT(context == GetValidGlobalContext());
9269 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9270 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9271 bool isCallValid = (context->skipValidation() ||
9272 ValidateCompressedTexSubImage3D(context, targetPacked, level, xoffset,
9273 yoffset, zoffset, width, height, depth,
9274 format, imageSize, data));
9275 if (isCallValid)
9276 {
9277 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
9278 height, depth, format, imageSize, data);
9279 }
9280 ANGLE_CAPTURE(CompressedTexSubImage3D, isCallValid, context, targetPacked, level, xoffset,
9281 yoffset, zoffset, width, height, depth, format, imageSize, data);
9282 }
9283 }
9284
CompressedTexSubImage3DOESContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)9285 void GL_APIENTRY CompressedTexSubImage3DOESContextANGLE(GLeglContext ctx,
9286 GLenum target,
9287 GLint level,
9288 GLint xoffset,
9289 GLint yoffset,
9290 GLint zoffset,
9291 GLsizei width,
9292 GLsizei height,
9293 GLsizei depth,
9294 GLenum format,
9295 GLsizei imageSize,
9296 const void *data)
9297 {
9298 Context *context = static_cast<gl::Context *>(ctx);
9299 EVENT("glCompressedTexSubImage3DOES",
9300 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
9301 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
9302 "GLenum format = %s, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR "",
9303 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9304 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
9305 imageSize, (uintptr_t)data);
9306
9307 if (context)
9308 {
9309 ASSERT(context == GetValidGlobalContext());
9310 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9311 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9312 bool isCallValid = (context->skipValidation() ||
9313 ValidateCompressedTexSubImage3DOES(
9314 context, targetPacked, level, xoffset, yoffset, zoffset, width,
9315 height, depth, format, imageSize, data));
9316 if (isCallValid)
9317 {
9318 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
9319 height, depth, format, imageSize, data);
9320 }
9321 ANGLE_CAPTURE(CompressedTexSubImage3DOES, isCallValid, context, targetPacked, level,
9322 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
9323 }
9324 }
9325
CopyBufferSubDataContextANGLE(GLeglContext ctx,GLenum readTarget,GLenum writeTarget,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size)9326 void GL_APIENTRY CopyBufferSubDataContextANGLE(GLeglContext ctx,
9327 GLenum readTarget,
9328 GLenum writeTarget,
9329 GLintptr readOffset,
9330 GLintptr writeOffset,
9331 GLsizeiptr size)
9332 {
9333 Context *context = static_cast<gl::Context *>(ctx);
9334 EVENT("glCopyBufferSubData",
9335 "context = %d, GLenum readTarget = %s, GLenum writeTarget = %s, GLintptr readOffset = "
9336 "%llu, GLintptr writeOffset = %llu, GLsizeiptr size = %llu",
9337 CID(context), GLenumToString(GLenumGroup::CopyBufferSubDataTarget, readTarget),
9338 GLenumToString(GLenumGroup::CopyBufferSubDataTarget, writeTarget),
9339 static_cast<unsigned long long>(readOffset), static_cast<unsigned long long>(writeOffset),
9340 static_cast<unsigned long long>(size));
9341
9342 if (context)
9343 {
9344 ASSERT(context == GetValidGlobalContext());
9345 BufferBinding readTargetPacked = FromGL<BufferBinding>(readTarget);
9346 BufferBinding writeTargetPacked = FromGL<BufferBinding>(writeTarget);
9347 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9348 bool isCallValid = (context->skipValidation() ||
9349 ValidateCopyBufferSubData(context, readTargetPacked, writeTargetPacked,
9350 readOffset, writeOffset, size));
9351 if (isCallValid)
9352 {
9353 context->copyBufferSubData(readTargetPacked, writeTargetPacked, readOffset, writeOffset,
9354 size);
9355 }
9356 ANGLE_CAPTURE(CopyBufferSubData, isCallValid, context, readTargetPacked, writeTargetPacked,
9357 readOffset, writeOffset, size);
9358 }
9359 }
9360
CopyImageSubDataContextANGLE(GLeglContext ctx,GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth)9361 void GL_APIENTRY CopyImageSubDataContextANGLE(GLeglContext ctx,
9362 GLuint srcName,
9363 GLenum srcTarget,
9364 GLint srcLevel,
9365 GLint srcX,
9366 GLint srcY,
9367 GLint srcZ,
9368 GLuint dstName,
9369 GLenum dstTarget,
9370 GLint dstLevel,
9371 GLint dstX,
9372 GLint dstY,
9373 GLint dstZ,
9374 GLsizei srcWidth,
9375 GLsizei srcHeight,
9376 GLsizei srcDepth)
9377 {
9378 Context *context = static_cast<gl::Context *>(ctx);
9379 EVENT("glCopyImageSubData",
9380 "context = %d, GLuint srcName = %u, GLenum srcTarget = %s, GLint srcLevel = %d, GLint "
9381 "srcX = %d, GLint srcY = %d, GLint srcZ = %d, GLuint dstName = %u, GLenum dstTarget = "
9382 "%s, GLint dstLevel = %d, GLint dstX = %d, GLint dstY = %d, GLint dstZ = %d, GLsizei "
9383 "srcWidth = %d, GLsizei srcHeight = %d, GLsizei srcDepth = %d",
9384 CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget),
9385 srcLevel, srcX, srcY, srcZ, dstName,
9386 GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY,
9387 dstZ, srcWidth, srcHeight, srcDepth);
9388
9389 if (context)
9390 {
9391 ASSERT(context == GetValidGlobalContext());
9392 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9393 bool isCallValid = (context->skipValidation() ||
9394 ValidateCopyImageSubData(context, srcName, srcTarget, srcLevel, srcX,
9395 srcY, srcZ, dstName, dstTarget, dstLevel, dstX,
9396 dstY, dstZ, srcWidth, srcHeight, srcDepth));
9397 if (isCallValid)
9398 {
9399 context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
9400 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
9401 srcDepth);
9402 }
9403 ANGLE_CAPTURE(CopyImageSubData, isCallValid, context, srcName, srcTarget, srcLevel, srcX,
9404 srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
9405 srcHeight, srcDepth);
9406 }
9407 }
9408
CopyTexImage2DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)9409 void GL_APIENTRY CopyTexImage2DContextANGLE(GLeglContext ctx,
9410 GLenum target,
9411 GLint level,
9412 GLenum internalformat,
9413 GLint x,
9414 GLint y,
9415 GLsizei width,
9416 GLsizei height,
9417 GLint border)
9418 {
9419 Context *context = static_cast<gl::Context *>(ctx);
9420 EVENT("glCopyTexImage2D",
9421 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLint x "
9422 "= %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d",
9423 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
9424 GLenumToString(GLenumGroup::InternalFormat, internalformat), x, y, width, height, border);
9425
9426 if (context)
9427 {
9428 ASSERT(context == GetValidGlobalContext());
9429 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9430 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9431 bool isCallValid = (context->skipValidation() ||
9432 ValidateCopyTexImage2D(context, targetPacked, level, internalformat, x,
9433 y, width, height, border));
9434 if (isCallValid)
9435 {
9436 context->copyTexImage2D(targetPacked, level, internalformat, x, y, width, height,
9437 border);
9438 }
9439 ANGLE_CAPTURE(CopyTexImage2D, isCallValid, context, targetPacked, level, internalformat, x,
9440 y, width, height, border);
9441 }
9442 }
9443
CopyTexSubImage2DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)9444 void GL_APIENTRY CopyTexSubImage2DContextANGLE(GLeglContext ctx,
9445 GLenum target,
9446 GLint level,
9447 GLint xoffset,
9448 GLint yoffset,
9449 GLint x,
9450 GLint y,
9451 GLsizei width,
9452 GLsizei height)
9453 {
9454 Context *context = static_cast<gl::Context *>(ctx);
9455 EVENT("glCopyTexSubImage2D",
9456 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
9457 "%d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d",
9458 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9459 x, y, width, height);
9460
9461 if (context)
9462 {
9463 ASSERT(context == GetValidGlobalContext());
9464 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9465 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9466 bool isCallValid = (context->skipValidation() ||
9467 ValidateCopyTexSubImage2D(context, targetPacked, level, xoffset,
9468 yoffset, x, y, width, height));
9469 if (isCallValid)
9470 {
9471 context->copyTexSubImage2D(targetPacked, level, xoffset, yoffset, x, y, width, height);
9472 }
9473 ANGLE_CAPTURE(CopyTexSubImage2D, isCallValid, context, targetPacked, level, xoffset,
9474 yoffset, x, y, width, height);
9475 }
9476 }
9477
CopyTexSubImage3DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)9478 void GL_APIENTRY CopyTexSubImage3DContextANGLE(GLeglContext ctx,
9479 GLenum target,
9480 GLint level,
9481 GLint xoffset,
9482 GLint yoffset,
9483 GLint zoffset,
9484 GLint x,
9485 GLint y,
9486 GLsizei width,
9487 GLsizei height)
9488 {
9489 Context *context = static_cast<gl::Context *>(ctx);
9490 EVENT("glCopyTexSubImage3D",
9491 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
9492 "%d, GLint zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height "
9493 "= %d",
9494 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
9495 zoffset, x, y, width, height);
9496
9497 if (context)
9498 {
9499 ASSERT(context == GetValidGlobalContext());
9500 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9501 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9502 bool isCallValid = (context->skipValidation() ||
9503 ValidateCopyTexSubImage3D(context, targetPacked, level, xoffset,
9504 yoffset, zoffset, x, y, width, height));
9505 if (isCallValid)
9506 {
9507 context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
9508 height);
9509 }
9510 ANGLE_CAPTURE(CopyTexSubImage3D, isCallValid, context, targetPacked, level, xoffset,
9511 yoffset, zoffset, x, y, width, height);
9512 }
9513 }
9514
CopyTexSubImage3DOESContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)9515 void GL_APIENTRY CopyTexSubImage3DOESContextANGLE(GLeglContext ctx,
9516 GLenum target,
9517 GLint level,
9518 GLint xoffset,
9519 GLint yoffset,
9520 GLint zoffset,
9521 GLint x,
9522 GLint y,
9523 GLsizei width,
9524 GLsizei height)
9525 {
9526 Context *context = static_cast<gl::Context *>(ctx);
9527 EVENT("glCopyTexSubImage3DOES",
9528 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
9529 "%d, GLint zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height "
9530 "= %d",
9531 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
9532 zoffset, x, y, width, height);
9533
9534 if (context)
9535 {
9536 ASSERT(context == GetValidGlobalContext());
9537 TextureTarget targetPacked = FromGL<TextureTarget>(target);
9538 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9539 bool isCallValid = (context->skipValidation() ||
9540 ValidateCopyTexSubImage3DOES(context, targetPacked, level, xoffset,
9541 yoffset, zoffset, x, y, width, height));
9542 if (isCallValid)
9543 {
9544 context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
9545 height);
9546 }
9547 ANGLE_CAPTURE(CopyTexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset,
9548 yoffset, zoffset, x, y, width, height);
9549 }
9550 }
9551
CreateMemoryObjectsEXTContextANGLE(GLeglContext ctx,GLsizei n,GLuint * memoryObjects)9552 void GL_APIENTRY CreateMemoryObjectsEXTContextANGLE(GLeglContext ctx,
9553 GLsizei n,
9554 GLuint *memoryObjects)
9555 {
9556 Context *context = static_cast<gl::Context *>(ctx);
9557 EVENT("glCreateMemoryObjectsEXT",
9558 "context = %d, GLsizei n = %d, GLuint *memoryObjects = 0x%016" PRIxPTR "", CID(context),
9559 n, (uintptr_t)memoryObjects);
9560
9561 if (context)
9562 {
9563 ASSERT(context == GetValidGlobalContext());
9564 MemoryObjectID *memoryObjectsPacked = FromGL<MemoryObjectID *>(memoryObjects);
9565 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9566 bool isCallValid = (context->skipValidation() ||
9567 ValidateCreateMemoryObjectsEXT(context, n, memoryObjectsPacked));
9568 if (isCallValid)
9569 {
9570 context->createMemoryObjects(n, memoryObjectsPacked);
9571 }
9572 ANGLE_CAPTURE(CreateMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
9573 }
9574 }
9575
CreateProgramContextANGLE(GLeglContext ctx)9576 GLuint GL_APIENTRY CreateProgramContextANGLE(GLeglContext ctx)
9577 {
9578 Context *context = static_cast<gl::Context *>(ctx);
9579 EVENT("glCreateProgram", "context = %d", CID(context));
9580
9581 GLuint returnValue;
9582 if (context)
9583 {
9584 ASSERT(context == GetValidGlobalContext());
9585 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9586 bool isCallValid = (context->skipValidation() || ValidateCreateProgram(context));
9587 if (isCallValid)
9588 {
9589 returnValue = context->createProgram();
9590 }
9591 else
9592 {
9593 returnValue = GetDefaultReturnValue<EntryPoint::CreateProgram, GLuint>();
9594 }
9595 ANGLE_CAPTURE(CreateProgram, isCallValid, context, returnValue);
9596 }
9597 else
9598 {
9599 returnValue = GetDefaultReturnValue<EntryPoint::CreateProgram, GLuint>();
9600 }
9601 return returnValue;
9602 }
9603
CreateShaderContextANGLE(GLeglContext ctx,GLenum type)9604 GLuint GL_APIENTRY CreateShaderContextANGLE(GLeglContext ctx, GLenum type)
9605 {
9606 Context *context = static_cast<gl::Context *>(ctx);
9607 EVENT("glCreateShader", "context = %d, GLenum type = %s", CID(context),
9608 GLenumToString(GLenumGroup::ShaderType, type));
9609
9610 GLuint returnValue;
9611 if (context)
9612 {
9613 ASSERT(context == GetValidGlobalContext());
9614 ShaderType typePacked = FromGL<ShaderType>(type);
9615 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9616 bool isCallValid = (context->skipValidation() || ValidateCreateShader(context, typePacked));
9617 if (isCallValid)
9618 {
9619 returnValue = context->createShader(typePacked);
9620 }
9621 else
9622 {
9623 returnValue = GetDefaultReturnValue<EntryPoint::CreateShader, GLuint>();
9624 }
9625 ANGLE_CAPTURE(CreateShader, isCallValid, context, typePacked, returnValue);
9626 }
9627 else
9628 {
9629 returnValue = GetDefaultReturnValue<EntryPoint::CreateShader, GLuint>();
9630 }
9631 return returnValue;
9632 }
9633
CreateShaderProgramvContextANGLE(GLeglContext ctx,GLenum type,GLsizei count,const GLchar * const * strings)9634 GLuint GL_APIENTRY CreateShaderProgramvContextANGLE(GLeglContext ctx,
9635 GLenum type,
9636 GLsizei count,
9637 const GLchar *const *strings)
9638 {
9639 Context *context = static_cast<gl::Context *>(ctx);
9640 EVENT("glCreateShaderProgramv",
9641 "context = %d, GLenum type = %s, GLsizei count = %d, const GLchar *const*strings = "
9642 "0x%016" PRIxPTR "",
9643 CID(context), GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings);
9644
9645 GLuint returnValue;
9646 if (context)
9647 {
9648 ASSERT(context == GetValidGlobalContext());
9649 ShaderType typePacked = FromGL<ShaderType>(type);
9650 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9651 bool isCallValid = (context->skipValidation() ||
9652 ValidateCreateShaderProgramv(context, typePacked, count, strings));
9653 if (isCallValid)
9654 {
9655 returnValue = context->createShaderProgramv(typePacked, count, strings);
9656 }
9657 else
9658 {
9659 returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
9660 }
9661 ANGLE_CAPTURE(CreateShaderProgramv, isCallValid, context, typePacked, count, strings,
9662 returnValue);
9663 }
9664 else
9665 {
9666 returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
9667 }
9668 return returnValue;
9669 }
9670
CullFaceContextANGLE(GLeglContext ctx,GLenum mode)9671 void GL_APIENTRY CullFaceContextANGLE(GLeglContext ctx, GLenum mode)
9672 {
9673 Context *context = static_cast<gl::Context *>(ctx);
9674 EVENT("glCullFace", "context = %d, GLenum mode = %s", CID(context),
9675 GLenumToString(GLenumGroup::CullFaceMode, mode));
9676
9677 if (context)
9678 {
9679 ASSERT(context == GetValidGlobalContext());
9680 CullFaceMode modePacked = FromGL<CullFaceMode>(mode);
9681 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9682 bool isCallValid = (context->skipValidation() || ValidateCullFace(context, modePacked));
9683 if (isCallValid)
9684 {
9685 context->cullFace(modePacked);
9686 }
9687 ANGLE_CAPTURE(CullFace, isCallValid, context, modePacked);
9688 }
9689 }
9690
CurrentPaletteMatrixOESContextANGLE(GLeglContext ctx,GLuint matrixpaletteindex)9691 void GL_APIENTRY CurrentPaletteMatrixOESContextANGLE(GLeglContext ctx, GLuint matrixpaletteindex)
9692 {
9693 Context *context = static_cast<gl::Context *>(ctx);
9694 EVENT("glCurrentPaletteMatrixOES", "context = %d, GLuint matrixpaletteindex = %u", CID(context),
9695 matrixpaletteindex);
9696
9697 if (context)
9698 {
9699 ASSERT(context == GetValidGlobalContext());
9700 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9701 bool isCallValid = (context->skipValidation() ||
9702 ValidateCurrentPaletteMatrixOES(context, matrixpaletteindex));
9703 if (isCallValid)
9704 {
9705 context->currentPaletteMatrix(matrixpaletteindex);
9706 }
9707 ANGLE_CAPTURE(CurrentPaletteMatrixOES, isCallValid, context, matrixpaletteindex);
9708 }
9709 }
9710
DebugMessageCallbackContextANGLE(GLeglContext ctx,GLDEBUGPROC callback,const void * userParam)9711 void GL_APIENTRY DebugMessageCallbackContextANGLE(GLeglContext ctx,
9712 GLDEBUGPROC callback,
9713 const void *userParam)
9714 {
9715 Context *context = static_cast<gl::Context *>(ctx);
9716 EVENT("glDebugMessageCallback",
9717 "context = %d, GLDEBUGPROC callback = 0x%016" PRIxPTR
9718 ", const void *userParam = 0x%016" PRIxPTR "",
9719 CID(context), (uintptr_t)callback, (uintptr_t)userParam);
9720
9721 if (context)
9722 {
9723 ASSERT(context == GetValidGlobalContext());
9724 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9725 bool isCallValid = (context->skipValidation() ||
9726 ValidateDebugMessageCallback(context, callback, userParam));
9727 if (isCallValid)
9728 {
9729 context->debugMessageCallback(callback, userParam);
9730 }
9731 ANGLE_CAPTURE(DebugMessageCallback, isCallValid, context, callback, userParam);
9732 }
9733 }
9734
DebugMessageCallbackKHRContextANGLE(GLeglContext ctx,GLDEBUGPROCKHR callback,const void * userParam)9735 void GL_APIENTRY DebugMessageCallbackKHRContextANGLE(GLeglContext ctx,
9736 GLDEBUGPROCKHR callback,
9737 const void *userParam)
9738 {
9739 Context *context = static_cast<gl::Context *>(ctx);
9740 EVENT("glDebugMessageCallbackKHR",
9741 "context = %d, GLDEBUGPROCKHR callback = 0x%016" PRIxPTR
9742 ", const void *userParam = 0x%016" PRIxPTR "",
9743 CID(context), (uintptr_t)callback, (uintptr_t)userParam);
9744
9745 if (context)
9746 {
9747 ASSERT(context == GetValidGlobalContext());
9748 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9749 bool isCallValid = (context->skipValidation() ||
9750 ValidateDebugMessageCallbackKHR(context, callback, userParam));
9751 if (isCallValid)
9752 {
9753 context->debugMessageCallback(callback, userParam);
9754 }
9755 ANGLE_CAPTURE(DebugMessageCallbackKHR, isCallValid, context, callback, userParam);
9756 }
9757 }
9758
DebugMessageControlContextANGLE(GLeglContext ctx,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)9759 void GL_APIENTRY DebugMessageControlContextANGLE(GLeglContext ctx,
9760 GLenum source,
9761 GLenum type,
9762 GLenum severity,
9763 GLsizei count,
9764 const GLuint *ids,
9765 GLboolean enabled)
9766 {
9767 Context *context = static_cast<gl::Context *>(ctx);
9768 EVENT("glDebugMessageControl",
9769 "context = %d, GLenum source = %s, GLenum type = %s, GLenum severity = %s, GLsizei count "
9770 "= %d, const GLuint *ids = 0x%016" PRIxPTR ", GLboolean enabled = %s",
9771 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
9772 GLenumToString(GLenumGroup::DebugType, type),
9773 GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids,
9774 GLbooleanToString(enabled));
9775
9776 if (context)
9777 {
9778 ASSERT(context == GetValidGlobalContext());
9779 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9780 bool isCallValid =
9781 (context->skipValidation() ||
9782 ValidateDebugMessageControl(context, source, type, severity, count, ids, enabled));
9783 if (isCallValid)
9784 {
9785 context->debugMessageControl(source, type, severity, count, ids, enabled);
9786 }
9787 ANGLE_CAPTURE(DebugMessageControl, isCallValid, context, source, type, severity, count, ids,
9788 enabled);
9789 }
9790 }
9791
DebugMessageControlKHRContextANGLE(GLeglContext ctx,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)9792 void GL_APIENTRY DebugMessageControlKHRContextANGLE(GLeglContext ctx,
9793 GLenum source,
9794 GLenum type,
9795 GLenum severity,
9796 GLsizei count,
9797 const GLuint *ids,
9798 GLboolean enabled)
9799 {
9800 Context *context = static_cast<gl::Context *>(ctx);
9801 EVENT("glDebugMessageControlKHR",
9802 "context = %d, GLenum source = %s, GLenum type = %s, GLenum severity = %s, GLsizei count "
9803 "= %d, const GLuint *ids = 0x%016" PRIxPTR ", GLboolean enabled = %s",
9804 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
9805 GLenumToString(GLenumGroup::DebugType, type),
9806 GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids,
9807 GLbooleanToString(enabled));
9808
9809 if (context)
9810 {
9811 ASSERT(context == GetValidGlobalContext());
9812 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9813 bool isCallValid =
9814 (context->skipValidation() ||
9815 ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled));
9816 if (isCallValid)
9817 {
9818 context->debugMessageControl(source, type, severity, count, ids, enabled);
9819 }
9820 ANGLE_CAPTURE(DebugMessageControlKHR, isCallValid, context, source, type, severity, count,
9821 ids, enabled);
9822 }
9823 }
9824
DebugMessageInsertContextANGLE(GLeglContext ctx,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)9825 void GL_APIENTRY DebugMessageInsertContextANGLE(GLeglContext ctx,
9826 GLenum source,
9827 GLenum type,
9828 GLuint id,
9829 GLenum severity,
9830 GLsizei length,
9831 const GLchar *buf)
9832 {
9833 Context *context = static_cast<gl::Context *>(ctx);
9834 EVENT("glDebugMessageInsert",
9835 "context = %d, GLenum source = %s, GLenum type = %s, GLuint id = %u, GLenum severity = "
9836 "%s, GLsizei length = %d, const GLchar *buf = 0x%016" PRIxPTR "",
9837 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
9838 GLenumToString(GLenumGroup::DebugType, type), id,
9839 GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf);
9840
9841 if (context)
9842 {
9843 ASSERT(context == GetValidGlobalContext());
9844 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9845 bool isCallValid =
9846 (context->skipValidation() ||
9847 ValidateDebugMessageInsert(context, source, type, id, severity, length, buf));
9848 if (isCallValid)
9849 {
9850 context->debugMessageInsert(source, type, id, severity, length, buf);
9851 }
9852 ANGLE_CAPTURE(DebugMessageInsert, isCallValid, context, source, type, id, severity, length,
9853 buf);
9854 }
9855 }
9856
DebugMessageInsertKHRContextANGLE(GLeglContext ctx,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)9857 void GL_APIENTRY DebugMessageInsertKHRContextANGLE(GLeglContext ctx,
9858 GLenum source,
9859 GLenum type,
9860 GLuint id,
9861 GLenum severity,
9862 GLsizei length,
9863 const GLchar *buf)
9864 {
9865 Context *context = static_cast<gl::Context *>(ctx);
9866 EVENT("glDebugMessageInsertKHR",
9867 "context = %d, GLenum source = %s, GLenum type = %s, GLuint id = %u, GLenum severity = "
9868 "%s, GLsizei length = %d, const GLchar *buf = 0x%016" PRIxPTR "",
9869 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
9870 GLenumToString(GLenumGroup::DebugType, type), id,
9871 GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf);
9872
9873 if (context)
9874 {
9875 ASSERT(context == GetValidGlobalContext());
9876 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9877 bool isCallValid =
9878 (context->skipValidation() ||
9879 ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf));
9880 if (isCallValid)
9881 {
9882 context->debugMessageInsert(source, type, id, severity, length, buf);
9883 }
9884 ANGLE_CAPTURE(DebugMessageInsertKHR, isCallValid, context, source, type, id, severity,
9885 length, buf);
9886 }
9887 }
9888
DeleteBuffersContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * buffers)9889 void GL_APIENTRY DeleteBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *buffers)
9890 {
9891 Context *context = static_cast<gl::Context *>(ctx);
9892 EVENT("glDeleteBuffers",
9893 "context = %d, GLsizei n = %d, const GLuint *buffers = 0x%016" PRIxPTR "", CID(context),
9894 n, (uintptr_t)buffers);
9895
9896 if (context)
9897 {
9898 ASSERT(context == GetValidGlobalContext());
9899 const BufferID *buffersPacked = FromGL<const BufferID *>(buffers);
9900 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9901 bool isCallValid =
9902 (context->skipValidation() || ValidateDeleteBuffers(context, n, buffersPacked));
9903 if (isCallValid)
9904 {
9905 context->deleteBuffers(n, buffersPacked);
9906 }
9907 ANGLE_CAPTURE(DeleteBuffers, isCallValid, context, n, buffersPacked);
9908 }
9909 }
9910
DeleteFencesNVContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * fences)9911 void GL_APIENTRY DeleteFencesNVContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *fences)
9912 {
9913 Context *context = static_cast<gl::Context *>(ctx);
9914 EVENT("glDeleteFencesNV",
9915 "context = %d, GLsizei n = %d, const GLuint *fences = 0x%016" PRIxPTR "", CID(context), n,
9916 (uintptr_t)fences);
9917
9918 if (context)
9919 {
9920 ASSERT(context == GetValidGlobalContext());
9921 const FenceNVID *fencesPacked = FromGL<const FenceNVID *>(fences);
9922 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9923 bool isCallValid =
9924 (context->skipValidation() || ValidateDeleteFencesNV(context, n, fencesPacked));
9925 if (isCallValid)
9926 {
9927 context->deleteFencesNV(n, fencesPacked);
9928 }
9929 ANGLE_CAPTURE(DeleteFencesNV, isCallValid, context, n, fencesPacked);
9930 }
9931 }
9932
DeleteFramebuffersContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * framebuffers)9933 void GL_APIENTRY DeleteFramebuffersContextANGLE(GLeglContext ctx,
9934 GLsizei n,
9935 const GLuint *framebuffers)
9936 {
9937 Context *context = static_cast<gl::Context *>(ctx);
9938 EVENT("glDeleteFramebuffers",
9939 "context = %d, GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR "",
9940 CID(context), n, (uintptr_t)framebuffers);
9941
9942 if (context)
9943 {
9944 ASSERT(context == GetValidGlobalContext());
9945 const FramebufferID *framebuffersPacked = FromGL<const FramebufferID *>(framebuffers);
9946 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9947 bool isCallValid = (context->skipValidation() ||
9948 ValidateDeleteFramebuffers(context, n, framebuffersPacked));
9949 if (isCallValid)
9950 {
9951 context->deleteFramebuffers(n, framebuffersPacked);
9952 }
9953 ANGLE_CAPTURE(DeleteFramebuffers, isCallValid, context, n, framebuffersPacked);
9954 }
9955 }
9956
DeleteFramebuffersOESContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * framebuffers)9957 void GL_APIENTRY DeleteFramebuffersOESContextANGLE(GLeglContext ctx,
9958 GLsizei n,
9959 const GLuint *framebuffers)
9960 {
9961 Context *context = static_cast<gl::Context *>(ctx);
9962 EVENT("glDeleteFramebuffersOES",
9963 "context = %d, GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR "",
9964 CID(context), n, (uintptr_t)framebuffers);
9965
9966 if (context)
9967 {
9968 ASSERT(context == GetValidGlobalContext());
9969 const FramebufferID *framebuffersPacked = FromGL<const FramebufferID *>(framebuffers);
9970 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9971 bool isCallValid = (context->skipValidation() ||
9972 ValidateDeleteFramebuffersOES(context, n, framebuffersPacked));
9973 if (isCallValid)
9974 {
9975 context->deleteFramebuffers(n, framebuffersPacked);
9976 }
9977 ANGLE_CAPTURE(DeleteFramebuffersOES, isCallValid, context, n, framebuffersPacked);
9978 }
9979 }
9980
DeleteMemoryObjectsEXTContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * memoryObjects)9981 void GL_APIENTRY DeleteMemoryObjectsEXTContextANGLE(GLeglContext ctx,
9982 GLsizei n,
9983 const GLuint *memoryObjects)
9984 {
9985 Context *context = static_cast<gl::Context *>(ctx);
9986 EVENT("glDeleteMemoryObjectsEXT",
9987 "context = %d, GLsizei n = %d, const GLuint *memoryObjects = 0x%016" PRIxPTR "",
9988 CID(context), n, (uintptr_t)memoryObjects);
9989
9990 if (context)
9991 {
9992 ASSERT(context == GetValidGlobalContext());
9993 const MemoryObjectID *memoryObjectsPacked = FromGL<const MemoryObjectID *>(memoryObjects);
9994 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
9995 bool isCallValid = (context->skipValidation() ||
9996 ValidateDeleteMemoryObjectsEXT(context, n, memoryObjectsPacked));
9997 if (isCallValid)
9998 {
9999 context->deleteMemoryObjects(n, memoryObjectsPacked);
10000 }
10001 ANGLE_CAPTURE(DeleteMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
10002 }
10003 }
10004
DeleteProgramContextANGLE(GLeglContext ctx,GLuint program)10005 void GL_APIENTRY DeleteProgramContextANGLE(GLeglContext ctx, GLuint program)
10006 {
10007 Context *context = static_cast<gl::Context *>(ctx);
10008 EVENT("glDeleteProgram", "context = %d, GLuint program = %u", CID(context), program);
10009
10010 if (context)
10011 {
10012 ASSERT(context == GetValidGlobalContext());
10013 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
10014 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10015 bool isCallValid =
10016 (context->skipValidation() || ValidateDeleteProgram(context, programPacked));
10017 if (isCallValid)
10018 {
10019 context->deleteProgram(programPacked);
10020 }
10021 ANGLE_CAPTURE(DeleteProgram, isCallValid, context, programPacked);
10022 }
10023 }
10024
DeleteProgramPipelinesContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * pipelines)10025 void GL_APIENTRY DeleteProgramPipelinesContextANGLE(GLeglContext ctx,
10026 GLsizei n,
10027 const GLuint *pipelines)
10028 {
10029 Context *context = static_cast<gl::Context *>(ctx);
10030 EVENT("glDeleteProgramPipelines",
10031 "context = %d, GLsizei n = %d, const GLuint *pipelines = 0x%016" PRIxPTR "", CID(context),
10032 n, (uintptr_t)pipelines);
10033
10034 if (context)
10035 {
10036 ASSERT(context == GetValidGlobalContext());
10037 const ProgramPipelineID *pipelinesPacked = FromGL<const ProgramPipelineID *>(pipelines);
10038 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10039 bool isCallValid = (context->skipValidation() ||
10040 ValidateDeleteProgramPipelines(context, n, pipelinesPacked));
10041 if (isCallValid)
10042 {
10043 context->deleteProgramPipelines(n, pipelinesPacked);
10044 }
10045 ANGLE_CAPTURE(DeleteProgramPipelines, isCallValid, context, n, pipelinesPacked);
10046 }
10047 }
10048
DeleteQueriesContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * ids)10049 void GL_APIENTRY DeleteQueriesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
10050 {
10051 Context *context = static_cast<gl::Context *>(ctx);
10052 EVENT("glDeleteQueries", "context = %d, GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR "",
10053 CID(context), n, (uintptr_t)ids);
10054
10055 if (context)
10056 {
10057 ASSERT(context == GetValidGlobalContext());
10058 const QueryID *idsPacked = FromGL<const QueryID *>(ids);
10059 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10060 bool isCallValid =
10061 (context->skipValidation() || ValidateDeleteQueries(context, n, idsPacked));
10062 if (isCallValid)
10063 {
10064 context->deleteQueries(n, idsPacked);
10065 }
10066 ANGLE_CAPTURE(DeleteQueries, isCallValid, context, n, idsPacked);
10067 }
10068 }
10069
DeleteQueriesEXTContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * ids)10070 void GL_APIENTRY DeleteQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
10071 {
10072 Context *context = static_cast<gl::Context *>(ctx);
10073 EVENT("glDeleteQueriesEXT",
10074 "context = %d, GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
10075 (uintptr_t)ids);
10076
10077 if (context)
10078 {
10079 ASSERT(context == GetValidGlobalContext());
10080 const QueryID *idsPacked = FromGL<const QueryID *>(ids);
10081 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10082 bool isCallValid =
10083 (context->skipValidation() || ValidateDeleteQueriesEXT(context, n, idsPacked));
10084 if (isCallValid)
10085 {
10086 context->deleteQueries(n, idsPacked);
10087 }
10088 ANGLE_CAPTURE(DeleteQueriesEXT, isCallValid, context, n, idsPacked);
10089 }
10090 }
10091
DeleteRenderbuffersContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * renderbuffers)10092 void GL_APIENTRY DeleteRenderbuffersContextANGLE(GLeglContext ctx,
10093 GLsizei n,
10094 const GLuint *renderbuffers)
10095 {
10096 Context *context = static_cast<gl::Context *>(ctx);
10097 EVENT("glDeleteRenderbuffers",
10098 "context = %d, GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR "",
10099 CID(context), n, (uintptr_t)renderbuffers);
10100
10101 if (context)
10102 {
10103 ASSERT(context == GetValidGlobalContext());
10104 const RenderbufferID *renderbuffersPacked = FromGL<const RenderbufferID *>(renderbuffers);
10105 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10106 bool isCallValid = (context->skipValidation() ||
10107 ValidateDeleteRenderbuffers(context, n, renderbuffersPacked));
10108 if (isCallValid)
10109 {
10110 context->deleteRenderbuffers(n, renderbuffersPacked);
10111 }
10112 ANGLE_CAPTURE(DeleteRenderbuffers, isCallValid, context, n, renderbuffersPacked);
10113 }
10114 }
10115
DeleteRenderbuffersOESContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * renderbuffers)10116 void GL_APIENTRY DeleteRenderbuffersOESContextANGLE(GLeglContext ctx,
10117 GLsizei n,
10118 const GLuint *renderbuffers)
10119 {
10120 Context *context = static_cast<gl::Context *>(ctx);
10121 EVENT("glDeleteRenderbuffersOES",
10122 "context = %d, GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR "",
10123 CID(context), n, (uintptr_t)renderbuffers);
10124
10125 if (context)
10126 {
10127 ASSERT(context == GetValidGlobalContext());
10128 const RenderbufferID *renderbuffersPacked = FromGL<const RenderbufferID *>(renderbuffers);
10129 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10130 bool isCallValid = (context->skipValidation() ||
10131 ValidateDeleteRenderbuffersOES(context, n, renderbuffersPacked));
10132 if (isCallValid)
10133 {
10134 context->deleteRenderbuffers(n, renderbuffersPacked);
10135 }
10136 ANGLE_CAPTURE(DeleteRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
10137 }
10138 }
10139
DeleteSamplersContextANGLE(GLeglContext ctx,GLsizei count,const GLuint * samplers)10140 void GL_APIENTRY DeleteSamplersContextANGLE(GLeglContext ctx, GLsizei count, const GLuint *samplers)
10141 {
10142 Context *context = static_cast<gl::Context *>(ctx);
10143 EVENT("glDeleteSamplers",
10144 "context = %d, GLsizei count = %d, const GLuint *samplers = 0x%016" PRIxPTR "",
10145 CID(context), count, (uintptr_t)samplers);
10146
10147 if (context)
10148 {
10149 ASSERT(context == GetValidGlobalContext());
10150 const SamplerID *samplersPacked = FromGL<const SamplerID *>(samplers);
10151 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10152 bool isCallValid =
10153 (context->skipValidation() || ValidateDeleteSamplers(context, count, samplersPacked));
10154 if (isCallValid)
10155 {
10156 context->deleteSamplers(count, samplersPacked);
10157 }
10158 ANGLE_CAPTURE(DeleteSamplers, isCallValid, context, count, samplersPacked);
10159 }
10160 }
10161
DeleteSemaphoresEXTContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * semaphores)10162 void GL_APIENTRY DeleteSemaphoresEXTContextANGLE(GLeglContext ctx,
10163 GLsizei n,
10164 const GLuint *semaphores)
10165 {
10166 Context *context = static_cast<gl::Context *>(ctx);
10167 EVENT("glDeleteSemaphoresEXT",
10168 "context = %d, GLsizei n = %d, const GLuint *semaphores = 0x%016" PRIxPTR "",
10169 CID(context), n, (uintptr_t)semaphores);
10170
10171 if (context)
10172 {
10173 ASSERT(context == GetValidGlobalContext());
10174 const SemaphoreID *semaphoresPacked = FromGL<const SemaphoreID *>(semaphores);
10175 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10176 bool isCallValid = (context->skipValidation() ||
10177 ValidateDeleteSemaphoresEXT(context, n, semaphoresPacked));
10178 if (isCallValid)
10179 {
10180 context->deleteSemaphores(n, semaphoresPacked);
10181 }
10182 ANGLE_CAPTURE(DeleteSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
10183 }
10184 }
10185
DeleteShaderContextANGLE(GLeglContext ctx,GLuint shader)10186 void GL_APIENTRY DeleteShaderContextANGLE(GLeglContext ctx, GLuint shader)
10187 {
10188 Context *context = static_cast<gl::Context *>(ctx);
10189 EVENT("glDeleteShader", "context = %d, GLuint shader = %u", CID(context), shader);
10190
10191 if (context)
10192 {
10193 ASSERT(context == GetValidGlobalContext());
10194 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
10195 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10196 bool isCallValid =
10197 (context->skipValidation() || ValidateDeleteShader(context, shaderPacked));
10198 if (isCallValid)
10199 {
10200 context->deleteShader(shaderPacked);
10201 }
10202 ANGLE_CAPTURE(DeleteShader, isCallValid, context, shaderPacked);
10203 }
10204 }
10205
DeleteSyncContextANGLE(GLeglContext ctx,GLsync sync)10206 void GL_APIENTRY DeleteSyncContextANGLE(GLeglContext ctx, GLsync sync)
10207 {
10208 Context *context = static_cast<gl::Context *>(ctx);
10209 EVENT("glDeleteSync", "context = %d, GLsync sync = 0x%016" PRIxPTR "", CID(context),
10210 (uintptr_t)sync);
10211
10212 if (context)
10213 {
10214 ASSERT(context == GetValidGlobalContext());
10215 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10216 bool isCallValid = (context->skipValidation() || ValidateDeleteSync(context, sync));
10217 if (isCallValid)
10218 {
10219 context->deleteSync(sync);
10220 }
10221 ANGLE_CAPTURE(DeleteSync, isCallValid, context, sync);
10222 }
10223 }
10224
DeleteTexturesContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * textures)10225 void GL_APIENTRY DeleteTexturesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *textures)
10226 {
10227 Context *context = static_cast<gl::Context *>(ctx);
10228 EVENT("glDeleteTextures",
10229 "context = %d, GLsizei n = %d, const GLuint *textures = 0x%016" PRIxPTR "", CID(context),
10230 n, (uintptr_t)textures);
10231
10232 if (context)
10233 {
10234 ASSERT(context == GetValidGlobalContext());
10235 const TextureID *texturesPacked = FromGL<const TextureID *>(textures);
10236 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10237 bool isCallValid =
10238 (context->skipValidation() || ValidateDeleteTextures(context, n, texturesPacked));
10239 if (isCallValid)
10240 {
10241 context->deleteTextures(n, texturesPacked);
10242 }
10243 ANGLE_CAPTURE(DeleteTextures, isCallValid, context, n, texturesPacked);
10244 }
10245 }
10246
DeleteTransformFeedbacksContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * ids)10247 void GL_APIENTRY DeleteTransformFeedbacksContextANGLE(GLeglContext ctx,
10248 GLsizei n,
10249 const GLuint *ids)
10250 {
10251 Context *context = static_cast<gl::Context *>(ctx);
10252 EVENT("glDeleteTransformFeedbacks",
10253 "context = %d, GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
10254 (uintptr_t)ids);
10255
10256 if (context)
10257 {
10258 ASSERT(context == GetValidGlobalContext());
10259 const TransformFeedbackID *idsPacked = FromGL<const TransformFeedbackID *>(ids);
10260 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10261 bool isCallValid =
10262 (context->skipValidation() || ValidateDeleteTransformFeedbacks(context, n, idsPacked));
10263 if (isCallValid)
10264 {
10265 context->deleteTransformFeedbacks(n, idsPacked);
10266 }
10267 ANGLE_CAPTURE(DeleteTransformFeedbacks, isCallValid, context, n, idsPacked);
10268 }
10269 }
10270
DeleteVertexArraysContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * arrays)10271 void GL_APIENTRY DeleteVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *arrays)
10272 {
10273 Context *context = static_cast<gl::Context *>(ctx);
10274 EVENT("glDeleteVertexArrays",
10275 "context = %d, GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR "", CID(context), n,
10276 (uintptr_t)arrays);
10277
10278 if (context)
10279 {
10280 ASSERT(context == GetValidGlobalContext());
10281 const VertexArrayID *arraysPacked = FromGL<const VertexArrayID *>(arrays);
10282 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10283 bool isCallValid =
10284 (context->skipValidation() || ValidateDeleteVertexArrays(context, n, arraysPacked));
10285 if (isCallValid)
10286 {
10287 context->deleteVertexArrays(n, arraysPacked);
10288 }
10289 ANGLE_CAPTURE(DeleteVertexArrays, isCallValid, context, n, arraysPacked);
10290 }
10291 }
10292
DeleteVertexArraysOESContextANGLE(GLeglContext ctx,GLsizei n,const GLuint * arrays)10293 void GL_APIENTRY DeleteVertexArraysOESContextANGLE(GLeglContext ctx,
10294 GLsizei n,
10295 const GLuint *arrays)
10296 {
10297 Context *context = static_cast<gl::Context *>(ctx);
10298 EVENT("glDeleteVertexArraysOES",
10299 "context = %d, GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR "", CID(context), n,
10300 (uintptr_t)arrays);
10301
10302 if (context)
10303 {
10304 ASSERT(context == GetValidGlobalContext());
10305 const VertexArrayID *arraysPacked = FromGL<const VertexArrayID *>(arrays);
10306 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10307 bool isCallValid =
10308 (context->skipValidation() || ValidateDeleteVertexArraysOES(context, n, arraysPacked));
10309 if (isCallValid)
10310 {
10311 context->deleteVertexArrays(n, arraysPacked);
10312 }
10313 ANGLE_CAPTURE(DeleteVertexArraysOES, isCallValid, context, n, arraysPacked);
10314 }
10315 }
10316
DepthFuncContextANGLE(GLeglContext ctx,GLenum func)10317 void GL_APIENTRY DepthFuncContextANGLE(GLeglContext ctx, GLenum func)
10318 {
10319 Context *context = static_cast<gl::Context *>(ctx);
10320 EVENT("glDepthFunc", "context = %d, GLenum func = %s", CID(context),
10321 GLenumToString(GLenumGroup::DepthFunction, func));
10322
10323 if (context)
10324 {
10325 ASSERT(context == GetValidGlobalContext());
10326 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10327 bool isCallValid = (context->skipValidation() || ValidateDepthFunc(context, func));
10328 if (isCallValid)
10329 {
10330 context->depthFunc(func);
10331 }
10332 ANGLE_CAPTURE(DepthFunc, isCallValid, context, func);
10333 }
10334 }
10335
DepthMaskContextANGLE(GLeglContext ctx,GLboolean flag)10336 void GL_APIENTRY DepthMaskContextANGLE(GLeglContext ctx, GLboolean flag)
10337 {
10338 Context *context = static_cast<gl::Context *>(ctx);
10339 EVENT("glDepthMask", "context = %d, GLboolean flag = %s", CID(context),
10340 GLbooleanToString(flag));
10341
10342 if (context)
10343 {
10344 ASSERT(context == GetValidGlobalContext());
10345 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10346 bool isCallValid = (context->skipValidation() || ValidateDepthMask(context, flag));
10347 if (isCallValid)
10348 {
10349 context->depthMask(flag);
10350 }
10351 ANGLE_CAPTURE(DepthMask, isCallValid, context, flag);
10352 }
10353 }
10354
DepthRangefContextANGLE(GLeglContext ctx,GLfloat n,GLfloat f)10355 void GL_APIENTRY DepthRangefContextANGLE(GLeglContext ctx, GLfloat n, GLfloat f)
10356 {
10357 Context *context = static_cast<gl::Context *>(ctx);
10358 EVENT("glDepthRangef", "context = %d, GLfloat n = %f, GLfloat f = %f", CID(context), n, f);
10359
10360 if (context)
10361 {
10362 ASSERT(context == GetValidGlobalContext());
10363 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10364 bool isCallValid = (context->skipValidation() || ValidateDepthRangef(context, n, f));
10365 if (isCallValid)
10366 {
10367 context->depthRangef(n, f);
10368 }
10369 ANGLE_CAPTURE(DepthRangef, isCallValid, context, n, f);
10370 }
10371 }
10372
DepthRangexContextANGLE(GLeglContext ctx,GLfixed n,GLfixed f)10373 void GL_APIENTRY DepthRangexContextANGLE(GLeglContext ctx, GLfixed n, GLfixed f)
10374 {
10375 Context *context = static_cast<gl::Context *>(ctx);
10376 EVENT("glDepthRangex", "context = %d, GLfixed n = 0x%X, GLfixed f = 0x%X", CID(context), n, f);
10377
10378 if (context)
10379 {
10380 ASSERT(context == GetValidGlobalContext());
10381 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10382 bool isCallValid = (context->skipValidation() || ValidateDepthRangex(context, n, f));
10383 if (isCallValid)
10384 {
10385 context->depthRangex(n, f);
10386 }
10387 ANGLE_CAPTURE(DepthRangex, isCallValid, context, n, f);
10388 }
10389 }
10390
DetachShaderContextANGLE(GLeglContext ctx,GLuint program,GLuint shader)10391 void GL_APIENTRY DetachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
10392 {
10393 Context *context = static_cast<gl::Context *>(ctx);
10394 EVENT("glDetachShader", "context = %d, GLuint program = %u, GLuint shader = %u", CID(context),
10395 program, shader);
10396
10397 if (context)
10398 {
10399 ASSERT(context == GetValidGlobalContext());
10400 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
10401 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
10402 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10403 bool isCallValid = (context->skipValidation() ||
10404 ValidateDetachShader(context, programPacked, shaderPacked));
10405 if (isCallValid)
10406 {
10407 context->detachShader(programPacked, shaderPacked);
10408 }
10409 ANGLE_CAPTURE(DetachShader, isCallValid, context, programPacked, shaderPacked);
10410 }
10411 }
10412
DisableContextANGLE(GLeglContext ctx,GLenum cap)10413 void GL_APIENTRY DisableContextANGLE(GLeglContext ctx, GLenum cap)
10414 {
10415 Context *context = static_cast<gl::Context *>(ctx);
10416 EVENT("glDisable", "context = %d, GLenum cap = %s", CID(context),
10417 GLenumToString(GLenumGroup::EnableCap, cap));
10418
10419 if (context)
10420 {
10421 ASSERT(context == GetValidGlobalContext());
10422 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10423 bool isCallValid = (context->skipValidation() || ValidateDisable(context, cap));
10424 if (isCallValid)
10425 {
10426 context->disable(cap);
10427 }
10428 ANGLE_CAPTURE(Disable, isCallValid, context, cap);
10429 }
10430 }
10431
DisableClientStateContextANGLE(GLeglContext ctx,GLenum array)10432 void GL_APIENTRY DisableClientStateContextANGLE(GLeglContext ctx, GLenum array)
10433 {
10434 Context *context = static_cast<gl::Context *>(ctx);
10435 EVENT("glDisableClientState", "context = %d, GLenum array = %s", CID(context),
10436 GLenumToString(GLenumGroup::EnableCap, array));
10437
10438 if (context)
10439 {
10440 ASSERT(context == GetValidGlobalContext());
10441 ClientVertexArrayType arrayPacked = FromGL<ClientVertexArrayType>(array);
10442 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10443 bool isCallValid =
10444 (context->skipValidation() || ValidateDisableClientState(context, arrayPacked));
10445 if (isCallValid)
10446 {
10447 context->disableClientState(arrayPacked);
10448 }
10449 ANGLE_CAPTURE(DisableClientState, isCallValid, context, arrayPacked);
10450 }
10451 }
10452
DisableVertexAttribArrayContextANGLE(GLeglContext ctx,GLuint index)10453 void GL_APIENTRY DisableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
10454 {
10455 Context *context = static_cast<gl::Context *>(ctx);
10456 EVENT("glDisableVertexAttribArray", "context = %d, GLuint index = %u", CID(context), index);
10457
10458 if (context)
10459 {
10460 ASSERT(context == GetValidGlobalContext());
10461 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10462 bool isCallValid =
10463 (context->skipValidation() || ValidateDisableVertexAttribArray(context, index));
10464 if (isCallValid)
10465 {
10466 context->disableVertexAttribArray(index);
10467 }
10468 ANGLE_CAPTURE(DisableVertexAttribArray, isCallValid, context, index);
10469 }
10470 }
10471
DisableiContextANGLE(GLeglContext ctx,GLenum target,GLuint index)10472 void GL_APIENTRY DisableiContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
10473 {
10474 Context *context = static_cast<gl::Context *>(ctx);
10475 EVENT("glDisablei", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
10476 GLenumToString(GLenumGroup::EnableCap, target), index);
10477
10478 if (context)
10479 {
10480 ASSERT(context == GetValidGlobalContext());
10481 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10482 bool isCallValid = (context->skipValidation() || ValidateDisablei(context, target, index));
10483 if (isCallValid)
10484 {
10485 context->disablei(target, index);
10486 }
10487 ANGLE_CAPTURE(Disablei, isCallValid, context, target, index);
10488 }
10489 }
10490
DisableiEXTContextANGLE(GLeglContext ctx,GLenum target,GLuint index)10491 void GL_APIENTRY DisableiEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
10492 {
10493 Context *context = static_cast<gl::Context *>(ctx);
10494 EVENT("glDisableiEXT", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
10495 GLenumToString(GLenumGroup::EnableCap, target), index);
10496
10497 if (context)
10498 {
10499 ASSERT(context == GetValidGlobalContext());
10500 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10501 bool isCallValid =
10502 (context->skipValidation() || ValidateDisableiEXT(context, target, index));
10503 if (isCallValid)
10504 {
10505 context->disablei(target, index);
10506 }
10507 ANGLE_CAPTURE(DisableiEXT, isCallValid, context, target, index);
10508 }
10509 }
10510
DisableiOESContextANGLE(GLeglContext ctx,GLenum target,GLuint index)10511 void GL_APIENTRY DisableiOESContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
10512 {
10513 Context *context = static_cast<gl::Context *>(ctx);
10514 EVENT("glDisableiOES", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
10515 GLenumToString(GLenumGroup::EnableCap, target), index);
10516
10517 if (context)
10518 {
10519 ASSERT(context == GetValidGlobalContext());
10520 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10521 bool isCallValid =
10522 (context->skipValidation() || ValidateDisableiOES(context, target, index));
10523 if (isCallValid)
10524 {
10525 context->disablei(target, index);
10526 }
10527 ANGLE_CAPTURE(DisableiOES, isCallValid, context, target, index);
10528 }
10529 }
10530
DiscardFramebufferEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei numAttachments,const GLenum * attachments)10531 void GL_APIENTRY DiscardFramebufferEXTContextANGLE(GLeglContext ctx,
10532 GLenum target,
10533 GLsizei numAttachments,
10534 const GLenum *attachments)
10535 {
10536 Context *context = static_cast<gl::Context *>(ctx);
10537 EVENT("glDiscardFramebufferEXT",
10538 "context = %d, GLenum target = %s, GLsizei numAttachments = %d, const GLenum "
10539 "*attachments = 0x%016" PRIxPTR "",
10540 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), numAttachments,
10541 (uintptr_t)attachments);
10542
10543 if (context)
10544 {
10545 ASSERT(context == GetValidGlobalContext());
10546 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10547 bool isCallValid =
10548 (context->skipValidation() ||
10549 ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments));
10550 if (isCallValid)
10551 {
10552 context->discardFramebuffer(target, numAttachments, attachments);
10553 }
10554 ANGLE_CAPTURE(DiscardFramebufferEXT, isCallValid, context, target, numAttachments,
10555 attachments);
10556 }
10557 }
10558
DispatchComputeContextANGLE(GLeglContext ctx,GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z)10559 void GL_APIENTRY DispatchComputeContextANGLE(GLeglContext ctx,
10560 GLuint num_groups_x,
10561 GLuint num_groups_y,
10562 GLuint num_groups_z)
10563 {
10564 Context *context = static_cast<gl::Context *>(ctx);
10565 EVENT("glDispatchCompute",
10566 "context = %d, GLuint num_groups_x = %u, GLuint num_groups_y = %u, GLuint num_groups_z = "
10567 "%u",
10568 CID(context), num_groups_x, num_groups_y, num_groups_z);
10569
10570 if (context)
10571 {
10572 ASSERT(context == GetValidGlobalContext());
10573 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10574 bool isCallValid =
10575 (context->skipValidation() ||
10576 ValidateDispatchCompute(context, num_groups_x, num_groups_y, num_groups_z));
10577 if (isCallValid)
10578 {
10579 context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
10580 }
10581 ANGLE_CAPTURE(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y,
10582 num_groups_z);
10583 }
10584 }
10585
DispatchComputeIndirectContextANGLE(GLeglContext ctx,GLintptr indirect)10586 void GL_APIENTRY DispatchComputeIndirectContextANGLE(GLeglContext ctx, GLintptr indirect)
10587 {
10588 Context *context = static_cast<gl::Context *>(ctx);
10589 EVENT("glDispatchComputeIndirect", "context = %d, GLintptr indirect = %llu", CID(context),
10590 static_cast<unsigned long long>(indirect));
10591
10592 if (context)
10593 {
10594 ASSERT(context == GetValidGlobalContext());
10595 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10596 bool isCallValid =
10597 (context->skipValidation() || ValidateDispatchComputeIndirect(context, indirect));
10598 if (isCallValid)
10599 {
10600 context->dispatchComputeIndirect(indirect);
10601 }
10602 ANGLE_CAPTURE(DispatchComputeIndirect, isCallValid, context, indirect);
10603 }
10604 }
10605
DrawArraysContextANGLE(GLeglContext ctx,GLenum mode,GLint first,GLsizei count)10606 void GL_APIENTRY DrawArraysContextANGLE(GLeglContext ctx, GLenum mode, GLint first, GLsizei count)
10607 {
10608 Context *context = static_cast<gl::Context *>(ctx);
10609 EVENT("glDrawArrays", "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d",
10610 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count);
10611
10612 if (context)
10613 {
10614 ASSERT(context == GetValidGlobalContext());
10615 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10616 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10617 bool isCallValid =
10618 (context->skipValidation() || ValidateDrawArrays(context, modePacked, first, count));
10619 if (isCallValid)
10620 {
10621 context->drawArrays(modePacked, first, count);
10622 }
10623 ANGLE_CAPTURE(DrawArrays, isCallValid, context, modePacked, first, count);
10624 }
10625 }
10626
DrawArraysIndirectContextANGLE(GLeglContext ctx,GLenum mode,const void * indirect)10627 void GL_APIENTRY DrawArraysIndirectContextANGLE(GLeglContext ctx, GLenum mode, const void *indirect)
10628 {
10629 Context *context = static_cast<gl::Context *>(ctx);
10630 EVENT("glDrawArraysIndirect",
10631 "context = %d, GLenum mode = %s, const void *indirect = 0x%016" PRIxPTR "", CID(context),
10632 GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect);
10633
10634 if (context)
10635 {
10636 ASSERT(context == GetValidGlobalContext());
10637 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10638 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10639 bool isCallValid = (context->skipValidation() ||
10640 ValidateDrawArraysIndirect(context, modePacked, indirect));
10641 if (isCallValid)
10642 {
10643 context->drawArraysIndirect(modePacked, indirect);
10644 }
10645 ANGLE_CAPTURE(DrawArraysIndirect, isCallValid, context, modePacked, indirect);
10646 }
10647 }
10648
DrawArraysInstancedContextANGLE(GLeglContext ctx,GLenum mode,GLint first,GLsizei count,GLsizei instancecount)10649 void GL_APIENTRY DrawArraysInstancedContextANGLE(GLeglContext ctx,
10650 GLenum mode,
10651 GLint first,
10652 GLsizei count,
10653 GLsizei instancecount)
10654 {
10655 Context *context = static_cast<gl::Context *>(ctx);
10656 EVENT("glDrawArraysInstanced",
10657 "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei "
10658 "instancecount = %d",
10659 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count,
10660 instancecount);
10661
10662 if (context)
10663 {
10664 ASSERT(context == GetValidGlobalContext());
10665 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10666 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10667 bool isCallValid =
10668 (context->skipValidation() ||
10669 ValidateDrawArraysInstanced(context, modePacked, first, count, instancecount));
10670 if (isCallValid)
10671 {
10672 context->drawArraysInstanced(modePacked, first, count, instancecount);
10673 }
10674 ANGLE_CAPTURE(DrawArraysInstanced, isCallValid, context, modePacked, first, count,
10675 instancecount);
10676 }
10677 }
10678
DrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,GLenum mode,GLint first,GLsizei count,GLsizei primcount)10679 void GL_APIENTRY DrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
10680 GLenum mode,
10681 GLint first,
10682 GLsizei count,
10683 GLsizei primcount)
10684 {
10685 Context *context = static_cast<gl::Context *>(ctx);
10686 EVENT("glDrawArraysInstancedANGLE",
10687 "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei primcount "
10688 "= %d",
10689 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, primcount);
10690
10691 if (context)
10692 {
10693 ASSERT(context == GetValidGlobalContext());
10694 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10695 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10696 bool isCallValid =
10697 (context->skipValidation() ||
10698 ValidateDrawArraysInstancedANGLE(context, modePacked, first, count, primcount));
10699 if (isCallValid)
10700 {
10701 context->drawArraysInstanced(modePacked, first, count, primcount);
10702 }
10703 ANGLE_CAPTURE(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count,
10704 primcount);
10705 }
10706 }
10707
DrawArraysInstancedEXTContextANGLE(GLeglContext ctx,GLenum mode,GLint start,GLsizei count,GLsizei primcount)10708 void GL_APIENTRY DrawArraysInstancedEXTContextANGLE(GLeglContext ctx,
10709 GLenum mode,
10710 GLint start,
10711 GLsizei count,
10712 GLsizei primcount)
10713 {
10714 Context *context = static_cast<gl::Context *>(ctx);
10715 EVENT("glDrawArraysInstancedEXT",
10716 "context = %d, GLenum mode = %s, GLint start = %d, GLsizei count = %d, GLsizei primcount "
10717 "= %d",
10718 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, count, primcount);
10719
10720 if (context)
10721 {
10722 ASSERT(context == GetValidGlobalContext());
10723 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10724 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10725 bool isCallValid =
10726 (context->skipValidation() ||
10727 ValidateDrawArraysInstancedEXT(context, modePacked, start, count, primcount));
10728 if (isCallValid)
10729 {
10730 context->drawArraysInstanced(modePacked, start, count, primcount);
10731 }
10732 ANGLE_CAPTURE(DrawArraysInstancedEXT, isCallValid, context, modePacked, start, count,
10733 primcount);
10734 }
10735 }
10736
DrawBuffersContextANGLE(GLeglContext ctx,GLsizei n,const GLenum * bufs)10737 void GL_APIENTRY DrawBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
10738 {
10739 Context *context = static_cast<gl::Context *>(ctx);
10740 EVENT("glDrawBuffers", "context = %d, GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR "",
10741 CID(context), n, (uintptr_t)bufs);
10742
10743 if (context)
10744 {
10745 ASSERT(context == GetValidGlobalContext());
10746 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10747 bool isCallValid = (context->skipValidation() || ValidateDrawBuffers(context, n, bufs));
10748 if (isCallValid)
10749 {
10750 context->drawBuffers(n, bufs);
10751 }
10752 ANGLE_CAPTURE(DrawBuffers, isCallValid, context, n, bufs);
10753 }
10754 }
10755
DrawBuffersEXTContextANGLE(GLeglContext ctx,GLsizei n,const GLenum * bufs)10756 void GL_APIENTRY DrawBuffersEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
10757 {
10758 Context *context = static_cast<gl::Context *>(ctx);
10759 EVENT("glDrawBuffersEXT",
10760 "context = %d, GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR "", CID(context), n,
10761 (uintptr_t)bufs);
10762
10763 if (context)
10764 {
10765 ASSERT(context == GetValidGlobalContext());
10766 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10767 bool isCallValid = (context->skipValidation() || ValidateDrawBuffersEXT(context, n, bufs));
10768 if (isCallValid)
10769 {
10770 context->drawBuffers(n, bufs);
10771 }
10772 ANGLE_CAPTURE(DrawBuffersEXT, isCallValid, context, n, bufs);
10773 }
10774 }
10775
DrawElementsContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices)10776 void GL_APIENTRY DrawElementsContextANGLE(GLeglContext ctx,
10777 GLenum mode,
10778 GLsizei count,
10779 GLenum type,
10780 const void *indices)
10781 {
10782 Context *context = static_cast<gl::Context *>(ctx);
10783 EVENT("glDrawElements",
10784 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
10785 "*indices = 0x%016" PRIxPTR "",
10786 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
10787 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices);
10788
10789 if (context)
10790 {
10791 ASSERT(context == GetValidGlobalContext());
10792 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10793 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10794 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10795 bool isCallValid = (context->skipValidation() ||
10796 ValidateDrawElements(context, modePacked, count, typePacked, indices));
10797 if (isCallValid)
10798 {
10799 context->drawElements(modePacked, count, typePacked, indices);
10800 }
10801 ANGLE_CAPTURE(DrawElements, isCallValid, context, modePacked, count, typePacked, indices);
10802 }
10803 }
10804
DrawElementsBaseVertexContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)10805 void GL_APIENTRY DrawElementsBaseVertexContextANGLE(GLeglContext ctx,
10806 GLenum mode,
10807 GLsizei count,
10808 GLenum type,
10809 const void *indices,
10810 GLint basevertex)
10811 {
10812 Context *context = static_cast<gl::Context *>(ctx);
10813 EVENT("glDrawElementsBaseVertex",
10814 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
10815 "*indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
10816 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
10817 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
10818
10819 if (context)
10820 {
10821 ASSERT(context == GetValidGlobalContext());
10822 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10823 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10824 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10825 bool isCallValid = (context->skipValidation() ||
10826 ValidateDrawElementsBaseVertex(context, modePacked, count, typePacked,
10827 indices, basevertex));
10828 if (isCallValid)
10829 {
10830 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
10831 }
10832 ANGLE_CAPTURE(DrawElementsBaseVertex, isCallValid, context, modePacked, count, typePacked,
10833 indices, basevertex);
10834 }
10835 }
10836
DrawElementsBaseVertexEXTContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)10837 void GL_APIENTRY DrawElementsBaseVertexEXTContextANGLE(GLeglContext ctx,
10838 GLenum mode,
10839 GLsizei count,
10840 GLenum type,
10841 const void *indices,
10842 GLint basevertex)
10843 {
10844 Context *context = static_cast<gl::Context *>(ctx);
10845 EVENT("glDrawElementsBaseVertexEXT",
10846 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
10847 "*indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
10848 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
10849 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
10850
10851 if (context)
10852 {
10853 ASSERT(context == GetValidGlobalContext());
10854 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10855 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10857 bool isCallValid = (context->skipValidation() ||
10858 ValidateDrawElementsBaseVertexEXT(context, modePacked, count,
10859 typePacked, indices, basevertex));
10860 if (isCallValid)
10861 {
10862 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
10863 }
10864 ANGLE_CAPTURE(DrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
10865 typePacked, indices, basevertex);
10866 }
10867 }
10868
DrawElementsBaseVertexOESContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)10869 void GL_APIENTRY DrawElementsBaseVertexOESContextANGLE(GLeglContext ctx,
10870 GLenum mode,
10871 GLsizei count,
10872 GLenum type,
10873 const void *indices,
10874 GLint basevertex)
10875 {
10876 Context *context = static_cast<gl::Context *>(ctx);
10877 EVENT("glDrawElementsBaseVertexOES",
10878 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
10879 "*indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
10880 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
10881 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
10882
10883 if (context)
10884 {
10885 ASSERT(context == GetValidGlobalContext());
10886 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10887 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10888 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10889 bool isCallValid = (context->skipValidation() ||
10890 ValidateDrawElementsBaseVertexOES(context, modePacked, count,
10891 typePacked, indices, basevertex));
10892 if (isCallValid)
10893 {
10894 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
10895 }
10896 ANGLE_CAPTURE(DrawElementsBaseVertexOES, isCallValid, context, modePacked, count,
10897 typePacked, indices, basevertex);
10898 }
10899 }
10900
DrawElementsIndirectContextANGLE(GLeglContext ctx,GLenum mode,GLenum type,const void * indirect)10901 void GL_APIENTRY DrawElementsIndirectContextANGLE(GLeglContext ctx,
10902 GLenum mode,
10903 GLenum type,
10904 const void *indirect)
10905 {
10906 Context *context = static_cast<gl::Context *>(ctx);
10907 EVENT("glDrawElementsIndirect",
10908 "context = %d, GLenum mode = %s, GLenum type = %s, const void *indirect = 0x%016" PRIxPTR
10909 "",
10910 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode),
10911 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect);
10912
10913 if (context)
10914 {
10915 ASSERT(context == GetValidGlobalContext());
10916 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10917 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10918 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10919 bool isCallValid =
10920 (context->skipValidation() ||
10921 ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect));
10922 if (isCallValid)
10923 {
10924 context->drawElementsIndirect(modePacked, typePacked, indirect);
10925 }
10926 ANGLE_CAPTURE(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, indirect);
10927 }
10928 }
10929
DrawElementsInstancedContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount)10930 void GL_APIENTRY DrawElementsInstancedContextANGLE(GLeglContext ctx,
10931 GLenum mode,
10932 GLsizei count,
10933 GLenum type,
10934 const void *indices,
10935 GLsizei instancecount)
10936 {
10937 Context *context = static_cast<gl::Context *>(ctx);
10938 EVENT("glDrawElementsInstanced",
10939 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
10940 "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d",
10941 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
10942 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount);
10943
10944 if (context)
10945 {
10946 ASSERT(context == GetValidGlobalContext());
10947 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10948 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10949 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10950 bool isCallValid = (context->skipValidation() ||
10951 ValidateDrawElementsInstanced(context, modePacked, count, typePacked,
10952 indices, instancecount));
10953 if (isCallValid)
10954 {
10955 context->drawElementsInstanced(modePacked, count, typePacked, indices, instancecount);
10956 }
10957 ANGLE_CAPTURE(DrawElementsInstanced, isCallValid, context, modePacked, count, typePacked,
10958 indices, instancecount);
10959 }
10960 }
10961
DrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)10962 void GL_APIENTRY DrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
10963 GLenum mode,
10964 GLsizei count,
10965 GLenum type,
10966 const void *indices,
10967 GLsizei primcount)
10968 {
10969 Context *context = static_cast<gl::Context *>(ctx);
10970 EVENT("glDrawElementsInstancedANGLE",
10971 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
10972 "*indices = 0x%016" PRIxPTR ", GLsizei primcount = %d",
10973 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
10974 GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, primcount);
10975
10976 if (context)
10977 {
10978 ASSERT(context == GetValidGlobalContext());
10979 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
10980 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
10981 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
10982 bool isCallValid = (context->skipValidation() ||
10983 ValidateDrawElementsInstancedANGLE(context, modePacked, count,
10984 typePacked, indices, primcount));
10985 if (isCallValid)
10986 {
10987 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
10988 }
10989 ANGLE_CAPTURE(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count,
10990 typePacked, indices, primcount);
10991 }
10992 }
10993
DrawElementsInstancedBaseVertexContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)10994 void GL_APIENTRY DrawElementsInstancedBaseVertexContextANGLE(GLeglContext ctx,
10995 GLenum mode,
10996 GLsizei count,
10997 GLenum type,
10998 const void *indices,
10999 GLsizei instancecount,
11000 GLint basevertex)
11001 {
11002 Context *context = static_cast<gl::Context *>(ctx);
11003 EVENT("glDrawElementsInstancedBaseVertex",
11004 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
11005 "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d, GLint basevertex = %d",
11006 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
11007 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
11008 basevertex);
11009
11010 if (context)
11011 {
11012 ASSERT(context == GetValidGlobalContext());
11013 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11014 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11015 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11016 bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertex(
11017 context, modePacked, count, typePacked,
11018 indices, instancecount, basevertex));
11019 if (isCallValid)
11020 {
11021 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
11022 instancecount, basevertex);
11023 }
11024 ANGLE_CAPTURE(DrawElementsInstancedBaseVertex, isCallValid, context, modePacked, count,
11025 typePacked, indices, instancecount, basevertex);
11026 }
11027 }
11028
DrawElementsInstancedBaseVertexEXTContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)11029 void GL_APIENTRY DrawElementsInstancedBaseVertexEXTContextANGLE(GLeglContext ctx,
11030 GLenum mode,
11031 GLsizei count,
11032 GLenum type,
11033 const void *indices,
11034 GLsizei instancecount,
11035 GLint basevertex)
11036 {
11037 Context *context = static_cast<gl::Context *>(ctx);
11038 EVENT("glDrawElementsInstancedBaseVertexEXT",
11039 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
11040 "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d, GLint basevertex = %d",
11041 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
11042 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
11043 basevertex);
11044
11045 if (context)
11046 {
11047 ASSERT(context == GetValidGlobalContext());
11048 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11049 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11050 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11051 bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexEXT(
11052 context, modePacked, count, typePacked,
11053 indices, instancecount, basevertex));
11054 if (isCallValid)
11055 {
11056 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
11057 instancecount, basevertex);
11058 }
11059 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexEXT, isCallValid, context, modePacked, count,
11060 typePacked, indices, instancecount, basevertex);
11061 }
11062 }
11063
DrawElementsInstancedBaseVertexOESContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)11064 void GL_APIENTRY DrawElementsInstancedBaseVertexOESContextANGLE(GLeglContext ctx,
11065 GLenum mode,
11066 GLsizei count,
11067 GLenum type,
11068 const void *indices,
11069 GLsizei instancecount,
11070 GLint basevertex)
11071 {
11072 Context *context = static_cast<gl::Context *>(ctx);
11073 EVENT("glDrawElementsInstancedBaseVertexOES",
11074 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
11075 "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d, GLint basevertex = %d",
11076 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
11077 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
11078 basevertex);
11079
11080 if (context)
11081 {
11082 ASSERT(context == GetValidGlobalContext());
11083 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11084 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11085 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11086 bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexOES(
11087 context, modePacked, count, typePacked,
11088 indices, instancecount, basevertex));
11089 if (isCallValid)
11090 {
11091 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
11092 instancecount, basevertex);
11093 }
11094 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexOES, isCallValid, context, modePacked, count,
11095 typePacked, indices, instancecount, basevertex);
11096 }
11097 }
11098
DrawElementsInstancedEXTContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)11099 void GL_APIENTRY DrawElementsInstancedEXTContextANGLE(GLeglContext ctx,
11100 GLenum mode,
11101 GLsizei count,
11102 GLenum type,
11103 const void *indices,
11104 GLsizei primcount)
11105 {
11106 Context *context = static_cast<gl::Context *>(ctx);
11107 EVENT("glDrawElementsInstancedEXT",
11108 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
11109 "*indices = 0x%016" PRIxPTR ", GLsizei primcount = %d",
11110 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
11111 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount);
11112
11113 if (context)
11114 {
11115 ASSERT(context == GetValidGlobalContext());
11116 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11117 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11118 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11119 bool isCallValid = (context->skipValidation() ||
11120 ValidateDrawElementsInstancedEXT(context, modePacked, count, typePacked,
11121 indices, primcount));
11122 if (isCallValid)
11123 {
11124 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
11125 }
11126 ANGLE_CAPTURE(DrawElementsInstancedEXT, isCallValid, context, modePacked, count, typePacked,
11127 indices, primcount);
11128 }
11129 }
11130
DrawRangeElementsContextANGLE(GLeglContext ctx,GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices)11131 void GL_APIENTRY DrawRangeElementsContextANGLE(GLeglContext ctx,
11132 GLenum mode,
11133 GLuint start,
11134 GLuint end,
11135 GLsizei count,
11136 GLenum type,
11137 const void *indices)
11138 {
11139 Context *context = static_cast<gl::Context *>(ctx);
11140 EVENT("glDrawRangeElements",
11141 "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
11142 "GLenum type = %s, const void *indices = 0x%016" PRIxPTR "",
11143 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
11144 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices);
11145
11146 if (context)
11147 {
11148 ASSERT(context == GetValidGlobalContext());
11149 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11150 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11151 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11152 bool isCallValid =
11153 (context->skipValidation() || ValidateDrawRangeElements(context, modePacked, start, end,
11154 count, typePacked, indices));
11155 if (isCallValid)
11156 {
11157 context->drawRangeElements(modePacked, start, end, count, typePacked, indices);
11158 }
11159 ANGLE_CAPTURE(DrawRangeElements, isCallValid, context, modePacked, start, end, count,
11160 typePacked, indices);
11161 }
11162 }
11163
DrawRangeElementsBaseVertexContextANGLE(GLeglContext ctx,GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)11164 void GL_APIENTRY DrawRangeElementsBaseVertexContextANGLE(GLeglContext ctx,
11165 GLenum mode,
11166 GLuint start,
11167 GLuint end,
11168 GLsizei count,
11169 GLenum type,
11170 const void *indices,
11171 GLint basevertex)
11172 {
11173 Context *context = static_cast<gl::Context *>(ctx);
11174 EVENT("glDrawRangeElementsBaseVertex",
11175 "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
11176 "GLenum type = %s, const void *indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
11177 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
11178 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
11179
11180 if (context)
11181 {
11182 ASSERT(context == GetValidGlobalContext());
11183 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11184 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11185 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11186 bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertex(
11187 context, modePacked, start, end, count,
11188 typePacked, indices, basevertex));
11189 if (isCallValid)
11190 {
11191 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
11192 basevertex);
11193 }
11194 ANGLE_CAPTURE(DrawRangeElementsBaseVertex, isCallValid, context, modePacked, start, end,
11195 count, typePacked, indices, basevertex);
11196 }
11197 }
11198
DrawRangeElementsBaseVertexEXTContextANGLE(GLeglContext ctx,GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)11199 void GL_APIENTRY DrawRangeElementsBaseVertexEXTContextANGLE(GLeglContext ctx,
11200 GLenum mode,
11201 GLuint start,
11202 GLuint end,
11203 GLsizei count,
11204 GLenum type,
11205 const void *indices,
11206 GLint basevertex)
11207 {
11208 Context *context = static_cast<gl::Context *>(ctx);
11209 EVENT("glDrawRangeElementsBaseVertexEXT",
11210 "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
11211 "GLenum type = %s, const void *indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
11212 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
11213 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
11214
11215 if (context)
11216 {
11217 ASSERT(context == GetValidGlobalContext());
11218 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11219 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11220 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11221 bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertexEXT(
11222 context, modePacked, start, end, count,
11223 typePacked, indices, basevertex));
11224 if (isCallValid)
11225 {
11226 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
11227 basevertex);
11228 }
11229 ANGLE_CAPTURE(DrawRangeElementsBaseVertexEXT, isCallValid, context, modePacked, start, end,
11230 count, typePacked, indices, basevertex);
11231 }
11232 }
11233
DrawRangeElementsBaseVertexOESContextANGLE(GLeglContext ctx,GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)11234 void GL_APIENTRY DrawRangeElementsBaseVertexOESContextANGLE(GLeglContext ctx,
11235 GLenum mode,
11236 GLuint start,
11237 GLuint end,
11238 GLsizei count,
11239 GLenum type,
11240 const void *indices,
11241 GLint basevertex)
11242 {
11243 Context *context = static_cast<gl::Context *>(ctx);
11244 EVENT("glDrawRangeElementsBaseVertexOES",
11245 "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
11246 "GLenum type = %s, const void *indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
11247 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
11248 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
11249
11250 if (context)
11251 {
11252 ASSERT(context == GetValidGlobalContext());
11253 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
11254 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
11255 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11256 bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertexOES(
11257 context, modePacked, start, end, count,
11258 typePacked, indices, basevertex));
11259 if (isCallValid)
11260 {
11261 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
11262 basevertex);
11263 }
11264 ANGLE_CAPTURE(DrawRangeElementsBaseVertexOES, isCallValid, context, modePacked, start, end,
11265 count, typePacked, indices, basevertex);
11266 }
11267 }
11268
DrawTexfOESContextANGLE(GLeglContext ctx,GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)11269 void GL_APIENTRY DrawTexfOESContextANGLE(GLeglContext ctx,
11270 GLfloat x,
11271 GLfloat y,
11272 GLfloat z,
11273 GLfloat width,
11274 GLfloat height)
11275 {
11276 Context *context = static_cast<gl::Context *>(ctx);
11277 EVENT("glDrawTexfOES",
11278 "context = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat width = %f, "
11279 "GLfloat height = %f",
11280 CID(context), x, y, z, width, height);
11281
11282 if (context)
11283 {
11284 ASSERT(context == GetValidGlobalContext());
11285 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11286 bool isCallValid =
11287 (context->skipValidation() || ValidateDrawTexfOES(context, x, y, z, width, height));
11288 if (isCallValid)
11289 {
11290 context->drawTexf(x, y, z, width, height);
11291 }
11292 ANGLE_CAPTURE(DrawTexfOES, isCallValid, context, x, y, z, width, height);
11293 }
11294 }
11295
DrawTexfvOESContextANGLE(GLeglContext ctx,const GLfloat * coords)11296 void GL_APIENTRY DrawTexfvOESContextANGLE(GLeglContext ctx, const GLfloat *coords)
11297 {
11298 Context *context = static_cast<gl::Context *>(ctx);
11299 EVENT("glDrawTexfvOES", "context = %d, const GLfloat *coords = 0x%016" PRIxPTR "", CID(context),
11300 (uintptr_t)coords);
11301
11302 if (context)
11303 {
11304 ASSERT(context == GetValidGlobalContext());
11305 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11306 bool isCallValid = (context->skipValidation() || ValidateDrawTexfvOES(context, coords));
11307 if (isCallValid)
11308 {
11309 context->drawTexfv(coords);
11310 }
11311 ANGLE_CAPTURE(DrawTexfvOES, isCallValid, context, coords);
11312 }
11313 }
11314
11315 void GL_APIENTRY
DrawTexiOESContextANGLE(GLeglContext ctx,GLint x,GLint y,GLint z,GLint width,GLint height)11316 DrawTexiOESContextANGLE(GLeglContext ctx, GLint x, GLint y, GLint z, GLint width, GLint height)
11317 {
11318 Context *context = static_cast<gl::Context *>(ctx);
11319 EVENT("glDrawTexiOES",
11320 "context = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height "
11321 "= %d",
11322 CID(context), x, y, z, width, height);
11323
11324 if (context)
11325 {
11326 ASSERT(context == GetValidGlobalContext());
11327 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11328 bool isCallValid =
11329 (context->skipValidation() || ValidateDrawTexiOES(context, x, y, z, width, height));
11330 if (isCallValid)
11331 {
11332 context->drawTexi(x, y, z, width, height);
11333 }
11334 ANGLE_CAPTURE(DrawTexiOES, isCallValid, context, x, y, z, width, height);
11335 }
11336 }
11337
DrawTexivOESContextANGLE(GLeglContext ctx,const GLint * coords)11338 void GL_APIENTRY DrawTexivOESContextANGLE(GLeglContext ctx, const GLint *coords)
11339 {
11340 Context *context = static_cast<gl::Context *>(ctx);
11341 EVENT("glDrawTexivOES", "context = %d, const GLint *coords = 0x%016" PRIxPTR "", CID(context),
11342 (uintptr_t)coords);
11343
11344 if (context)
11345 {
11346 ASSERT(context == GetValidGlobalContext());
11347 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11348 bool isCallValid = (context->skipValidation() || ValidateDrawTexivOES(context, coords));
11349 if (isCallValid)
11350 {
11351 context->drawTexiv(coords);
11352 }
11353 ANGLE_CAPTURE(DrawTexivOES, isCallValid, context, coords);
11354 }
11355 }
11356
DrawTexsOESContextANGLE(GLeglContext ctx,GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)11357 void GL_APIENTRY DrawTexsOESContextANGLE(GLeglContext ctx,
11358 GLshort x,
11359 GLshort y,
11360 GLshort z,
11361 GLshort width,
11362 GLshort height)
11363 {
11364 Context *context = static_cast<gl::Context *>(ctx);
11365 EVENT("glDrawTexsOES",
11366 "context = %d, GLshort x = %d, GLshort y = %d, GLshort z = %d, GLshort width = %d, "
11367 "GLshort height = %d",
11368 CID(context), x, y, z, width, height);
11369
11370 if (context)
11371 {
11372 ASSERT(context == GetValidGlobalContext());
11373 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11374 bool isCallValid =
11375 (context->skipValidation() || ValidateDrawTexsOES(context, x, y, z, width, height));
11376 if (isCallValid)
11377 {
11378 context->drawTexs(x, y, z, width, height);
11379 }
11380 ANGLE_CAPTURE(DrawTexsOES, isCallValid, context, x, y, z, width, height);
11381 }
11382 }
11383
DrawTexsvOESContextANGLE(GLeglContext ctx,const GLshort * coords)11384 void GL_APIENTRY DrawTexsvOESContextANGLE(GLeglContext ctx, const GLshort *coords)
11385 {
11386 Context *context = static_cast<gl::Context *>(ctx);
11387 EVENT("glDrawTexsvOES", "context = %d, const GLshort *coords = 0x%016" PRIxPTR "", CID(context),
11388 (uintptr_t)coords);
11389
11390 if (context)
11391 {
11392 ASSERT(context == GetValidGlobalContext());
11393 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11394 bool isCallValid = (context->skipValidation() || ValidateDrawTexsvOES(context, coords));
11395 if (isCallValid)
11396 {
11397 context->drawTexsv(coords);
11398 }
11399 ANGLE_CAPTURE(DrawTexsvOES, isCallValid, context, coords);
11400 }
11401 }
11402
DrawTexxOESContextANGLE(GLeglContext ctx,GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)11403 void GL_APIENTRY DrawTexxOESContextANGLE(GLeglContext ctx,
11404 GLfixed x,
11405 GLfixed y,
11406 GLfixed z,
11407 GLfixed width,
11408 GLfixed height)
11409 {
11410 Context *context = static_cast<gl::Context *>(ctx);
11411 EVENT("glDrawTexxOES",
11412 "context = %d, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X, GLfixed width = "
11413 "0x%X, GLfixed height = 0x%X",
11414 CID(context), x, y, z, width, height);
11415
11416 if (context)
11417 {
11418 ASSERT(context == GetValidGlobalContext());
11419 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11420 bool isCallValid =
11421 (context->skipValidation() || ValidateDrawTexxOES(context, x, y, z, width, height));
11422 if (isCallValid)
11423 {
11424 context->drawTexx(x, y, z, width, height);
11425 }
11426 ANGLE_CAPTURE(DrawTexxOES, isCallValid, context, x, y, z, width, height);
11427 }
11428 }
11429
DrawTexxvOESContextANGLE(GLeglContext ctx,const GLfixed * coords)11430 void GL_APIENTRY DrawTexxvOESContextANGLE(GLeglContext ctx, const GLfixed *coords)
11431 {
11432 Context *context = static_cast<gl::Context *>(ctx);
11433 EVENT("glDrawTexxvOES", "context = %d, const GLfixed *coords = 0x%016" PRIxPTR "", CID(context),
11434 (uintptr_t)coords);
11435
11436 if (context)
11437 {
11438 ASSERT(context == GetValidGlobalContext());
11439 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11440 bool isCallValid = (context->skipValidation() || ValidateDrawTexxvOES(context, coords));
11441 if (isCallValid)
11442 {
11443 context->drawTexxv(coords);
11444 }
11445 ANGLE_CAPTURE(DrawTexxvOES, isCallValid, context, coords);
11446 }
11447 }
11448
EGLImageTargetRenderbufferStorageOESContextANGLE(GLeglContext ctx,GLenum target,GLeglImageOES image)11449 void GL_APIENTRY EGLImageTargetRenderbufferStorageOESContextANGLE(GLeglContext ctx,
11450 GLenum target,
11451 GLeglImageOES image)
11452 {
11453 Context *context = static_cast<gl::Context *>(ctx);
11454 EVENT("glEGLImageTargetRenderbufferStorageOES",
11455 "context = %d, GLenum target = %s, GLeglImageOES image = 0x%016" PRIxPTR "", CID(context),
11456 GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
11457
11458 if (context)
11459 {
11460 ASSERT(context == GetValidGlobalContext());
11461 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11462 bool isCallValid = (context->skipValidation() ||
11463 ValidateEGLImageTargetRenderbufferStorageOES(context, target, image));
11464 if (isCallValid)
11465 {
11466 context->eGLImageTargetRenderbufferStorage(target, image);
11467 }
11468 ANGLE_CAPTURE(EGLImageTargetRenderbufferStorageOES, isCallValid, context, target, image);
11469 }
11470 }
11471
EGLImageTargetTexture2DOESContextANGLE(GLeglContext ctx,GLenum target,GLeglImageOES image)11472 void GL_APIENTRY EGLImageTargetTexture2DOESContextANGLE(GLeglContext ctx,
11473 GLenum target,
11474 GLeglImageOES image)
11475 {
11476 Context *context = static_cast<gl::Context *>(ctx);
11477 EVENT("glEGLImageTargetTexture2DOES",
11478 "context = %d, GLenum target = %s, GLeglImageOES image = 0x%016" PRIxPTR "", CID(context),
11479 GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
11480
11481 if (context)
11482 {
11483 ASSERT(context == GetValidGlobalContext());
11484 TextureType targetPacked = FromGL<TextureType>(target);
11485 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11486 bool isCallValid = (context->skipValidation() ||
11487 ValidateEGLImageTargetTexture2DOES(context, targetPacked, image));
11488 if (isCallValid)
11489 {
11490 context->eGLImageTargetTexture2D(targetPacked, image);
11491 }
11492 ANGLE_CAPTURE(EGLImageTargetTexture2DOES, isCallValid, context, targetPacked, image);
11493 }
11494 }
11495
EnableContextANGLE(GLeglContext ctx,GLenum cap)11496 void GL_APIENTRY EnableContextANGLE(GLeglContext ctx, GLenum cap)
11497 {
11498 Context *context = static_cast<gl::Context *>(ctx);
11499 EVENT("glEnable", "context = %d, GLenum cap = %s", CID(context),
11500 GLenumToString(GLenumGroup::EnableCap, cap));
11501
11502 if (context)
11503 {
11504 ASSERT(context == GetValidGlobalContext());
11505 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11506 bool isCallValid = (context->skipValidation() || ValidateEnable(context, cap));
11507 if (isCallValid)
11508 {
11509 context->enable(cap);
11510 }
11511 ANGLE_CAPTURE(Enable, isCallValid, context, cap);
11512 }
11513 }
11514
EnableClientStateContextANGLE(GLeglContext ctx,GLenum array)11515 void GL_APIENTRY EnableClientStateContextANGLE(GLeglContext ctx, GLenum array)
11516 {
11517 Context *context = static_cast<gl::Context *>(ctx);
11518 EVENT("glEnableClientState", "context = %d, GLenum array = %s", CID(context),
11519 GLenumToString(GLenumGroup::EnableCap, array));
11520
11521 if (context)
11522 {
11523 ASSERT(context == GetValidGlobalContext());
11524 ClientVertexArrayType arrayPacked = FromGL<ClientVertexArrayType>(array);
11525 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11526 bool isCallValid =
11527 (context->skipValidation() || ValidateEnableClientState(context, arrayPacked));
11528 if (isCallValid)
11529 {
11530 context->enableClientState(arrayPacked);
11531 }
11532 ANGLE_CAPTURE(EnableClientState, isCallValid, context, arrayPacked);
11533 }
11534 }
11535
EnableVertexAttribArrayContextANGLE(GLeglContext ctx,GLuint index)11536 void GL_APIENTRY EnableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
11537 {
11538 Context *context = static_cast<gl::Context *>(ctx);
11539 EVENT("glEnableVertexAttribArray", "context = %d, GLuint index = %u", CID(context), index);
11540
11541 if (context)
11542 {
11543 ASSERT(context == GetValidGlobalContext());
11544 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11545 bool isCallValid =
11546 (context->skipValidation() || ValidateEnableVertexAttribArray(context, index));
11547 if (isCallValid)
11548 {
11549 context->enableVertexAttribArray(index);
11550 }
11551 ANGLE_CAPTURE(EnableVertexAttribArray, isCallValid, context, index);
11552 }
11553 }
11554
EnableiContextANGLE(GLeglContext ctx,GLenum target,GLuint index)11555 void GL_APIENTRY EnableiContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
11556 {
11557 Context *context = static_cast<gl::Context *>(ctx);
11558 EVENT("glEnablei", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
11559 GLenumToString(GLenumGroup::EnableCap, target), index);
11560
11561 if (context)
11562 {
11563 ASSERT(context == GetValidGlobalContext());
11564 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11565 bool isCallValid = (context->skipValidation() || ValidateEnablei(context, target, index));
11566 if (isCallValid)
11567 {
11568 context->enablei(target, index);
11569 }
11570 ANGLE_CAPTURE(Enablei, isCallValid, context, target, index);
11571 }
11572 }
11573
EnableiEXTContextANGLE(GLeglContext ctx,GLenum target,GLuint index)11574 void GL_APIENTRY EnableiEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
11575 {
11576 Context *context = static_cast<gl::Context *>(ctx);
11577 EVENT("glEnableiEXT", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
11578 GLenumToString(GLenumGroup::EnableCap, target), index);
11579
11580 if (context)
11581 {
11582 ASSERT(context == GetValidGlobalContext());
11583 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11584 bool isCallValid =
11585 (context->skipValidation() || ValidateEnableiEXT(context, target, index));
11586 if (isCallValid)
11587 {
11588 context->enablei(target, index);
11589 }
11590 ANGLE_CAPTURE(EnableiEXT, isCallValid, context, target, index);
11591 }
11592 }
11593
EnableiOESContextANGLE(GLeglContext ctx,GLenum target,GLuint index)11594 void GL_APIENTRY EnableiOESContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
11595 {
11596 Context *context = static_cast<gl::Context *>(ctx);
11597 EVENT("glEnableiOES", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
11598 GLenumToString(GLenumGroup::EnableCap, target), index);
11599
11600 if (context)
11601 {
11602 ASSERT(context == GetValidGlobalContext());
11603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11604 bool isCallValid =
11605 (context->skipValidation() || ValidateEnableiOES(context, target, index));
11606 if (isCallValid)
11607 {
11608 context->enablei(target, index);
11609 }
11610 ANGLE_CAPTURE(EnableiOES, isCallValid, context, target, index);
11611 }
11612 }
11613
EndQueryContextANGLE(GLeglContext ctx,GLenum target)11614 void GL_APIENTRY EndQueryContextANGLE(GLeglContext ctx, GLenum target)
11615 {
11616 Context *context = static_cast<gl::Context *>(ctx);
11617 EVENT("glEndQuery", "context = %d, GLenum target = %s", CID(context),
11618 GLenumToString(GLenumGroup::QueryTarget, target));
11619
11620 if (context)
11621 {
11622 ASSERT(context == GetValidGlobalContext());
11623 QueryType targetPacked = FromGL<QueryType>(target);
11624 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11625 bool isCallValid = (context->skipValidation() || ValidateEndQuery(context, targetPacked));
11626 if (isCallValid)
11627 {
11628 context->endQuery(targetPacked);
11629 }
11630 ANGLE_CAPTURE(EndQuery, isCallValid, context, targetPacked);
11631 }
11632 }
11633
EndQueryEXTContextANGLE(GLeglContext ctx,GLenum target)11634 void GL_APIENTRY EndQueryEXTContextANGLE(GLeglContext ctx, GLenum target)
11635 {
11636 Context *context = static_cast<gl::Context *>(ctx);
11637 EVENT("glEndQueryEXT", "context = %d, GLenum target = %s", CID(context),
11638 GLenumToString(GLenumGroup::QueryTarget, target));
11639
11640 if (context)
11641 {
11642 ASSERT(context == GetValidGlobalContext());
11643 QueryType targetPacked = FromGL<QueryType>(target);
11644 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11645 bool isCallValid =
11646 (context->skipValidation() || ValidateEndQueryEXT(context, targetPacked));
11647 if (isCallValid)
11648 {
11649 context->endQuery(targetPacked);
11650 }
11651 ANGLE_CAPTURE(EndQueryEXT, isCallValid, context, targetPacked);
11652 }
11653 }
11654
EndTransformFeedbackContextANGLE(GLeglContext ctx)11655 void GL_APIENTRY EndTransformFeedbackContextANGLE(GLeglContext ctx)
11656 {
11657 Context *context = static_cast<gl::Context *>(ctx);
11658 EVENT("glEndTransformFeedback", "context = %d", CID(context));
11659
11660 if (context)
11661 {
11662 ASSERT(context == GetValidGlobalContext());
11663 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11664 bool isCallValid = (context->skipValidation() || ValidateEndTransformFeedback(context));
11665 if (isCallValid)
11666 {
11667 context->endTransformFeedback();
11668 }
11669 ANGLE_CAPTURE(EndTransformFeedback, isCallValid, context);
11670 }
11671 }
11672
FenceSyncContextANGLE(GLeglContext ctx,GLenum condition,GLbitfield flags)11673 GLsync GL_APIENTRY FenceSyncContextANGLE(GLeglContext ctx, GLenum condition, GLbitfield flags)
11674 {
11675 Context *context = static_cast<gl::Context *>(ctx);
11676 EVENT("glFenceSync", "context = %d, GLenum condition = %s, GLbitfield flags = %s", CID(context),
11677 GLenumToString(GLenumGroup::SyncCondition, condition),
11678 GLbitfieldToString(GLenumGroup::DefaultGroup, flags).c_str());
11679
11680 GLsync returnValue;
11681 if (context)
11682 {
11683 ASSERT(context == GetValidGlobalContext());
11684 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11685 bool isCallValid =
11686 (context->skipValidation() || ValidateFenceSync(context, condition, flags));
11687 if (isCallValid)
11688 {
11689 returnValue = context->fenceSync(condition, flags);
11690 }
11691 else
11692 {
11693 returnValue = GetDefaultReturnValue<EntryPoint::FenceSync, GLsync>();
11694 }
11695 ANGLE_CAPTURE(FenceSync, isCallValid, context, condition, flags, returnValue);
11696 }
11697 else
11698 {
11699 returnValue = GetDefaultReturnValue<EntryPoint::FenceSync, GLsync>();
11700 }
11701 return returnValue;
11702 }
11703
FinishContextANGLE(GLeglContext ctx)11704 void GL_APIENTRY FinishContextANGLE(GLeglContext ctx)
11705 {
11706 Context *context = static_cast<gl::Context *>(ctx);
11707 EVENT("glFinish", "context = %d", CID(context));
11708
11709 if (context)
11710 {
11711 ASSERT(context == GetValidGlobalContext());
11712 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11713 bool isCallValid = (context->skipValidation() || ValidateFinish(context));
11714 if (isCallValid)
11715 {
11716 context->finish();
11717 }
11718 ANGLE_CAPTURE(Finish, isCallValid, context);
11719 }
11720 }
11721
FinishFenceNVContextANGLE(GLeglContext ctx,GLuint fence)11722 void GL_APIENTRY FinishFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
11723 {
11724 Context *context = static_cast<gl::Context *>(ctx);
11725 EVENT("glFinishFenceNV", "context = %d, GLuint fence = %u", CID(context), fence);
11726
11727 if (context)
11728 {
11729 ASSERT(context == GetValidGlobalContext());
11730 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
11731 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11732 bool isCallValid =
11733 (context->skipValidation() || ValidateFinishFenceNV(context, fencePacked));
11734 if (isCallValid)
11735 {
11736 context->finishFenceNV(fencePacked);
11737 }
11738 ANGLE_CAPTURE(FinishFenceNV, isCallValid, context, fencePacked);
11739 }
11740 }
11741
FlushContextANGLE(GLeglContext ctx)11742 void GL_APIENTRY FlushContextANGLE(GLeglContext ctx)
11743 {
11744 Context *context = static_cast<gl::Context *>(ctx);
11745 EVENT("glFlush", "context = %d", CID(context));
11746
11747 if (context)
11748 {
11749 ASSERT(context == GetValidGlobalContext());
11750 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11751 bool isCallValid = (context->skipValidation() || ValidateFlush(context));
11752 if (isCallValid)
11753 {
11754 context->flush();
11755 }
11756 ANGLE_CAPTURE(Flush, isCallValid, context);
11757 }
11758 }
11759
FlushMappedBufferRangeContextANGLE(GLeglContext ctx,GLenum target,GLintptr offset,GLsizeiptr length)11760 void GL_APIENTRY FlushMappedBufferRangeContextANGLE(GLeglContext ctx,
11761 GLenum target,
11762 GLintptr offset,
11763 GLsizeiptr length)
11764 {
11765 Context *context = static_cast<gl::Context *>(ctx);
11766 EVENT("glFlushMappedBufferRange",
11767 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu",
11768 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
11769 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
11770
11771 if (context)
11772 {
11773 ASSERT(context == GetValidGlobalContext());
11774 BufferBinding targetPacked = FromGL<BufferBinding>(target);
11775 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11776 bool isCallValid = (context->skipValidation() ||
11777 ValidateFlushMappedBufferRange(context, targetPacked, offset, length));
11778 if (isCallValid)
11779 {
11780 context->flushMappedBufferRange(targetPacked, offset, length);
11781 }
11782 ANGLE_CAPTURE(FlushMappedBufferRange, isCallValid, context, targetPacked, offset, length);
11783 }
11784 }
11785
FlushMappedBufferRangeEXTContextANGLE(GLeglContext ctx,GLenum target,GLintptr offset,GLsizeiptr length)11786 void GL_APIENTRY FlushMappedBufferRangeEXTContextANGLE(GLeglContext ctx,
11787 GLenum target,
11788 GLintptr offset,
11789 GLsizeiptr length)
11790 {
11791 Context *context = static_cast<gl::Context *>(ctx);
11792 EVENT("glFlushMappedBufferRangeEXT",
11793 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu",
11794 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
11795 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
11796
11797 if (context)
11798 {
11799 ASSERT(context == GetValidGlobalContext());
11800 BufferBinding targetPacked = FromGL<BufferBinding>(target);
11801 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11802 bool isCallValid =
11803 (context->skipValidation() ||
11804 ValidateFlushMappedBufferRangeEXT(context, targetPacked, offset, length));
11805 if (isCallValid)
11806 {
11807 context->flushMappedBufferRange(targetPacked, offset, length);
11808 }
11809 ANGLE_CAPTURE(FlushMappedBufferRangeEXT, isCallValid, context, targetPacked, offset,
11810 length);
11811 }
11812 }
11813
FogfContextANGLE(GLeglContext ctx,GLenum pname,GLfloat param)11814 void GL_APIENTRY FogfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
11815 {
11816 Context *context = static_cast<gl::Context *>(ctx);
11817 EVENT("glFogf", "context = %d, GLenum pname = %s, GLfloat param = %f", CID(context),
11818 GLenumToString(GLenumGroup::FogParameter, pname), param);
11819
11820 if (context)
11821 {
11822 ASSERT(context == GetValidGlobalContext());
11823 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11824 bool isCallValid = (context->skipValidation() || ValidateFogf(context, pname, param));
11825 if (isCallValid)
11826 {
11827 context->fogf(pname, param);
11828 }
11829 ANGLE_CAPTURE(Fogf, isCallValid, context, pname, param);
11830 }
11831 }
11832
FogfvContextANGLE(GLeglContext ctx,GLenum pname,const GLfloat * params)11833 void GL_APIENTRY FogfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
11834 {
11835 Context *context = static_cast<gl::Context *>(ctx);
11836 EVENT("glFogfv", "context = %d, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR "",
11837 CID(context), GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params);
11838
11839 if (context)
11840 {
11841 ASSERT(context == GetValidGlobalContext());
11842 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11843 bool isCallValid = (context->skipValidation() || ValidateFogfv(context, pname, params));
11844 if (isCallValid)
11845 {
11846 context->fogfv(pname, params);
11847 }
11848 ANGLE_CAPTURE(Fogfv, isCallValid, context, pname, params);
11849 }
11850 }
11851
FogxContextANGLE(GLeglContext ctx,GLenum pname,GLfixed param)11852 void GL_APIENTRY FogxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
11853 {
11854 Context *context = static_cast<gl::Context *>(ctx);
11855 EVENT("glFogx", "context = %d, GLenum pname = %s, GLfixed param = 0x%X", CID(context),
11856 GLenumToString(GLenumGroup::FogPName, pname), param);
11857
11858 if (context)
11859 {
11860 ASSERT(context == GetValidGlobalContext());
11861 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11862 bool isCallValid = (context->skipValidation() || ValidateFogx(context, pname, param));
11863 if (isCallValid)
11864 {
11865 context->fogx(pname, param);
11866 }
11867 ANGLE_CAPTURE(Fogx, isCallValid, context, pname, param);
11868 }
11869 }
11870
FogxvContextANGLE(GLeglContext ctx,GLenum pname,const GLfixed * param)11871 void GL_APIENTRY FogxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
11872 {
11873 Context *context = static_cast<gl::Context *>(ctx);
11874 EVENT("glFogxv", "context = %d, GLenum pname = %s, const GLfixed *param = 0x%016" PRIxPTR "",
11875 CID(context), GLenumToString(GLenumGroup::FogPName, pname), (uintptr_t)param);
11876
11877 if (context)
11878 {
11879 ASSERT(context == GetValidGlobalContext());
11880 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11881 bool isCallValid = (context->skipValidation() || ValidateFogxv(context, pname, param));
11882 if (isCallValid)
11883 {
11884 context->fogxv(pname, param);
11885 }
11886 ANGLE_CAPTURE(Fogxv, isCallValid, context, pname, param);
11887 }
11888 }
11889
FramebufferParameteriContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint param)11890 void GL_APIENTRY FramebufferParameteriContextANGLE(GLeglContext ctx,
11891 GLenum target,
11892 GLenum pname,
11893 GLint param)
11894 {
11895 Context *context = static_cast<gl::Context *>(ctx);
11896 EVENT("glFramebufferParameteri",
11897 "context = %d, GLenum target = %s, GLenum pname = %s, GLint param = %d", CID(context),
11898 GLenumToString(GLenumGroup::FramebufferTarget, target),
11899 GLenumToString(GLenumGroup::FramebufferParameterName, pname), param);
11900
11901 if (context)
11902 {
11903 ASSERT(context == GetValidGlobalContext());
11904 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11905 bool isCallValid = (context->skipValidation() ||
11906 ValidateFramebufferParameteri(context, target, pname, param));
11907 if (isCallValid)
11908 {
11909 context->framebufferParameteri(target, pname, param);
11910 }
11911 ANGLE_CAPTURE(FramebufferParameteri, isCallValid, context, target, pname, param);
11912 }
11913 }
11914
FramebufferRenderbufferContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)11915 void GL_APIENTRY FramebufferRenderbufferContextANGLE(GLeglContext ctx,
11916 GLenum target,
11917 GLenum attachment,
11918 GLenum renderbuffertarget,
11919 GLuint renderbuffer)
11920 {
11921 Context *context = static_cast<gl::Context *>(ctx);
11922 EVENT("glFramebufferRenderbuffer",
11923 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum renderbuffertarget = "
11924 "%s, GLuint renderbuffer = %u",
11925 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
11926 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
11927 GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer);
11928
11929 if (context)
11930 {
11931 ASSERT(context == GetValidGlobalContext());
11932 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
11933 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11934 bool isCallValid =
11935 (context->skipValidation() ||
11936 ValidateFramebufferRenderbuffer(context, target, attachment, renderbuffertarget,
11937 renderbufferPacked));
11938 if (isCallValid)
11939 {
11940 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
11941 renderbufferPacked);
11942 }
11943 ANGLE_CAPTURE(FramebufferRenderbuffer, isCallValid, context, target, attachment,
11944 renderbuffertarget, renderbufferPacked);
11945 }
11946 }
11947
FramebufferRenderbufferOESContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)11948 void GL_APIENTRY FramebufferRenderbufferOESContextANGLE(GLeglContext ctx,
11949 GLenum target,
11950 GLenum attachment,
11951 GLenum renderbuffertarget,
11952 GLuint renderbuffer)
11953 {
11954 Context *context = static_cast<gl::Context *>(ctx);
11955 EVENT("glFramebufferRenderbufferOES",
11956 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum renderbuffertarget = "
11957 "%s, GLuint renderbuffer = %u",
11958 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
11959 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
11960 GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer);
11961
11962 if (context)
11963 {
11964 ASSERT(context == GetValidGlobalContext());
11965 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
11966 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11967 bool isCallValid =
11968 (context->skipValidation() ||
11969 ValidateFramebufferRenderbufferOES(context, target, attachment, renderbuffertarget,
11970 renderbufferPacked));
11971 if (isCallValid)
11972 {
11973 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
11974 renderbufferPacked);
11975 }
11976 ANGLE_CAPTURE(FramebufferRenderbufferOES, isCallValid, context, target, attachment,
11977 renderbuffertarget, renderbufferPacked);
11978 }
11979 }
11980
FramebufferTextureContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLuint texture,GLint level)11981 void GL_APIENTRY FramebufferTextureContextANGLE(GLeglContext ctx,
11982 GLenum target,
11983 GLenum attachment,
11984 GLuint texture,
11985 GLint level)
11986 {
11987 Context *context = static_cast<gl::Context *>(ctx);
11988 EVENT("glFramebufferTexture",
11989 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
11990 "level = %d",
11991 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
11992 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
11993
11994 if (context)
11995 {
11996 ASSERT(context == GetValidGlobalContext());
11997 TextureID texturePacked = FromGL<TextureID>(texture);
11998 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
11999 bool isCallValid =
12000 (context->skipValidation() ||
12001 ValidateFramebufferTexture(context, target, attachment, texturePacked, level));
12002 if (isCallValid)
12003 {
12004 context->framebufferTexture(target, attachment, texturePacked, level);
12005 }
12006 ANGLE_CAPTURE(FramebufferTexture, isCallValid, context, target, attachment, texturePacked,
12007 level);
12008 }
12009 }
12010
FramebufferTexture2DContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)12011 void GL_APIENTRY FramebufferTexture2DContextANGLE(GLeglContext ctx,
12012 GLenum target,
12013 GLenum attachment,
12014 GLenum textarget,
12015 GLuint texture,
12016 GLint level)
12017 {
12018 Context *context = static_cast<gl::Context *>(ctx);
12019 EVENT("glFramebufferTexture2D",
12020 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
12021 "texture = %u, GLint level = %d",
12022 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12023 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
12024 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
12025
12026 if (context)
12027 {
12028 ASSERT(context == GetValidGlobalContext());
12029 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
12030 TextureID texturePacked = FromGL<TextureID>(texture);
12031 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12032 bool isCallValid = (context->skipValidation() ||
12033 ValidateFramebufferTexture2D(context, target, attachment,
12034 textargetPacked, texturePacked, level));
12035 if (isCallValid)
12036 {
12037 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
12038 level);
12039 }
12040 ANGLE_CAPTURE(FramebufferTexture2D, isCallValid, context, target, attachment,
12041 textargetPacked, texturePacked, level);
12042 }
12043 }
12044
FramebufferTexture2DMultisampleEXTContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)12045 void GL_APIENTRY FramebufferTexture2DMultisampleEXTContextANGLE(GLeglContext ctx,
12046 GLenum target,
12047 GLenum attachment,
12048 GLenum textarget,
12049 GLuint texture,
12050 GLint level,
12051 GLsizei samples)
12052 {
12053 Context *context = static_cast<gl::Context *>(ctx);
12054 EVENT("glFramebufferTexture2DMultisampleEXT",
12055 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
12056 "texture = %u, GLint level = %d, GLsizei samples = %d",
12057 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12058 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
12059 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, samples);
12060
12061 if (context)
12062 {
12063 ASSERT(context == GetValidGlobalContext());
12064 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12065 bool isCallValid = (context->skipValidation() ||
12066 ValidateFramebufferTexture2DMultisampleEXT(
12067 context, target, attachment, textarget, texture, level, samples));
12068 if (isCallValid)
12069 {
12070 context->framebufferTexture2DMultisample(target, attachment, textarget, texture, level,
12071 samples);
12072 }
12073 ANGLE_CAPTURE(FramebufferTexture2DMultisampleEXT, isCallValid, context, target, attachment,
12074 textarget, texture, level, samples);
12075 }
12076 }
12077
FramebufferTexture2DOESContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)12078 void GL_APIENTRY FramebufferTexture2DOESContextANGLE(GLeglContext ctx,
12079 GLenum target,
12080 GLenum attachment,
12081 GLenum textarget,
12082 GLuint texture,
12083 GLint level)
12084 {
12085 Context *context = static_cast<gl::Context *>(ctx);
12086 EVENT("glFramebufferTexture2DOES",
12087 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
12088 "texture = %u, GLint level = %d",
12089 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12090 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
12091 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
12092
12093 if (context)
12094 {
12095 ASSERT(context == GetValidGlobalContext());
12096 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
12097 TextureID texturePacked = FromGL<TextureID>(texture);
12098 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12099 bool isCallValid = (context->skipValidation() ||
12100 ValidateFramebufferTexture2DOES(context, target, attachment,
12101 textargetPacked, texturePacked, level));
12102 if (isCallValid)
12103 {
12104 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
12105 level);
12106 }
12107 ANGLE_CAPTURE(FramebufferTexture2DOES, isCallValid, context, target, attachment,
12108 textargetPacked, texturePacked, level);
12109 }
12110 }
12111
FramebufferTexture3DOESContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)12112 void GL_APIENTRY FramebufferTexture3DOESContextANGLE(GLeglContext ctx,
12113 GLenum target,
12114 GLenum attachment,
12115 GLenum textarget,
12116 GLuint texture,
12117 GLint level,
12118 GLint zoffset)
12119 {
12120 Context *context = static_cast<gl::Context *>(ctx);
12121 EVENT("glFramebufferTexture3DOES",
12122 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum textarget = %s, GLuint "
12123 "texture = %u, GLint level = %d, GLint zoffset = %d",
12124 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12125 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
12126 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset);
12127
12128 if (context)
12129 {
12130 ASSERT(context == GetValidGlobalContext());
12131 TextureTarget textargetPacked = FromGL<TextureTarget>(textarget);
12132 TextureID texturePacked = FromGL<TextureID>(texture);
12133 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12134 bool isCallValid =
12135 (context->skipValidation() ||
12136 ValidateFramebufferTexture3DOES(context, target, attachment, textargetPacked,
12137 texturePacked, level, zoffset));
12138 if (isCallValid)
12139 {
12140 context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
12141 zoffset);
12142 }
12143 ANGLE_CAPTURE(FramebufferTexture3DOES, isCallValid, context, target, attachment,
12144 textargetPacked, texturePacked, level, zoffset);
12145 }
12146 }
12147
FramebufferTextureEXTContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLuint texture,GLint level)12148 void GL_APIENTRY FramebufferTextureEXTContextANGLE(GLeglContext ctx,
12149 GLenum target,
12150 GLenum attachment,
12151 GLuint texture,
12152 GLint level)
12153 {
12154 Context *context = static_cast<gl::Context *>(ctx);
12155 EVENT("glFramebufferTextureEXT",
12156 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
12157 "level = %d",
12158 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12159 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
12160
12161 if (context)
12162 {
12163 ASSERT(context == GetValidGlobalContext());
12164 TextureID texturePacked = FromGL<TextureID>(texture);
12165 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12166 bool isCallValid =
12167 (context->skipValidation() ||
12168 ValidateFramebufferTextureEXT(context, target, attachment, texturePacked, level));
12169 if (isCallValid)
12170 {
12171 context->framebufferTexture(target, attachment, texturePacked, level);
12172 }
12173 ANGLE_CAPTURE(FramebufferTextureEXT, isCallValid, context, target, attachment,
12174 texturePacked, level);
12175 }
12176 }
12177
FramebufferTextureLayerContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)12178 void GL_APIENTRY FramebufferTextureLayerContextANGLE(GLeglContext ctx,
12179 GLenum target,
12180 GLenum attachment,
12181 GLuint texture,
12182 GLint level,
12183 GLint layer)
12184 {
12185 Context *context = static_cast<gl::Context *>(ctx);
12186 EVENT("glFramebufferTextureLayer",
12187 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
12188 "level = %d, GLint layer = %d",
12189 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12190 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level, layer);
12191
12192 if (context)
12193 {
12194 ASSERT(context == GetValidGlobalContext());
12195 TextureID texturePacked = FromGL<TextureID>(texture);
12196 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12197 bool isCallValid = (context->skipValidation() ||
12198 ValidateFramebufferTextureLayer(context, target, attachment,
12199 texturePacked, level, layer));
12200 if (isCallValid)
12201 {
12202 context->framebufferTextureLayer(target, attachment, texturePacked, level, layer);
12203 }
12204 ANGLE_CAPTURE(FramebufferTextureLayer, isCallValid, context, target, attachment,
12205 texturePacked, level, layer);
12206 }
12207 }
12208
FramebufferTextureMultiviewOVRContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLuint texture,GLint level,GLint baseViewIndex,GLsizei numViews)12209 void GL_APIENTRY FramebufferTextureMultiviewOVRContextANGLE(GLeglContext ctx,
12210 GLenum target,
12211 GLenum attachment,
12212 GLuint texture,
12213 GLint level,
12214 GLint baseViewIndex,
12215 GLsizei numViews)
12216 {
12217 Context *context = static_cast<gl::Context *>(ctx);
12218 EVENT("glFramebufferTextureMultiviewOVR",
12219 "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
12220 "level = %d, GLint baseViewIndex = %d, GLsizei numViews = %d",
12221 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
12222 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level,
12223 baseViewIndex, numViews);
12224
12225 if (context)
12226 {
12227 ASSERT(context == GetValidGlobalContext());
12228 TextureID texturePacked = FromGL<TextureID>(texture);
12229 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12230 bool isCallValid =
12231 (context->skipValidation() ||
12232 ValidateFramebufferTextureMultiviewOVR(context, target, attachment, texturePacked,
12233 level, baseViewIndex, numViews));
12234 if (isCallValid)
12235 {
12236 context->framebufferTextureMultiview(target, attachment, texturePacked, level,
12237 baseViewIndex, numViews);
12238 }
12239 ANGLE_CAPTURE(FramebufferTextureMultiviewOVR, isCallValid, context, target, attachment,
12240 texturePacked, level, baseViewIndex, numViews);
12241 }
12242 }
12243
FrontFaceContextANGLE(GLeglContext ctx,GLenum mode)12244 void GL_APIENTRY FrontFaceContextANGLE(GLeglContext ctx, GLenum mode)
12245 {
12246 Context *context = static_cast<gl::Context *>(ctx);
12247 EVENT("glFrontFace", "context = %d, GLenum mode = %s", CID(context),
12248 GLenumToString(GLenumGroup::FrontFaceDirection, mode));
12249
12250 if (context)
12251 {
12252 ASSERT(context == GetValidGlobalContext());
12253 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12254 bool isCallValid = (context->skipValidation() || ValidateFrontFace(context, mode));
12255 if (isCallValid)
12256 {
12257 context->frontFace(mode);
12258 }
12259 ANGLE_CAPTURE(FrontFace, isCallValid, context, mode);
12260 }
12261 }
12262
FrustumfContextANGLE(GLeglContext ctx,GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f)12263 void GL_APIENTRY FrustumfContextANGLE(GLeglContext ctx,
12264 GLfloat l,
12265 GLfloat r,
12266 GLfloat b,
12267 GLfloat t,
12268 GLfloat n,
12269 GLfloat f)
12270 {
12271 Context *context = static_cast<gl::Context *>(ctx);
12272 EVENT("glFrustumf",
12273 "context = %d, GLfloat l = %f, GLfloat r = %f, GLfloat b = %f, GLfloat t = %f, GLfloat n "
12274 "= %f, GLfloat f = %f",
12275 CID(context), l, r, b, t, n, f);
12276
12277 if (context)
12278 {
12279 ASSERT(context == GetValidGlobalContext());
12280 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12281 bool isCallValid =
12282 (context->skipValidation() || ValidateFrustumf(context, l, r, b, t, n, f));
12283 if (isCallValid)
12284 {
12285 context->frustumf(l, r, b, t, n, f);
12286 }
12287 ANGLE_CAPTURE(Frustumf, isCallValid, context, l, r, b, t, n, f);
12288 }
12289 }
12290
FrustumxContextANGLE(GLeglContext ctx,GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f)12291 void GL_APIENTRY FrustumxContextANGLE(GLeglContext ctx,
12292 GLfixed l,
12293 GLfixed r,
12294 GLfixed b,
12295 GLfixed t,
12296 GLfixed n,
12297 GLfixed f)
12298 {
12299 Context *context = static_cast<gl::Context *>(ctx);
12300 EVENT("glFrustumx",
12301 "context = %d, GLfixed l = 0x%X, GLfixed r = 0x%X, GLfixed b = 0x%X, GLfixed t = 0x%X, "
12302 "GLfixed n = 0x%X, GLfixed f = 0x%X",
12303 CID(context), l, r, b, t, n, f);
12304
12305 if (context)
12306 {
12307 ASSERT(context == GetValidGlobalContext());
12308 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12309 bool isCallValid =
12310 (context->skipValidation() || ValidateFrustumx(context, l, r, b, t, n, f));
12311 if (isCallValid)
12312 {
12313 context->frustumx(l, r, b, t, n, f);
12314 }
12315 ANGLE_CAPTURE(Frustumx, isCallValid, context, l, r, b, t, n, f);
12316 }
12317 }
12318
GenBuffersContextANGLE(GLeglContext ctx,GLsizei n,GLuint * buffers)12319 void GL_APIENTRY GenBuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *buffers)
12320 {
12321 Context *context = static_cast<gl::Context *>(ctx);
12322 EVENT("glGenBuffers", "context = %d, GLsizei n = %d, GLuint *buffers = 0x%016" PRIxPTR "",
12323 CID(context), n, (uintptr_t)buffers);
12324
12325 if (context)
12326 {
12327 ASSERT(context == GetValidGlobalContext());
12328 BufferID *buffersPacked = FromGL<BufferID *>(buffers);
12329 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12330 bool isCallValid =
12331 (context->skipValidation() || ValidateGenBuffers(context, n, buffersPacked));
12332 if (isCallValid)
12333 {
12334 context->genBuffers(n, buffersPacked);
12335 }
12336 ANGLE_CAPTURE(GenBuffers, isCallValid, context, n, buffersPacked);
12337 }
12338 }
12339
GenFencesNVContextANGLE(GLeglContext ctx,GLsizei n,GLuint * fences)12340 void GL_APIENTRY GenFencesNVContextANGLE(GLeglContext ctx, GLsizei n, GLuint *fences)
12341 {
12342 Context *context = static_cast<gl::Context *>(ctx);
12343 EVENT("glGenFencesNV", "context = %d, GLsizei n = %d, GLuint *fences = 0x%016" PRIxPTR "",
12344 CID(context), n, (uintptr_t)fences);
12345
12346 if (context)
12347 {
12348 ASSERT(context == GetValidGlobalContext());
12349 FenceNVID *fencesPacked = FromGL<FenceNVID *>(fences);
12350 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12351 bool isCallValid =
12352 (context->skipValidation() || ValidateGenFencesNV(context, n, fencesPacked));
12353 if (isCallValid)
12354 {
12355 context->genFencesNV(n, fencesPacked);
12356 }
12357 ANGLE_CAPTURE(GenFencesNV, isCallValid, context, n, fencesPacked);
12358 }
12359 }
12360
GenFramebuffersContextANGLE(GLeglContext ctx,GLsizei n,GLuint * framebuffers)12361 void GL_APIENTRY GenFramebuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
12362 {
12363 Context *context = static_cast<gl::Context *>(ctx);
12364 EVENT("glGenFramebuffers",
12365 "context = %d, GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR "", CID(context), n,
12366 (uintptr_t)framebuffers);
12367
12368 if (context)
12369 {
12370 ASSERT(context == GetValidGlobalContext());
12371 FramebufferID *framebuffersPacked = FromGL<FramebufferID *>(framebuffers);
12372 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12373 bool isCallValid =
12374 (context->skipValidation() || ValidateGenFramebuffers(context, n, framebuffersPacked));
12375 if (isCallValid)
12376 {
12377 context->genFramebuffers(n, framebuffersPacked);
12378 }
12379 ANGLE_CAPTURE(GenFramebuffers, isCallValid, context, n, framebuffersPacked);
12380 }
12381 }
12382
GenFramebuffersOESContextANGLE(GLeglContext ctx,GLsizei n,GLuint * framebuffers)12383 void GL_APIENTRY GenFramebuffersOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
12384 {
12385 Context *context = static_cast<gl::Context *>(ctx);
12386 EVENT("glGenFramebuffersOES",
12387 "context = %d, GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR "", CID(context), n,
12388 (uintptr_t)framebuffers);
12389
12390 if (context)
12391 {
12392 ASSERT(context == GetValidGlobalContext());
12393 FramebufferID *framebuffersPacked = FromGL<FramebufferID *>(framebuffers);
12394 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12395 bool isCallValid = (context->skipValidation() ||
12396 ValidateGenFramebuffersOES(context, n, framebuffersPacked));
12397 if (isCallValid)
12398 {
12399 context->genFramebuffers(n, framebuffersPacked);
12400 }
12401 ANGLE_CAPTURE(GenFramebuffersOES, isCallValid, context, n, framebuffersPacked);
12402 }
12403 }
12404
GenProgramPipelinesContextANGLE(GLeglContext ctx,GLsizei n,GLuint * pipelines)12405 void GL_APIENTRY GenProgramPipelinesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *pipelines)
12406 {
12407 Context *context = static_cast<gl::Context *>(ctx);
12408 EVENT("glGenProgramPipelines",
12409 "context = %d, GLsizei n = %d, GLuint *pipelines = 0x%016" PRIxPTR "", CID(context), n,
12410 (uintptr_t)pipelines);
12411
12412 if (context)
12413 {
12414 ASSERT(context == GetValidGlobalContext());
12415 ProgramPipelineID *pipelinesPacked = FromGL<ProgramPipelineID *>(pipelines);
12416 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12417 bool isCallValid =
12418 (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelinesPacked));
12419 if (isCallValid)
12420 {
12421 context->genProgramPipelines(n, pipelinesPacked);
12422 }
12423 ANGLE_CAPTURE(GenProgramPipelines, isCallValid, context, n, pipelinesPacked);
12424 }
12425 }
12426
GenQueriesContextANGLE(GLeglContext ctx,GLsizei n,GLuint * ids)12427 void GL_APIENTRY GenQueriesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
12428 {
12429 Context *context = static_cast<gl::Context *>(ctx);
12430 EVENT("glGenQueries", "context = %d, GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR "",
12431 CID(context), n, (uintptr_t)ids);
12432
12433 if (context)
12434 {
12435 ASSERT(context == GetValidGlobalContext());
12436 QueryID *idsPacked = FromGL<QueryID *>(ids);
12437 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12438 bool isCallValid = (context->skipValidation() || ValidateGenQueries(context, n, idsPacked));
12439 if (isCallValid)
12440 {
12441 context->genQueries(n, idsPacked);
12442 }
12443 ANGLE_CAPTURE(GenQueries, isCallValid, context, n, idsPacked);
12444 }
12445 }
12446
GenQueriesEXTContextANGLE(GLeglContext ctx,GLsizei n,GLuint * ids)12447 void GL_APIENTRY GenQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
12448 {
12449 Context *context = static_cast<gl::Context *>(ctx);
12450 EVENT("glGenQueriesEXT", "context = %d, GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR "",
12451 CID(context), n, (uintptr_t)ids);
12452
12453 if (context)
12454 {
12455 ASSERT(context == GetValidGlobalContext());
12456 QueryID *idsPacked = FromGL<QueryID *>(ids);
12457 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12458 bool isCallValid =
12459 (context->skipValidation() || ValidateGenQueriesEXT(context, n, idsPacked));
12460 if (isCallValid)
12461 {
12462 context->genQueries(n, idsPacked);
12463 }
12464 ANGLE_CAPTURE(GenQueriesEXT, isCallValid, context, n, idsPacked);
12465 }
12466 }
12467
GenRenderbuffersContextANGLE(GLeglContext ctx,GLsizei n,GLuint * renderbuffers)12468 void GL_APIENTRY GenRenderbuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *renderbuffers)
12469 {
12470 Context *context = static_cast<gl::Context *>(ctx);
12471 EVENT("glGenRenderbuffers",
12472 "context = %d, GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR "", CID(context),
12473 n, (uintptr_t)renderbuffers);
12474
12475 if (context)
12476 {
12477 ASSERT(context == GetValidGlobalContext());
12478 RenderbufferID *renderbuffersPacked = FromGL<RenderbufferID *>(renderbuffers);
12479 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12480 bool isCallValid = (context->skipValidation() ||
12481 ValidateGenRenderbuffers(context, n, renderbuffersPacked));
12482 if (isCallValid)
12483 {
12484 context->genRenderbuffers(n, renderbuffersPacked);
12485 }
12486 ANGLE_CAPTURE(GenRenderbuffers, isCallValid, context, n, renderbuffersPacked);
12487 }
12488 }
12489
GenRenderbuffersOESContextANGLE(GLeglContext ctx,GLsizei n,GLuint * renderbuffers)12490 void GL_APIENTRY GenRenderbuffersOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *renderbuffers)
12491 {
12492 Context *context = static_cast<gl::Context *>(ctx);
12493 EVENT("glGenRenderbuffersOES",
12494 "context = %d, GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR "", CID(context),
12495 n, (uintptr_t)renderbuffers);
12496
12497 if (context)
12498 {
12499 ASSERT(context == GetValidGlobalContext());
12500 RenderbufferID *renderbuffersPacked = FromGL<RenderbufferID *>(renderbuffers);
12501 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12502 bool isCallValid = (context->skipValidation() ||
12503 ValidateGenRenderbuffersOES(context, n, renderbuffersPacked));
12504 if (isCallValid)
12505 {
12506 context->genRenderbuffers(n, renderbuffersPacked);
12507 }
12508 ANGLE_CAPTURE(GenRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
12509 }
12510 }
12511
GenSamplersContextANGLE(GLeglContext ctx,GLsizei count,GLuint * samplers)12512 void GL_APIENTRY GenSamplersContextANGLE(GLeglContext ctx, GLsizei count, GLuint *samplers)
12513 {
12514 Context *context = static_cast<gl::Context *>(ctx);
12515 EVENT("glGenSamplers", "context = %d, GLsizei count = %d, GLuint *samplers = 0x%016" PRIxPTR "",
12516 CID(context), count, (uintptr_t)samplers);
12517
12518 if (context)
12519 {
12520 ASSERT(context == GetValidGlobalContext());
12521 SamplerID *samplersPacked = FromGL<SamplerID *>(samplers);
12522 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12523 bool isCallValid =
12524 (context->skipValidation() || ValidateGenSamplers(context, count, samplersPacked));
12525 if (isCallValid)
12526 {
12527 context->genSamplers(count, samplersPacked);
12528 }
12529 ANGLE_CAPTURE(GenSamplers, isCallValid, context, count, samplersPacked);
12530 }
12531 }
12532
GenSemaphoresEXTContextANGLE(GLeglContext ctx,GLsizei n,GLuint * semaphores)12533 void GL_APIENTRY GenSemaphoresEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *semaphores)
12534 {
12535 Context *context = static_cast<gl::Context *>(ctx);
12536 EVENT("glGenSemaphoresEXT",
12537 "context = %d, GLsizei n = %d, GLuint *semaphores = 0x%016" PRIxPTR "", CID(context), n,
12538 (uintptr_t)semaphores);
12539
12540 if (context)
12541 {
12542 ASSERT(context == GetValidGlobalContext());
12543 SemaphoreID *semaphoresPacked = FromGL<SemaphoreID *>(semaphores);
12544 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12545 bool isCallValid =
12546 (context->skipValidation() || ValidateGenSemaphoresEXT(context, n, semaphoresPacked));
12547 if (isCallValid)
12548 {
12549 context->genSemaphores(n, semaphoresPacked);
12550 }
12551 ANGLE_CAPTURE(GenSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
12552 }
12553 }
12554
GenTexturesContextANGLE(GLeglContext ctx,GLsizei n,GLuint * textures)12555 void GL_APIENTRY GenTexturesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *textures)
12556 {
12557 Context *context = static_cast<gl::Context *>(ctx);
12558 EVENT("glGenTextures", "context = %d, GLsizei n = %d, GLuint *textures = 0x%016" PRIxPTR "",
12559 CID(context), n, (uintptr_t)textures);
12560
12561 if (context)
12562 {
12563 ASSERT(context == GetValidGlobalContext());
12564 TextureID *texturesPacked = FromGL<TextureID *>(textures);
12565 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12566 bool isCallValid =
12567 (context->skipValidation() || ValidateGenTextures(context, n, texturesPacked));
12568 if (isCallValid)
12569 {
12570 context->genTextures(n, texturesPacked);
12571 }
12572 ANGLE_CAPTURE(GenTextures, isCallValid, context, n, texturesPacked);
12573 }
12574 }
12575
GenTransformFeedbacksContextANGLE(GLeglContext ctx,GLsizei n,GLuint * ids)12576 void GL_APIENTRY GenTransformFeedbacksContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
12577 {
12578 Context *context = static_cast<gl::Context *>(ctx);
12579 EVENT("glGenTransformFeedbacks",
12580 "context = %d, GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
12581 (uintptr_t)ids);
12582
12583 if (context)
12584 {
12585 ASSERT(context == GetValidGlobalContext());
12586 TransformFeedbackID *idsPacked = FromGL<TransformFeedbackID *>(ids);
12587 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12588 bool isCallValid =
12589 (context->skipValidation() || ValidateGenTransformFeedbacks(context, n, idsPacked));
12590 if (isCallValid)
12591 {
12592 context->genTransformFeedbacks(n, idsPacked);
12593 }
12594 ANGLE_CAPTURE(GenTransformFeedbacks, isCallValid, context, n, idsPacked);
12595 }
12596 }
12597
GenVertexArraysContextANGLE(GLeglContext ctx,GLsizei n,GLuint * arrays)12598 void GL_APIENTRY GenVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
12599 {
12600 Context *context = static_cast<gl::Context *>(ctx);
12601 EVENT("glGenVertexArrays", "context = %d, GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR "",
12602 CID(context), n, (uintptr_t)arrays);
12603
12604 if (context)
12605 {
12606 ASSERT(context == GetValidGlobalContext());
12607 VertexArrayID *arraysPacked = FromGL<VertexArrayID *>(arrays);
12608 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12609 bool isCallValid =
12610 (context->skipValidation() || ValidateGenVertexArrays(context, n, arraysPacked));
12611 if (isCallValid)
12612 {
12613 context->genVertexArrays(n, arraysPacked);
12614 }
12615 ANGLE_CAPTURE(GenVertexArrays, isCallValid, context, n, arraysPacked);
12616 }
12617 }
12618
GenVertexArraysOESContextANGLE(GLeglContext ctx,GLsizei n,GLuint * arrays)12619 void GL_APIENTRY GenVertexArraysOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
12620 {
12621 Context *context = static_cast<gl::Context *>(ctx);
12622 EVENT("glGenVertexArraysOES",
12623 "context = %d, GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR "", CID(context), n,
12624 (uintptr_t)arrays);
12625
12626 if (context)
12627 {
12628 ASSERT(context == GetValidGlobalContext());
12629 VertexArrayID *arraysPacked = FromGL<VertexArrayID *>(arrays);
12630 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12631 bool isCallValid =
12632 (context->skipValidation() || ValidateGenVertexArraysOES(context, n, arraysPacked));
12633 if (isCallValid)
12634 {
12635 context->genVertexArrays(n, arraysPacked);
12636 }
12637 ANGLE_CAPTURE(GenVertexArraysOES, isCallValid, context, n, arraysPacked);
12638 }
12639 }
12640
GenerateMipmapContextANGLE(GLeglContext ctx,GLenum target)12641 void GL_APIENTRY GenerateMipmapContextANGLE(GLeglContext ctx, GLenum target)
12642 {
12643 Context *context = static_cast<gl::Context *>(ctx);
12644 EVENT("glGenerateMipmap", "context = %d, GLenum target = %s", CID(context),
12645 GLenumToString(GLenumGroup::TextureTarget, target));
12646
12647 if (context)
12648 {
12649 ASSERT(context == GetValidGlobalContext());
12650 TextureType targetPacked = FromGL<TextureType>(target);
12651 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12652 bool isCallValid =
12653 (context->skipValidation() || ValidateGenerateMipmap(context, targetPacked));
12654 if (isCallValid)
12655 {
12656 context->generateMipmap(targetPacked);
12657 }
12658 ANGLE_CAPTURE(GenerateMipmap, isCallValid, context, targetPacked);
12659 }
12660 }
12661
GenerateMipmapOESContextANGLE(GLeglContext ctx,GLenum target)12662 void GL_APIENTRY GenerateMipmapOESContextANGLE(GLeglContext ctx, GLenum target)
12663 {
12664 Context *context = static_cast<gl::Context *>(ctx);
12665 EVENT("glGenerateMipmapOES", "context = %d, GLenum target = %s", CID(context),
12666 GLenumToString(GLenumGroup::TextureTarget, target));
12667
12668 if (context)
12669 {
12670 ASSERT(context == GetValidGlobalContext());
12671 TextureType targetPacked = FromGL<TextureType>(target);
12672 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12673 bool isCallValid =
12674 (context->skipValidation() || ValidateGenerateMipmapOES(context, targetPacked));
12675 if (isCallValid)
12676 {
12677 context->generateMipmap(targetPacked);
12678 }
12679 ANGLE_CAPTURE(GenerateMipmapOES, isCallValid, context, targetPacked);
12680 }
12681 }
12682
GetActiveAttribContextANGLE(GLeglContext ctx,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)12683 void GL_APIENTRY GetActiveAttribContextANGLE(GLeglContext ctx,
12684 GLuint program,
12685 GLuint index,
12686 GLsizei bufSize,
12687 GLsizei *length,
12688 GLint *size,
12689 GLenum *type,
12690 GLchar *name)
12691 {
12692 Context *context = static_cast<gl::Context *>(ctx);
12693 EVENT("glGetActiveAttrib",
12694 "context = %d, GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei "
12695 "*length = 0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR
12696 ", GLenum *type = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
12697 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
12698 (uintptr_t)type, (uintptr_t)name);
12699
12700 if (context)
12701 {
12702 ASSERT(context == GetValidGlobalContext());
12703 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12704 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12705 bool isCallValid = (context->skipValidation() ||
12706 ValidateGetActiveAttrib(context, programPacked, index, bufSize, length,
12707 size, type, name));
12708 if (isCallValid)
12709 {
12710 context->getActiveAttrib(programPacked, index, bufSize, length, size, type, name);
12711 }
12712 ANGLE_CAPTURE(GetActiveAttrib, isCallValid, context, programPacked, index, bufSize, length,
12713 size, type, name);
12714 }
12715 }
12716
GetActiveUniformContextANGLE(GLeglContext ctx,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)12717 void GL_APIENTRY GetActiveUniformContextANGLE(GLeglContext ctx,
12718 GLuint program,
12719 GLuint index,
12720 GLsizei bufSize,
12721 GLsizei *length,
12722 GLint *size,
12723 GLenum *type,
12724 GLchar *name)
12725 {
12726 Context *context = static_cast<gl::Context *>(ctx);
12727 EVENT("glGetActiveUniform",
12728 "context = %d, GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei "
12729 "*length = 0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR
12730 ", GLenum *type = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
12731 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
12732 (uintptr_t)type, (uintptr_t)name);
12733
12734 if (context)
12735 {
12736 ASSERT(context == GetValidGlobalContext());
12737 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12738 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12739 bool isCallValid = (context->skipValidation() ||
12740 ValidateGetActiveUniform(context, programPacked, index, bufSize, length,
12741 size, type, name));
12742 if (isCallValid)
12743 {
12744 context->getActiveUniform(programPacked, index, bufSize, length, size, type, name);
12745 }
12746 ANGLE_CAPTURE(GetActiveUniform, isCallValid, context, programPacked, index, bufSize, length,
12747 size, type, name);
12748 }
12749 }
12750
GetActiveUniformBlockNameContextANGLE(GLeglContext ctx,GLuint program,GLuint uniformBlockIndex,GLsizei bufSize,GLsizei * length,GLchar * uniformBlockName)12751 void GL_APIENTRY GetActiveUniformBlockNameContextANGLE(GLeglContext ctx,
12752 GLuint program,
12753 GLuint uniformBlockIndex,
12754 GLsizei bufSize,
12755 GLsizei *length,
12756 GLchar *uniformBlockName)
12757 {
12758 Context *context = static_cast<gl::Context *>(ctx);
12759 EVENT("glGetActiveUniformBlockName",
12760 "context = %d, GLuint program = %u, GLuint uniformBlockIndex = %u, GLsizei bufSize = %d, "
12761 "GLsizei *length = 0x%016" PRIxPTR ", GLchar *uniformBlockName = 0x%016" PRIxPTR "",
12762 CID(context), program, uniformBlockIndex, bufSize, (uintptr_t)length,
12763 (uintptr_t)uniformBlockName);
12764
12765 if (context)
12766 {
12767 ASSERT(context == GetValidGlobalContext());
12768 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12769 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12770 bool isCallValid =
12771 (context->skipValidation() ||
12772 ValidateGetActiveUniformBlockName(context, programPacked, uniformBlockIndex, bufSize,
12773 length, uniformBlockName));
12774 if (isCallValid)
12775 {
12776 context->getActiveUniformBlockName(programPacked, uniformBlockIndex, bufSize, length,
12777 uniformBlockName);
12778 }
12779 ANGLE_CAPTURE(GetActiveUniformBlockName, isCallValid, context, programPacked,
12780 uniformBlockIndex, bufSize, length, uniformBlockName);
12781 }
12782 }
12783
GetActiveUniformBlockivContextANGLE(GLeglContext ctx,GLuint program,GLuint uniformBlockIndex,GLenum pname,GLint * params)12784 void GL_APIENTRY GetActiveUniformBlockivContextANGLE(GLeglContext ctx,
12785 GLuint program,
12786 GLuint uniformBlockIndex,
12787 GLenum pname,
12788 GLint *params)
12789 {
12790 Context *context = static_cast<gl::Context *>(ctx);
12791 EVENT("glGetActiveUniformBlockiv",
12792 "context = %d, GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = %s, "
12793 "GLint *params = 0x%016" PRIxPTR "",
12794 CID(context), program, uniformBlockIndex,
12795 GLenumToString(GLenumGroup::UniformBlockPName, pname), (uintptr_t)params);
12796
12797 if (context)
12798 {
12799 ASSERT(context == GetValidGlobalContext());
12800 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12801 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12802 bool isCallValid = (context->skipValidation() ||
12803 ValidateGetActiveUniformBlockiv(context, programPacked,
12804 uniformBlockIndex, pname, params));
12805 if (isCallValid)
12806 {
12807 context->getActiveUniformBlockiv(programPacked, uniformBlockIndex, pname, params);
12808 }
12809 ANGLE_CAPTURE(GetActiveUniformBlockiv, isCallValid, context, programPacked,
12810 uniformBlockIndex, pname, params);
12811 }
12812 }
12813
GetActiveUniformsivContextANGLE(GLeglContext ctx,GLuint program,GLsizei uniformCount,const GLuint * uniformIndices,GLenum pname,GLint * params)12814 void GL_APIENTRY GetActiveUniformsivContextANGLE(GLeglContext ctx,
12815 GLuint program,
12816 GLsizei uniformCount,
12817 const GLuint *uniformIndices,
12818 GLenum pname,
12819 GLint *params)
12820 {
12821 Context *context = static_cast<gl::Context *>(ctx);
12822 EVENT("glGetActiveUniformsiv",
12823 "context = %d, GLuint program = %u, GLsizei uniformCount = %d, const GLuint "
12824 "*uniformIndices = 0x%016" PRIxPTR ", GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
12825 "",
12826 CID(context), program, uniformCount, (uintptr_t)uniformIndices,
12827 GLenumToString(GLenumGroup::UniformPName, pname), (uintptr_t)params);
12828
12829 if (context)
12830 {
12831 ASSERT(context == GetValidGlobalContext());
12832 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12833 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12834 bool isCallValid = (context->skipValidation() ||
12835 ValidateGetActiveUniformsiv(context, programPacked, uniformCount,
12836 uniformIndices, pname, params));
12837 if (isCallValid)
12838 {
12839 context->getActiveUniformsiv(programPacked, uniformCount, uniformIndices, pname,
12840 params);
12841 }
12842 ANGLE_CAPTURE(GetActiveUniformsiv, isCallValid, context, programPacked, uniformCount,
12843 uniformIndices, pname, params);
12844 }
12845 }
12846
GetAttachedShadersContextANGLE(GLeglContext ctx,GLuint program,GLsizei maxCount,GLsizei * count,GLuint * shaders)12847 void GL_APIENTRY GetAttachedShadersContextANGLE(GLeglContext ctx,
12848 GLuint program,
12849 GLsizei maxCount,
12850 GLsizei *count,
12851 GLuint *shaders)
12852 {
12853 Context *context = static_cast<gl::Context *>(ctx);
12854 EVENT(
12855 "glGetAttachedShaders",
12856 "context = %d, GLuint program = %u, GLsizei maxCount = %d, GLsizei *count = 0x%016" PRIxPTR
12857 ", GLuint *shaders = 0x%016" PRIxPTR "",
12858 CID(context), program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
12859
12860 if (context)
12861 {
12862 ASSERT(context == GetValidGlobalContext());
12863 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12864 ShaderProgramID *shadersPacked = FromGL<ShaderProgramID *>(shaders);
12865 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12866 bool isCallValid =
12867 (context->skipValidation() ||
12868 ValidateGetAttachedShaders(context, programPacked, maxCount, count, shadersPacked));
12869 if (isCallValid)
12870 {
12871 context->getAttachedShaders(programPacked, maxCount, count, shadersPacked);
12872 }
12873 ANGLE_CAPTURE(GetAttachedShaders, isCallValid, context, programPacked, maxCount, count,
12874 shadersPacked);
12875 }
12876 }
12877
GetAttribLocationContextANGLE(GLeglContext ctx,GLuint program,const GLchar * name)12878 GLint GL_APIENTRY GetAttribLocationContextANGLE(GLeglContext ctx,
12879 GLuint program,
12880 const GLchar *name)
12881 {
12882 Context *context = static_cast<gl::Context *>(ctx);
12883 EVENT("glGetAttribLocation",
12884 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
12885 program, (uintptr_t)name);
12886
12887 GLint returnValue;
12888 if (context)
12889 {
12890 ASSERT(context == GetValidGlobalContext());
12891 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
12892 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12893 bool isCallValid =
12894 (context->skipValidation() || ValidateGetAttribLocation(context, programPacked, name));
12895 if (isCallValid)
12896 {
12897 returnValue = context->getAttribLocation(programPacked, name);
12898 }
12899 else
12900 {
12901 returnValue = GetDefaultReturnValue<EntryPoint::GetAttribLocation, GLint>();
12902 }
12903 ANGLE_CAPTURE(GetAttribLocation, isCallValid, context, programPacked, name, returnValue);
12904 }
12905 else
12906 {
12907 returnValue = GetDefaultReturnValue<EntryPoint::GetAttribLocation, GLint>();
12908 }
12909 return returnValue;
12910 }
12911
GetBooleani_vContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLboolean * data)12912 void GL_APIENTRY GetBooleani_vContextANGLE(GLeglContext ctx,
12913 GLenum target,
12914 GLuint index,
12915 GLboolean *data)
12916 {
12917 Context *context = static_cast<gl::Context *>(ctx);
12918 EVENT(
12919 "glGetBooleani_v",
12920 "context = %d, GLenum target = %s, GLuint index = %u, GLboolean *data = 0x%016" PRIxPTR "",
12921 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, (uintptr_t)data);
12922
12923 if (context)
12924 {
12925 ASSERT(context == GetValidGlobalContext());
12926 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12927 bool isCallValid =
12928 (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data));
12929 if (isCallValid)
12930 {
12931 context->getBooleani_v(target, index, data);
12932 }
12933 ANGLE_CAPTURE(GetBooleani_v, isCallValid, context, target, index, data);
12934 }
12935 }
12936
GetBooleanvContextANGLE(GLeglContext ctx,GLenum pname,GLboolean * data)12937 void GL_APIENTRY GetBooleanvContextANGLE(GLeglContext ctx, GLenum pname, GLboolean *data)
12938 {
12939 Context *context = static_cast<gl::Context *>(ctx);
12940 EVENT("glGetBooleanv", "context = %d, GLenum pname = %s, GLboolean *data = 0x%016" PRIxPTR "",
12941 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
12942
12943 if (context)
12944 {
12945 ASSERT(context == GetValidGlobalContext());
12946 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12947 bool isCallValid = (context->skipValidation() || ValidateGetBooleanv(context, pname, data));
12948 if (isCallValid)
12949 {
12950 context->getBooleanv(pname, data);
12951 }
12952 ANGLE_CAPTURE(GetBooleanv, isCallValid, context, pname, data);
12953 }
12954 }
12955
GetBufferParameteri64vContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint64 * params)12956 void GL_APIENTRY GetBufferParameteri64vContextANGLE(GLeglContext ctx,
12957 GLenum target,
12958 GLenum pname,
12959 GLint64 *params)
12960 {
12961 Context *context = static_cast<gl::Context *>(ctx);
12962 EVENT("glGetBufferParameteri64v",
12963 "context = %d, GLenum target = %s, GLenum pname = %s, GLint64 *params = 0x%016" PRIxPTR
12964 "",
12965 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
12966 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
12967
12968 if (context)
12969 {
12970 ASSERT(context == GetValidGlobalContext());
12971 BufferBinding targetPacked = FromGL<BufferBinding>(target);
12972 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12973 bool isCallValid = (context->skipValidation() ||
12974 ValidateGetBufferParameteri64v(context, targetPacked, pname, params));
12975 if (isCallValid)
12976 {
12977 context->getBufferParameteri64v(targetPacked, pname, params);
12978 }
12979 ANGLE_CAPTURE(GetBufferParameteri64v, isCallValid, context, targetPacked, pname, params);
12980 }
12981 }
12982
GetBufferParameterivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)12983 void GL_APIENTRY GetBufferParameterivContextANGLE(GLeglContext ctx,
12984 GLenum target,
12985 GLenum pname,
12986 GLint *params)
12987 {
12988 Context *context = static_cast<gl::Context *>(ctx);
12989 EVENT("glGetBufferParameteriv",
12990 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
12991 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
12992 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
12993
12994 if (context)
12995 {
12996 ASSERT(context == GetValidGlobalContext());
12997 BufferBinding targetPacked = FromGL<BufferBinding>(target);
12998 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
12999 bool isCallValid = (context->skipValidation() ||
13000 ValidateGetBufferParameteriv(context, targetPacked, pname, params));
13001 if (isCallValid)
13002 {
13003 context->getBufferParameteriv(targetPacked, pname, params);
13004 }
13005 ANGLE_CAPTURE(GetBufferParameteriv, isCallValid, context, targetPacked, pname, params);
13006 }
13007 }
13008
GetBufferPointervContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,void ** params)13009 void GL_APIENTRY GetBufferPointervContextANGLE(GLeglContext ctx,
13010 GLenum target,
13011 GLenum pname,
13012 void **params)
13013 {
13014 Context *context = static_cast<gl::Context *>(ctx);
13015 EVENT("glGetBufferPointerv",
13016 "context = %d, GLenum target = %s, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
13017 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
13018 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
13019
13020 if (context)
13021 {
13022 ASSERT(context == GetValidGlobalContext());
13023 BufferBinding targetPacked = FromGL<BufferBinding>(target);
13024 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13025 bool isCallValid = (context->skipValidation() ||
13026 ValidateGetBufferPointerv(context, targetPacked, pname, params));
13027 if (isCallValid)
13028 {
13029 context->getBufferPointerv(targetPacked, pname, params);
13030 }
13031 ANGLE_CAPTURE(GetBufferPointerv, isCallValid, context, targetPacked, pname, params);
13032 }
13033 }
13034
GetBufferPointervOESContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,void ** params)13035 void GL_APIENTRY GetBufferPointervOESContextANGLE(GLeglContext ctx,
13036 GLenum target,
13037 GLenum pname,
13038 void **params)
13039 {
13040 Context *context = static_cast<gl::Context *>(ctx);
13041 EVENT("glGetBufferPointervOES",
13042 "context = %d, GLenum target = %s, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
13043 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
13044 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
13045
13046 if (context)
13047 {
13048 ASSERT(context == GetValidGlobalContext());
13049 BufferBinding targetPacked = FromGL<BufferBinding>(target);
13050 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13051 bool isCallValid = (context->skipValidation() ||
13052 ValidateGetBufferPointervOES(context, targetPacked, pname, params));
13053 if (isCallValid)
13054 {
13055 context->getBufferPointerv(targetPacked, pname, params);
13056 }
13057 ANGLE_CAPTURE(GetBufferPointervOES, isCallValid, context, targetPacked, pname, params);
13058 }
13059 }
13060
GetClipPlanefContextANGLE(GLeglContext ctx,GLenum plane,GLfloat * equation)13061 void GL_APIENTRY GetClipPlanefContextANGLE(GLeglContext ctx, GLenum plane, GLfloat *equation)
13062 {
13063 Context *context = static_cast<gl::Context *>(ctx);
13064 EVENT("glGetClipPlanef",
13065 "context = %d, GLenum plane = %s, GLfloat *equation = 0x%016" PRIxPTR "", CID(context),
13066 GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
13067
13068 if (context)
13069 {
13070 ASSERT(context == GetValidGlobalContext());
13071 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13072 bool isCallValid =
13073 (context->skipValidation() || ValidateGetClipPlanef(context, plane, equation));
13074 if (isCallValid)
13075 {
13076 context->getClipPlanef(plane, equation);
13077 }
13078 ANGLE_CAPTURE(GetClipPlanef, isCallValid, context, plane, equation);
13079 }
13080 }
13081
GetClipPlanexContextANGLE(GLeglContext ctx,GLenum plane,GLfixed * equation)13082 void GL_APIENTRY GetClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, GLfixed *equation)
13083 {
13084 Context *context = static_cast<gl::Context *>(ctx);
13085 EVENT("glGetClipPlanex",
13086 "context = %d, GLenum plane = %s, GLfixed *equation = 0x%016" PRIxPTR "", CID(context),
13087 GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
13088
13089 if (context)
13090 {
13091 ASSERT(context == GetValidGlobalContext());
13092 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13093 bool isCallValid =
13094 (context->skipValidation() || ValidateGetClipPlanex(context, plane, equation));
13095 if (isCallValid)
13096 {
13097 context->getClipPlanex(plane, equation);
13098 }
13099 ANGLE_CAPTURE(GetClipPlanex, isCallValid, context, plane, equation);
13100 }
13101 }
13102
GetDebugMessageLogContextANGLE(GLeglContext ctx,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)13103 GLuint GL_APIENTRY GetDebugMessageLogContextANGLE(GLeglContext ctx,
13104 GLuint count,
13105 GLsizei bufSize,
13106 GLenum *sources,
13107 GLenum *types,
13108 GLuint *ids,
13109 GLenum *severities,
13110 GLsizei *lengths,
13111 GLchar *messageLog)
13112 {
13113 Context *context = static_cast<gl::Context *>(ctx);
13114 EVENT("glGetDebugMessageLog",
13115 "context = %d, GLuint count = %u, GLsizei bufSize = %d, GLenum *sources = 0x%016" PRIxPTR
13116 ", GLenum *types = 0x%016" PRIxPTR ", GLuint *ids = 0x%016" PRIxPTR
13117 ", GLenum *severities = 0x%016" PRIxPTR ", GLsizei *lengths = 0x%016" PRIxPTR
13118 ", GLchar *messageLog = 0x%016" PRIxPTR "",
13119 CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
13120 (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
13121
13122 GLuint returnValue;
13123 if (context)
13124 {
13125 ASSERT(context == GetValidGlobalContext());
13126 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13127 bool isCallValid = (context->skipValidation() ||
13128 ValidateGetDebugMessageLog(context, count, bufSize, sources, types, ids,
13129 severities, lengths, messageLog));
13130 if (isCallValid)
13131 {
13132 returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
13133 severities, lengths, messageLog);
13134 }
13135 else
13136 {
13137 returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLog, GLuint>();
13138 }
13139 ANGLE_CAPTURE(GetDebugMessageLog, isCallValid, context, count, bufSize, sources, types, ids,
13140 severities, lengths, messageLog, returnValue);
13141 }
13142 else
13143 {
13144 returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLog, GLuint>();
13145 }
13146 return returnValue;
13147 }
13148
GetDebugMessageLogKHRContextANGLE(GLeglContext ctx,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)13149 GLuint GL_APIENTRY GetDebugMessageLogKHRContextANGLE(GLeglContext ctx,
13150 GLuint count,
13151 GLsizei bufSize,
13152 GLenum *sources,
13153 GLenum *types,
13154 GLuint *ids,
13155 GLenum *severities,
13156 GLsizei *lengths,
13157 GLchar *messageLog)
13158 {
13159 Context *context = static_cast<gl::Context *>(ctx);
13160 EVENT("glGetDebugMessageLogKHR",
13161 "context = %d, GLuint count = %u, GLsizei bufSize = %d, GLenum *sources = 0x%016" PRIxPTR
13162 ", GLenum *types = 0x%016" PRIxPTR ", GLuint *ids = 0x%016" PRIxPTR
13163 ", GLenum *severities = 0x%016" PRIxPTR ", GLsizei *lengths = 0x%016" PRIxPTR
13164 ", GLchar *messageLog = 0x%016" PRIxPTR "",
13165 CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
13166 (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
13167
13168 GLuint returnValue;
13169 if (context)
13170 {
13171 ASSERT(context == GetValidGlobalContext());
13172 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13173 bool isCallValid = (context->skipValidation() ||
13174 ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types,
13175 ids, severities, lengths, messageLog));
13176 if (isCallValid)
13177 {
13178 returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
13179 severities, lengths, messageLog);
13180 }
13181 else
13182 {
13183 returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLogKHR, GLuint>();
13184 }
13185 ANGLE_CAPTURE(GetDebugMessageLogKHR, isCallValid, context, count, bufSize, sources, types,
13186 ids, severities, lengths, messageLog, returnValue);
13187 }
13188 else
13189 {
13190 returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLogKHR, GLuint>();
13191 }
13192 return returnValue;
13193 }
13194
GetErrorContextANGLE(GLeglContext ctx)13195 GLenum GL_APIENTRY GetErrorContextANGLE(GLeglContext ctx)
13196 {
13197 Context *context = static_cast<gl::Context *>(ctx);
13198 EVENT("glGetError", "context = %d", CID(context));
13199
13200 GLenum returnValue;
13201 if (context)
13202 {
13203 ASSERT(context == GetValidGlobalContext());
13204 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13205 bool isCallValid = (context->skipValidation() || ValidateGetError(context));
13206 if (isCallValid)
13207 {
13208 returnValue = context->getError();
13209 }
13210 else
13211 {
13212 returnValue = GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
13213 }
13214 ANGLE_CAPTURE(GetError, isCallValid, context, returnValue);
13215 }
13216 else
13217 {
13218 returnValue = GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
13219 }
13220 return returnValue;
13221 }
13222
GetFenceivNVContextANGLE(GLeglContext ctx,GLuint fence,GLenum pname,GLint * params)13223 void GL_APIENTRY GetFenceivNVContextANGLE(GLeglContext ctx,
13224 GLuint fence,
13225 GLenum pname,
13226 GLint *params)
13227 {
13228 Context *context = static_cast<gl::Context *>(ctx);
13229 EVENT("glGetFenceivNV",
13230 "context = %d, GLuint fence = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
13231 CID(context), fence, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
13232
13233 if (context)
13234 {
13235 ASSERT(context == GetValidGlobalContext());
13236 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
13237 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13238 bool isCallValid = (context->skipValidation() ||
13239 ValidateGetFenceivNV(context, fencePacked, pname, params));
13240 if (isCallValid)
13241 {
13242 context->getFenceivNV(fencePacked, pname, params);
13243 }
13244 ANGLE_CAPTURE(GetFenceivNV, isCallValid, context, fencePacked, pname, params);
13245 }
13246 }
13247
GetFixedvContextANGLE(GLeglContext ctx,GLenum pname,GLfixed * params)13248 void GL_APIENTRY GetFixedvContextANGLE(GLeglContext ctx, GLenum pname, GLfixed *params)
13249 {
13250 Context *context = static_cast<gl::Context *>(ctx);
13251 EVENT("glGetFixedv", "context = %d, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR "",
13252 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)params);
13253
13254 if (context)
13255 {
13256 ASSERT(context == GetValidGlobalContext());
13257 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13258 bool isCallValid = (context->skipValidation() || ValidateGetFixedv(context, pname, params));
13259 if (isCallValid)
13260 {
13261 context->getFixedv(pname, params);
13262 }
13263 ANGLE_CAPTURE(GetFixedv, isCallValid, context, pname, params);
13264 }
13265 }
13266
GetFloatvContextANGLE(GLeglContext ctx,GLenum pname,GLfloat * data)13267 void GL_APIENTRY GetFloatvContextANGLE(GLeglContext ctx, GLenum pname, GLfloat *data)
13268 {
13269 Context *context = static_cast<gl::Context *>(ctx);
13270 EVENT("glGetFloatv", "context = %d, GLenum pname = %s, GLfloat *data = 0x%016" PRIxPTR "",
13271 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
13272
13273 if (context)
13274 {
13275 ASSERT(context == GetValidGlobalContext());
13276 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13277 bool isCallValid = (context->skipValidation() || ValidateGetFloatv(context, pname, data));
13278 if (isCallValid)
13279 {
13280 context->getFloatv(pname, data);
13281 }
13282 ANGLE_CAPTURE(GetFloatv, isCallValid, context, pname, data);
13283 }
13284 }
13285
GetFragDataIndexEXTContextANGLE(GLeglContext ctx,GLuint program,const GLchar * name)13286 GLint GL_APIENTRY GetFragDataIndexEXTContextANGLE(GLeglContext ctx,
13287 GLuint program,
13288 const GLchar *name)
13289 {
13290 Context *context = static_cast<gl::Context *>(ctx);
13291 EVENT("glGetFragDataIndexEXT",
13292 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
13293 program, (uintptr_t)name);
13294
13295 GLint returnValue;
13296 if (context)
13297 {
13298 ASSERT(context == GetValidGlobalContext());
13299 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
13300 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13301 bool isCallValid = (context->skipValidation() ||
13302 ValidateGetFragDataIndexEXT(context, programPacked, name));
13303 if (isCallValid)
13304 {
13305 returnValue = context->getFragDataIndex(programPacked, name);
13306 }
13307 else
13308 {
13309 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataIndexEXT, GLint>();
13310 }
13311 ANGLE_CAPTURE(GetFragDataIndexEXT, isCallValid, context, programPacked, name, returnValue);
13312 }
13313 else
13314 {
13315 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataIndexEXT, GLint>();
13316 }
13317 return returnValue;
13318 }
13319
GetFragDataLocationContextANGLE(GLeglContext ctx,GLuint program,const GLchar * name)13320 GLint GL_APIENTRY GetFragDataLocationContextANGLE(GLeglContext ctx,
13321 GLuint program,
13322 const GLchar *name)
13323 {
13324 Context *context = static_cast<gl::Context *>(ctx);
13325 EVENT("glGetFragDataLocation",
13326 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
13327 program, (uintptr_t)name);
13328
13329 GLint returnValue;
13330 if (context)
13331 {
13332 ASSERT(context == GetValidGlobalContext());
13333 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
13334 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13335 bool isCallValid = (context->skipValidation() ||
13336 ValidateGetFragDataLocation(context, programPacked, name));
13337 if (isCallValid)
13338 {
13339 returnValue = context->getFragDataLocation(programPacked, name);
13340 }
13341 else
13342 {
13343 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataLocation, GLint>();
13344 }
13345 ANGLE_CAPTURE(GetFragDataLocation, isCallValid, context, programPacked, name, returnValue);
13346 }
13347 else
13348 {
13349 returnValue = GetDefaultReturnValue<EntryPoint::GetFragDataLocation, GLint>();
13350 }
13351 return returnValue;
13352 }
13353
GetFramebufferAttachmentParameterivContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum pname,GLint * params)13354 void GL_APIENTRY GetFramebufferAttachmentParameterivContextANGLE(GLeglContext ctx,
13355 GLenum target,
13356 GLenum attachment,
13357 GLenum pname,
13358 GLint *params)
13359 {
13360 Context *context = static_cast<gl::Context *>(ctx);
13361 EVENT("glGetFramebufferAttachmentParameteriv",
13362 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLint "
13363 "*params = 0x%016" PRIxPTR "",
13364 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
13365 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
13366 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
13367 (uintptr_t)params);
13368
13369 if (context)
13370 {
13371 ASSERT(context == GetValidGlobalContext());
13372 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13373 bool isCallValid =
13374 (context->skipValidation() || ValidateGetFramebufferAttachmentParameteriv(
13375 context, target, attachment, pname, params));
13376 if (isCallValid)
13377 {
13378 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
13379 }
13380 ANGLE_CAPTURE(GetFramebufferAttachmentParameteriv, isCallValid, context, target, attachment,
13381 pname, params);
13382 }
13383 }
13384
GetFramebufferAttachmentParameterivOESContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum pname,GLint * params)13385 void GL_APIENTRY GetFramebufferAttachmentParameterivOESContextANGLE(GLeglContext ctx,
13386 GLenum target,
13387 GLenum attachment,
13388 GLenum pname,
13389 GLint *params)
13390 {
13391 Context *context = static_cast<gl::Context *>(ctx);
13392 EVENT("glGetFramebufferAttachmentParameterivOES",
13393 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLint "
13394 "*params = 0x%016" PRIxPTR "",
13395 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
13396 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
13397 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
13398 (uintptr_t)params);
13399
13400 if (context)
13401 {
13402 ASSERT(context == GetValidGlobalContext());
13403 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13404 bool isCallValid =
13405 (context->skipValidation() || ValidateGetFramebufferAttachmentParameterivOES(
13406 context, target, attachment, pname, params));
13407 if (isCallValid)
13408 {
13409 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
13410 }
13411 ANGLE_CAPTURE(GetFramebufferAttachmentParameterivOES, isCallValid, context, target,
13412 attachment, pname, params);
13413 }
13414 }
13415
GetFramebufferParameterivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)13416 void GL_APIENTRY GetFramebufferParameterivContextANGLE(GLeglContext ctx,
13417 GLenum target,
13418 GLenum pname,
13419 GLint *params)
13420 {
13421 Context *context = static_cast<gl::Context *>(ctx);
13422 EVENT("glGetFramebufferParameteriv",
13423 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
13424 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
13425 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
13426 (uintptr_t)params);
13427
13428 if (context)
13429 {
13430 ASSERT(context == GetValidGlobalContext());
13431 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13432 bool isCallValid = (context->skipValidation() ||
13433 ValidateGetFramebufferParameteriv(context, target, pname, params));
13434 if (isCallValid)
13435 {
13436 context->getFramebufferParameteriv(target, pname, params);
13437 }
13438 ANGLE_CAPTURE(GetFramebufferParameteriv, isCallValid, context, target, pname, params);
13439 }
13440 }
13441
GetGraphicsResetStatusContextANGLE(GLeglContext ctx)13442 GLenum GL_APIENTRY GetGraphicsResetStatusContextANGLE(GLeglContext ctx)
13443 {
13444 Context *context = static_cast<gl::Context *>(ctx);
13445 EVENT("glGetGraphicsResetStatus", "context = %d", CID(context));
13446
13447 GLenum returnValue;
13448 if (context)
13449 {
13450 ASSERT(context == GetValidGlobalContext());
13451 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13452 bool isCallValid = (context->skipValidation() || ValidateGetGraphicsResetStatus(context));
13453 if (isCallValid)
13454 {
13455 returnValue = context->getGraphicsResetStatus();
13456 }
13457 else
13458 {
13459 returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatus, GLenum>();
13460 }
13461 ANGLE_CAPTURE(GetGraphicsResetStatus, isCallValid, context, returnValue);
13462 }
13463 else
13464 {
13465 returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatus, GLenum>();
13466 }
13467 return returnValue;
13468 }
13469
GetGraphicsResetStatusEXTContextANGLE(GLeglContext ctx)13470 GLenum GL_APIENTRY GetGraphicsResetStatusEXTContextANGLE(GLeglContext ctx)
13471 {
13472 Context *context = static_cast<gl::Context *>(ctx);
13473 EVENT("glGetGraphicsResetStatusEXT", "context = %d", CID(context));
13474
13475 GLenum returnValue;
13476 if (context)
13477 {
13478 ASSERT(context == GetValidGlobalContext());
13479 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13480 bool isCallValid =
13481 (context->skipValidation() || ValidateGetGraphicsResetStatusEXT(context));
13482 if (isCallValid)
13483 {
13484 returnValue = context->getGraphicsResetStatus();
13485 }
13486 else
13487 {
13488 returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatusEXT, GLenum>();
13489 }
13490 ANGLE_CAPTURE(GetGraphicsResetStatusEXT, isCallValid, context, returnValue);
13491 }
13492 else
13493 {
13494 returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatusEXT, GLenum>();
13495 }
13496 return returnValue;
13497 }
13498
GetInteger64i_vContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLint64 * data)13499 void GL_APIENTRY GetInteger64i_vContextANGLE(GLeglContext ctx,
13500 GLenum target,
13501 GLuint index,
13502 GLint64 *data)
13503 {
13504 Context *context = static_cast<gl::Context *>(ctx);
13505 EVENT("glGetInteger64i_v",
13506 "context = %d, GLenum target = %s, GLuint index = %u, GLint64 *data = 0x%016" PRIxPTR "",
13507 CID(context), GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
13508
13509 if (context)
13510 {
13511 ASSERT(context == GetValidGlobalContext());
13512 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13513 bool isCallValid =
13514 (context->skipValidation() || ValidateGetInteger64i_v(context, target, index, data));
13515 if (isCallValid)
13516 {
13517 context->getInteger64i_v(target, index, data);
13518 }
13519 ANGLE_CAPTURE(GetInteger64i_v, isCallValid, context, target, index, data);
13520 }
13521 }
13522
GetInteger64vContextANGLE(GLeglContext ctx,GLenum pname,GLint64 * data)13523 void GL_APIENTRY GetInteger64vContextANGLE(GLeglContext ctx, GLenum pname, GLint64 *data)
13524 {
13525 Context *context = static_cast<gl::Context *>(ctx);
13526 EVENT("glGetInteger64v", "context = %d, GLenum pname = %s, GLint64 *data = 0x%016" PRIxPTR "",
13527 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
13528
13529 if (context)
13530 {
13531 ASSERT(context == GetValidGlobalContext());
13532 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13533 bool isCallValid =
13534 (context->skipValidation() || ValidateGetInteger64v(context, pname, data));
13535 if (isCallValid)
13536 {
13537 context->getInteger64v(pname, data);
13538 }
13539 ANGLE_CAPTURE(GetInteger64v, isCallValid, context, pname, data);
13540 }
13541 }
13542
GetInteger64vEXTContextANGLE(GLeglContext ctx,GLenum pname,GLint64 * data)13543 void GL_APIENTRY GetInteger64vEXTContextANGLE(GLeglContext ctx, GLenum pname, GLint64 *data)
13544 {
13545 Context *context = static_cast<gl::Context *>(ctx);
13546 EVENT("glGetInteger64vEXT",
13547 "context = %d, GLenum pname = %s, GLint64 *data = 0x%016" PRIxPTR "", CID(context),
13548 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
13549
13550 if (context)
13551 {
13552 ASSERT(context == GetValidGlobalContext());
13553 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13554 bool isCallValid =
13555 (context->skipValidation() || ValidateGetInteger64vEXT(context, pname, data));
13556 if (isCallValid)
13557 {
13558 context->getInteger64v(pname, data);
13559 }
13560 ANGLE_CAPTURE(GetInteger64vEXT, isCallValid, context, pname, data);
13561 }
13562 }
13563
GetIntegeri_vContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLint * data)13564 void GL_APIENTRY GetIntegeri_vContextANGLE(GLeglContext ctx,
13565 GLenum target,
13566 GLuint index,
13567 GLint *data)
13568 {
13569 Context *context = static_cast<gl::Context *>(ctx);
13570 EVENT("glGetIntegeri_v",
13571 "context = %d, GLenum target = %s, GLuint index = %u, GLint *data = 0x%016" PRIxPTR "",
13572 CID(context), GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
13573
13574 if (context)
13575 {
13576 ASSERT(context == GetValidGlobalContext());
13577 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13578 bool isCallValid =
13579 (context->skipValidation() || ValidateGetIntegeri_v(context, target, index, data));
13580 if (isCallValid)
13581 {
13582 context->getIntegeri_v(target, index, data);
13583 }
13584 ANGLE_CAPTURE(GetIntegeri_v, isCallValid, context, target, index, data);
13585 }
13586 }
13587
GetIntegervContextANGLE(GLeglContext ctx,GLenum pname,GLint * data)13588 void GL_APIENTRY GetIntegervContextANGLE(GLeglContext ctx, GLenum pname, GLint *data)
13589 {
13590 Context *context = static_cast<gl::Context *>(ctx);
13591 EVENT("glGetIntegerv", "context = %d, GLenum pname = %s, GLint *data = 0x%016" PRIxPTR "",
13592 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
13593
13594 if (context)
13595 {
13596 ASSERT(context == GetValidGlobalContext());
13597 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13598 bool isCallValid = (context->skipValidation() || ValidateGetIntegerv(context, pname, data));
13599 if (isCallValid)
13600 {
13601 context->getIntegerv(pname, data);
13602 }
13603 ANGLE_CAPTURE(GetIntegerv, isCallValid, context, pname, data);
13604 }
13605 }
13606
GetInternalformativContextANGLE(GLeglContext ctx,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint * params)13607 void GL_APIENTRY GetInternalformativContextANGLE(GLeglContext ctx,
13608 GLenum target,
13609 GLenum internalformat,
13610 GLenum pname,
13611 GLsizei bufSize,
13612 GLint *params)
13613 {
13614 Context *context = static_cast<gl::Context *>(ctx);
13615 EVENT("glGetInternalformativ",
13616 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLenum pname = %s, "
13617 "GLsizei bufSize = %d, GLint *params = 0x%016" PRIxPTR "",
13618 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
13619 GLenumToString(GLenumGroup::InternalFormat, internalformat),
13620 GLenumToString(GLenumGroup::InternalFormatPName, pname), bufSize, (uintptr_t)params);
13621
13622 if (context)
13623 {
13624 ASSERT(context == GetValidGlobalContext());
13625 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13626 bool isCallValid =
13627 (context->skipValidation() ||
13628 ValidateGetInternalformativ(context, target, internalformat, pname, bufSize, params));
13629 if (isCallValid)
13630 {
13631 context->getInternalformativ(target, internalformat, pname, bufSize, params);
13632 }
13633 ANGLE_CAPTURE(GetInternalformativ, isCallValid, context, target, internalformat, pname,
13634 bufSize, params);
13635 }
13636 }
13637
GetLightfvContextANGLE(GLeglContext ctx,GLenum light,GLenum pname,GLfloat * params)13638 void GL_APIENTRY GetLightfvContextANGLE(GLeglContext ctx,
13639 GLenum light,
13640 GLenum pname,
13641 GLfloat *params)
13642 {
13643 Context *context = static_cast<gl::Context *>(ctx);
13644 EVENT("glGetLightfv",
13645 "context = %d, GLenum light = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
13646 CID(context), GLenumToString(GLenumGroup::LightName, light),
13647 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
13648
13649 if (context)
13650 {
13651 ASSERT(context == GetValidGlobalContext());
13652 LightParameter pnamePacked = FromGL<LightParameter>(pname);
13653 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13654 bool isCallValid =
13655 (context->skipValidation() || ValidateGetLightfv(context, light, pnamePacked, params));
13656 if (isCallValid)
13657 {
13658 context->getLightfv(light, pnamePacked, params);
13659 }
13660 ANGLE_CAPTURE(GetLightfv, isCallValid, context, light, pnamePacked, params);
13661 }
13662 }
13663
GetLightxvContextANGLE(GLeglContext ctx,GLenum light,GLenum pname,GLfixed * params)13664 void GL_APIENTRY GetLightxvContextANGLE(GLeglContext ctx,
13665 GLenum light,
13666 GLenum pname,
13667 GLfixed *params)
13668 {
13669 Context *context = static_cast<gl::Context *>(ctx);
13670 EVENT("glGetLightxv",
13671 "context = %d, GLenum light = %s, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR "",
13672 CID(context), GLenumToString(GLenumGroup::LightName, light),
13673 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
13674
13675 if (context)
13676 {
13677 ASSERT(context == GetValidGlobalContext());
13678 LightParameter pnamePacked = FromGL<LightParameter>(pname);
13679 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13680 bool isCallValid =
13681 (context->skipValidation() || ValidateGetLightxv(context, light, pnamePacked, params));
13682 if (isCallValid)
13683 {
13684 context->getLightxv(light, pnamePacked, params);
13685 }
13686 ANGLE_CAPTURE(GetLightxv, isCallValid, context, light, pnamePacked, params);
13687 }
13688 }
13689
GetMaterialfvContextANGLE(GLeglContext ctx,GLenum face,GLenum pname,GLfloat * params)13690 void GL_APIENTRY GetMaterialfvContextANGLE(GLeglContext ctx,
13691 GLenum face,
13692 GLenum pname,
13693 GLfloat *params)
13694 {
13695 Context *context = static_cast<gl::Context *>(ctx);
13696 EVENT("glGetMaterialfv",
13697 "context = %d, GLenum face = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
13698 CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
13699 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
13700
13701 if (context)
13702 {
13703 ASSERT(context == GetValidGlobalContext());
13704 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
13705 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13706 bool isCallValid = (context->skipValidation() ||
13707 ValidateGetMaterialfv(context, face, pnamePacked, params));
13708 if (isCallValid)
13709 {
13710 context->getMaterialfv(face, pnamePacked, params);
13711 }
13712 ANGLE_CAPTURE(GetMaterialfv, isCallValid, context, face, pnamePacked, params);
13713 }
13714 }
13715
GetMaterialxvContextANGLE(GLeglContext ctx,GLenum face,GLenum pname,GLfixed * params)13716 void GL_APIENTRY GetMaterialxvContextANGLE(GLeglContext ctx,
13717 GLenum face,
13718 GLenum pname,
13719 GLfixed *params)
13720 {
13721 Context *context = static_cast<gl::Context *>(ctx);
13722 EVENT("glGetMaterialxv",
13723 "context = %d, GLenum face = %s, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR "",
13724 CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
13725 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
13726
13727 if (context)
13728 {
13729 ASSERT(context == GetValidGlobalContext());
13730 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
13731 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13732 bool isCallValid = (context->skipValidation() ||
13733 ValidateGetMaterialxv(context, face, pnamePacked, params));
13734 if (isCallValid)
13735 {
13736 context->getMaterialxv(face, pnamePacked, params);
13737 }
13738 ANGLE_CAPTURE(GetMaterialxv, isCallValid, context, face, pnamePacked, params);
13739 }
13740 }
13741
GetMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,GLuint memoryObject,GLenum pname,GLint * params)13742 void GL_APIENTRY GetMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
13743 GLuint memoryObject,
13744 GLenum pname,
13745 GLint *params)
13746 {
13747 Context *context = static_cast<gl::Context *>(ctx);
13748 EVENT(
13749 "glGetMemoryObjectParameterivEXT",
13750 "context = %d, GLuint memoryObject = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
13751 "",
13752 CID(context), memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
13753 (uintptr_t)params);
13754
13755 if (context)
13756 {
13757 ASSERT(context == GetValidGlobalContext());
13758 MemoryObjectID memoryObjectPacked = FromGL<MemoryObjectID>(memoryObject);
13759 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13760 bool isCallValid =
13761 (context->skipValidation() ||
13762 ValidateGetMemoryObjectParameterivEXT(context, memoryObjectPacked, pname, params));
13763 if (isCallValid)
13764 {
13765 context->getMemoryObjectParameteriv(memoryObjectPacked, pname, params);
13766 }
13767 ANGLE_CAPTURE(GetMemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked,
13768 pname, params);
13769 }
13770 }
13771
GetMultisamplefvContextANGLE(GLeglContext ctx,GLenum pname,GLuint index,GLfloat * val)13772 void GL_APIENTRY GetMultisamplefvContextANGLE(GLeglContext ctx,
13773 GLenum pname,
13774 GLuint index,
13775 GLfloat *val)
13776 {
13777 Context *context = static_cast<gl::Context *>(ctx);
13778 EVENT("glGetMultisamplefv",
13779 "context = %d, GLenum pname = %s, GLuint index = %u, GLfloat *val = 0x%016" PRIxPTR "",
13780 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
13781
13782 if (context)
13783 {
13784 ASSERT(context == GetValidGlobalContext());
13785 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13786 bool isCallValid =
13787 (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val));
13788 if (isCallValid)
13789 {
13790 context->getMultisamplefv(pname, index, val);
13791 }
13792 ANGLE_CAPTURE(GetMultisamplefv, isCallValid, context, pname, index, val);
13793 }
13794 }
13795
GetObjectLabelContextANGLE(GLeglContext ctx,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)13796 void GL_APIENTRY GetObjectLabelContextANGLE(GLeglContext ctx,
13797 GLenum identifier,
13798 GLuint name,
13799 GLsizei bufSize,
13800 GLsizei *length,
13801 GLchar *label)
13802 {
13803 Context *context = static_cast<gl::Context *>(ctx);
13804 EVENT("glGetObjectLabel",
13805 "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei bufSize = %d, GLsizei "
13806 "*length = 0x%016" PRIxPTR ", GLchar *label = 0x%016" PRIxPTR "",
13807 CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize,
13808 (uintptr_t)length, (uintptr_t)label);
13809
13810 if (context)
13811 {
13812 ASSERT(context == GetValidGlobalContext());
13813 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13814 bool isCallValid =
13815 (context->skipValidation() ||
13816 ValidateGetObjectLabel(context, identifier, name, bufSize, length, label));
13817 if (isCallValid)
13818 {
13819 context->getObjectLabel(identifier, name, bufSize, length, label);
13820 }
13821 ANGLE_CAPTURE(GetObjectLabel, isCallValid, context, identifier, name, bufSize, length,
13822 label);
13823 }
13824 }
13825
GetObjectLabelKHRContextANGLE(GLeglContext ctx,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)13826 void GL_APIENTRY GetObjectLabelKHRContextANGLE(GLeglContext ctx,
13827 GLenum identifier,
13828 GLuint name,
13829 GLsizei bufSize,
13830 GLsizei *length,
13831 GLchar *label)
13832 {
13833 Context *context = static_cast<gl::Context *>(ctx);
13834 EVENT("glGetObjectLabelKHR",
13835 "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei bufSize = %d, GLsizei "
13836 "*length = 0x%016" PRIxPTR ", GLchar *label = 0x%016" PRIxPTR "",
13837 CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize,
13838 (uintptr_t)length, (uintptr_t)label);
13839
13840 if (context)
13841 {
13842 ASSERT(context == GetValidGlobalContext());
13843 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13844 bool isCallValid =
13845 (context->skipValidation() ||
13846 ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label));
13847 if (isCallValid)
13848 {
13849 context->getObjectLabel(identifier, name, bufSize, length, label);
13850 }
13851 ANGLE_CAPTURE(GetObjectLabelKHR, isCallValid, context, identifier, name, bufSize, length,
13852 label);
13853 }
13854 }
13855
GetObjectPtrLabelContextANGLE(GLeglContext ctx,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)13856 void GL_APIENTRY GetObjectPtrLabelContextANGLE(GLeglContext ctx,
13857 const void *ptr,
13858 GLsizei bufSize,
13859 GLsizei *length,
13860 GLchar *label)
13861 {
13862 Context *context = static_cast<gl::Context *>(ctx);
13863 EVENT("glGetObjectPtrLabel",
13864 "context = %d, const void *ptr = 0x%016" PRIxPTR
13865 ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
13866 ", GLchar *label = 0x%016" PRIxPTR "",
13867 CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
13868
13869 if (context)
13870 {
13871 ASSERT(context == GetValidGlobalContext());
13872 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13873 bool isCallValid = (context->skipValidation() ||
13874 ValidateGetObjectPtrLabel(context, ptr, bufSize, length, label));
13875 if (isCallValid)
13876 {
13877 context->getObjectPtrLabel(ptr, bufSize, length, label);
13878 }
13879 ANGLE_CAPTURE(GetObjectPtrLabel, isCallValid, context, ptr, bufSize, length, label);
13880 }
13881 }
13882
GetObjectPtrLabelKHRContextANGLE(GLeglContext ctx,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)13883 void GL_APIENTRY GetObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
13884 const void *ptr,
13885 GLsizei bufSize,
13886 GLsizei *length,
13887 GLchar *label)
13888 {
13889 Context *context = static_cast<gl::Context *>(ctx);
13890 EVENT("glGetObjectPtrLabelKHR",
13891 "context = %d, const void *ptr = 0x%016" PRIxPTR
13892 ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
13893 ", GLchar *label = 0x%016" PRIxPTR "",
13894 CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
13895
13896 if (context)
13897 {
13898 ASSERT(context == GetValidGlobalContext());
13899 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13900 bool isCallValid = (context->skipValidation() ||
13901 ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label));
13902 if (isCallValid)
13903 {
13904 context->getObjectPtrLabel(ptr, bufSize, length, label);
13905 }
13906 ANGLE_CAPTURE(GetObjectPtrLabelKHR, isCallValid, context, ptr, bufSize, length, label);
13907 }
13908 }
13909
GetPointervContextANGLE(GLeglContext ctx,GLenum pname,void ** params)13910 void GL_APIENTRY GetPointervContextANGLE(GLeglContext ctx, GLenum pname, void **params)
13911 {
13912 Context *context = static_cast<gl::Context *>(ctx);
13913 EVENT("glGetPointerv", "context = %d, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
13914 CID(context), GLenumToString(GLenumGroup::GetPointervPName, pname), (uintptr_t)params);
13915
13916 if (context)
13917 {
13918 ASSERT(context == GetValidGlobalContext());
13919 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13920 bool isCallValid =
13921 (context->skipValidation() || ValidateGetPointerv(context, pname, params));
13922 if (isCallValid)
13923 {
13924 context->getPointerv(pname, params);
13925 }
13926 ANGLE_CAPTURE(GetPointerv, isCallValid, context, pname, params);
13927 }
13928 }
13929
GetPointervKHRContextANGLE(GLeglContext ctx,GLenum pname,void ** params)13930 void GL_APIENTRY GetPointervKHRContextANGLE(GLeglContext ctx, GLenum pname, void **params)
13931 {
13932 Context *context = static_cast<gl::Context *>(ctx);
13933 EVENT("glGetPointervKHR", "context = %d, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
13934 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
13935
13936 if (context)
13937 {
13938 ASSERT(context == GetValidGlobalContext());
13939 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13940 bool isCallValid =
13941 (context->skipValidation() || ValidateGetPointervKHR(context, pname, params));
13942 if (isCallValid)
13943 {
13944 context->getPointerv(pname, params);
13945 }
13946 ANGLE_CAPTURE(GetPointervKHR, isCallValid, context, pname, params);
13947 }
13948 }
13949
GetProgramBinaryContextANGLE(GLeglContext ctx,GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)13950 void GL_APIENTRY GetProgramBinaryContextANGLE(GLeglContext ctx,
13951 GLuint program,
13952 GLsizei bufSize,
13953 GLsizei *length,
13954 GLenum *binaryFormat,
13955 void *binary)
13956 {
13957 Context *context = static_cast<gl::Context *>(ctx);
13958 EVENT(
13959 "glGetProgramBinary",
13960 "context = %d, GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
13961 ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR "",
13962 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
13963 (uintptr_t)binary);
13964
13965 if (context)
13966 {
13967 ASSERT(context == GetValidGlobalContext());
13968 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
13969 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
13970 bool isCallValid =
13971 (context->skipValidation() || ValidateGetProgramBinary(context, programPacked, bufSize,
13972 length, binaryFormat, binary));
13973 if (isCallValid)
13974 {
13975 context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
13976 }
13977 ANGLE_CAPTURE(GetProgramBinary, isCallValid, context, programPacked, bufSize, length,
13978 binaryFormat, binary);
13979 }
13980 }
13981
GetProgramBinaryOESContextANGLE(GLeglContext ctx,GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)13982 void GL_APIENTRY GetProgramBinaryOESContextANGLE(GLeglContext ctx,
13983 GLuint program,
13984 GLsizei bufSize,
13985 GLsizei *length,
13986 GLenum *binaryFormat,
13987 void *binary)
13988 {
13989 Context *context = static_cast<gl::Context *>(ctx);
13990 EVENT(
13991 "glGetProgramBinaryOES",
13992 "context = %d, GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
13993 ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR "",
13994 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
13995 (uintptr_t)binary);
13996
13997 if (context)
13998 {
13999 ASSERT(context == GetValidGlobalContext());
14000 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14001 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14002 bool isCallValid = (context->skipValidation() ||
14003 ValidateGetProgramBinaryOES(context, programPacked, bufSize, length,
14004 binaryFormat, binary));
14005 if (isCallValid)
14006 {
14007 context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
14008 }
14009 ANGLE_CAPTURE(GetProgramBinaryOES, isCallValid, context, programPacked, bufSize, length,
14010 binaryFormat, binary);
14011 }
14012 }
14013
GetProgramInfoLogContextANGLE(GLeglContext ctx,GLuint program,GLsizei bufSize,GLsizei * length,GLchar * infoLog)14014 void GL_APIENTRY GetProgramInfoLogContextANGLE(GLeglContext ctx,
14015 GLuint program,
14016 GLsizei bufSize,
14017 GLsizei *length,
14018 GLchar *infoLog)
14019 {
14020 Context *context = static_cast<gl::Context *>(ctx);
14021 EVENT(
14022 "glGetProgramInfoLog",
14023 "context = %d, GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
14024 ", GLchar *infoLog = 0x%016" PRIxPTR "",
14025 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
14026
14027 if (context)
14028 {
14029 ASSERT(context == GetValidGlobalContext());
14030 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14031 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14032 bool isCallValid =
14033 (context->skipValidation() ||
14034 ValidateGetProgramInfoLog(context, programPacked, bufSize, length, infoLog));
14035 if (isCallValid)
14036 {
14037 context->getProgramInfoLog(programPacked, bufSize, length, infoLog);
14038 }
14039 ANGLE_CAPTURE(GetProgramInfoLog, isCallValid, context, programPacked, bufSize, length,
14040 infoLog);
14041 }
14042 }
14043
GetProgramInterfaceivContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,GLenum pname,GLint * params)14044 void GL_APIENTRY GetProgramInterfaceivContextANGLE(GLeglContext ctx,
14045 GLuint program,
14046 GLenum programInterface,
14047 GLenum pname,
14048 GLint *params)
14049 {
14050 Context *context = static_cast<gl::Context *>(ctx);
14051 EVENT("glGetProgramInterfaceiv",
14052 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLenum pname = %s, "
14053 "GLint *params = 0x%016" PRIxPTR "",
14054 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
14055 GLenumToString(GLenumGroup::ProgramInterfacePName, pname), (uintptr_t)params);
14056
14057 if (context)
14058 {
14059 ASSERT(context == GetValidGlobalContext());
14060 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14061 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14062 bool isCallValid = (context->skipValidation() ||
14063 ValidateGetProgramInterfaceiv(context, programPacked, programInterface,
14064 pname, params));
14065 if (isCallValid)
14066 {
14067 context->getProgramInterfaceiv(programPacked, programInterface, pname, params);
14068 }
14069 ANGLE_CAPTURE(GetProgramInterfaceiv, isCallValid, context, programPacked, programInterface,
14070 pname, params);
14071 }
14072 }
14073
GetProgramPipelineInfoLogContextANGLE(GLeglContext ctx,GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)14074 void GL_APIENTRY GetProgramPipelineInfoLogContextANGLE(GLeglContext ctx,
14075 GLuint pipeline,
14076 GLsizei bufSize,
14077 GLsizei *length,
14078 GLchar *infoLog)
14079 {
14080 Context *context = static_cast<gl::Context *>(ctx);
14081 EVENT(
14082 "glGetProgramPipelineInfoLog",
14083 "context = %d, GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
14084 ", GLchar *infoLog = 0x%016" PRIxPTR "",
14085 CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
14086
14087 if (context)
14088 {
14089 ASSERT(context == GetValidGlobalContext());
14090 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
14091 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14092 bool isCallValid =
14093 (context->skipValidation() ||
14094 ValidateGetProgramPipelineInfoLog(context, pipelinePacked, bufSize, length, infoLog));
14095 if (isCallValid)
14096 {
14097 context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog);
14098 }
14099 ANGLE_CAPTURE(GetProgramPipelineInfoLog, isCallValid, context, pipelinePacked, bufSize,
14100 length, infoLog);
14101 }
14102 }
14103
GetProgramPipelineivContextANGLE(GLeglContext ctx,GLuint pipeline,GLenum pname,GLint * params)14104 void GL_APIENTRY GetProgramPipelineivContextANGLE(GLeglContext ctx,
14105 GLuint pipeline,
14106 GLenum pname,
14107 GLint *params)
14108 {
14109 Context *context = static_cast<gl::Context *>(ctx);
14110 EVENT("glGetProgramPipelineiv",
14111 "context = %d, GLuint pipeline = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
14112 "",
14113 CID(context), pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname),
14114 (uintptr_t)params);
14115
14116 if (context)
14117 {
14118 ASSERT(context == GetValidGlobalContext());
14119 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
14120 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14121 bool isCallValid = (context->skipValidation() ||
14122 ValidateGetProgramPipelineiv(context, pipelinePacked, pname, params));
14123 if (isCallValid)
14124 {
14125 context->getProgramPipelineiv(pipelinePacked, pname, params);
14126 }
14127 ANGLE_CAPTURE(GetProgramPipelineiv, isCallValid, context, pipelinePacked, pname, params);
14128 }
14129 }
14130
GetProgramResourceIndexContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,const GLchar * name)14131 GLuint GL_APIENTRY GetProgramResourceIndexContextANGLE(GLeglContext ctx,
14132 GLuint program,
14133 GLenum programInterface,
14134 const GLchar *name)
14135 {
14136 Context *context = static_cast<gl::Context *>(ctx);
14137 EVENT("glGetProgramResourceIndex",
14138 "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = "
14139 "0x%016" PRIxPTR "",
14140 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
14141 (uintptr_t)name);
14142
14143 GLuint returnValue;
14144 if (context)
14145 {
14146 ASSERT(context == GetValidGlobalContext());
14147 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14148 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14149 bool isCallValid =
14150 (context->skipValidation() ||
14151 ValidateGetProgramResourceIndex(context, programPacked, programInterface, name));
14152 if (isCallValid)
14153 {
14154 returnValue = context->getProgramResourceIndex(programPacked, programInterface, name);
14155 }
14156 else
14157 {
14158 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
14159 }
14160 ANGLE_CAPTURE(GetProgramResourceIndex, isCallValid, context, programPacked,
14161 programInterface, name, returnValue);
14162 }
14163 else
14164 {
14165 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
14166 }
14167 return returnValue;
14168 }
14169
GetProgramResourceLocationContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,const GLchar * name)14170 GLint GL_APIENTRY GetProgramResourceLocationContextANGLE(GLeglContext ctx,
14171 GLuint program,
14172 GLenum programInterface,
14173 const GLchar *name)
14174 {
14175 Context *context = static_cast<gl::Context *>(ctx);
14176 EVENT("glGetProgramResourceLocation",
14177 "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = "
14178 "0x%016" PRIxPTR "",
14179 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
14180 (uintptr_t)name);
14181
14182 GLint returnValue;
14183 if (context)
14184 {
14185 ASSERT(context == GetValidGlobalContext());
14186 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14187 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14188 bool isCallValid =
14189 (context->skipValidation() ||
14190 ValidateGetProgramResourceLocation(context, programPacked, programInterface, name));
14191 if (isCallValid)
14192 {
14193 returnValue =
14194 context->getProgramResourceLocation(programPacked, programInterface, name);
14195 }
14196 else
14197 {
14198 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
14199 }
14200 ANGLE_CAPTURE(GetProgramResourceLocation, isCallValid, context, programPacked,
14201 programInterface, name, returnValue);
14202 }
14203 else
14204 {
14205 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
14206 }
14207 return returnValue;
14208 }
14209
GetProgramResourceLocationIndexEXTContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,const GLchar * name)14210 GLint GL_APIENTRY GetProgramResourceLocationIndexEXTContextANGLE(GLeglContext ctx,
14211 GLuint program,
14212 GLenum programInterface,
14213 const GLchar *name)
14214 {
14215 Context *context = static_cast<gl::Context *>(ctx);
14216 EVENT("glGetProgramResourceLocationIndexEXT",
14217 "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = "
14218 "0x%016" PRIxPTR "",
14219 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
14220 (uintptr_t)name);
14221
14222 GLint returnValue;
14223 if (context)
14224 {
14225 ASSERT(context == GetValidGlobalContext());
14226 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14227 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14228 bool isCallValid =
14229 (context->skipValidation() || ValidateGetProgramResourceLocationIndexEXT(
14230 context, programPacked, programInterface, name));
14231 if (isCallValid)
14232 {
14233 returnValue =
14234 context->getProgramResourceLocationIndex(programPacked, programInterface, name);
14235 }
14236 else
14237 {
14238 returnValue =
14239 GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndexEXT, GLint>();
14240 }
14241 ANGLE_CAPTURE(GetProgramResourceLocationIndexEXT, isCallValid, context, programPacked,
14242 programInterface, name, returnValue);
14243 }
14244 else
14245 {
14246 returnValue =
14247 GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndexEXT, GLint>();
14248 }
14249 return returnValue;
14250 }
14251
GetProgramResourceNameContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei * length,GLchar * name)14252 void GL_APIENTRY GetProgramResourceNameContextANGLE(GLeglContext ctx,
14253 GLuint program,
14254 GLenum programInterface,
14255 GLuint index,
14256 GLsizei bufSize,
14257 GLsizei *length,
14258 GLchar *name)
14259 {
14260 Context *context = static_cast<gl::Context *>(ctx);
14261 EVENT("glGetProgramResourceName",
14262 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLuint index = %u, "
14263 "GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR
14264 "",
14265 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
14266 index, bufSize, (uintptr_t)length, (uintptr_t)name);
14267
14268 if (context)
14269 {
14270 ASSERT(context == GetValidGlobalContext());
14271 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14272 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14273 bool isCallValid = (context->skipValidation() ||
14274 ValidateGetProgramResourceName(context, programPacked, programInterface,
14275 index, bufSize, length, name));
14276 if (isCallValid)
14277 {
14278 context->getProgramResourceName(programPacked, programInterface, index, bufSize, length,
14279 name);
14280 }
14281 ANGLE_CAPTURE(GetProgramResourceName, isCallValid, context, programPacked, programInterface,
14282 index, bufSize, length, name);
14283 }
14284 }
14285
GetProgramResourceivContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum * props,GLsizei bufSize,GLsizei * length,GLint * params)14286 void GL_APIENTRY GetProgramResourceivContextANGLE(GLeglContext ctx,
14287 GLuint program,
14288 GLenum programInterface,
14289 GLuint index,
14290 GLsizei propCount,
14291 const GLenum *props,
14292 GLsizei bufSize,
14293 GLsizei *length,
14294 GLint *params)
14295 {
14296 Context *context = static_cast<gl::Context *>(ctx);
14297 EVENT("glGetProgramResourceiv",
14298 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLuint index = %u, "
14299 "GLsizei propCount = %d, const GLenum *props = 0x%016" PRIxPTR
14300 ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
14301 ", GLint *params = 0x%016" PRIxPTR "",
14302 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
14303 index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length, (uintptr_t)params);
14304
14305 if (context)
14306 {
14307 ASSERT(context == GetValidGlobalContext());
14308 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14309 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14310 bool isCallValid =
14311 (context->skipValidation() ||
14312 ValidateGetProgramResourceiv(context, programPacked, programInterface, index,
14313 propCount, props, bufSize, length, params));
14314 if (isCallValid)
14315 {
14316 context->getProgramResourceiv(programPacked, programInterface, index, propCount, props,
14317 bufSize, length, params);
14318 }
14319 ANGLE_CAPTURE(GetProgramResourceiv, isCallValid, context, programPacked, programInterface,
14320 index, propCount, props, bufSize, length, params);
14321 }
14322 }
14323
GetProgramivContextANGLE(GLeglContext ctx,GLuint program,GLenum pname,GLint * params)14324 void GL_APIENTRY GetProgramivContextANGLE(GLeglContext ctx,
14325 GLuint program,
14326 GLenum pname,
14327 GLint *params)
14328 {
14329 Context *context = static_cast<gl::Context *>(ctx);
14330 EVENT("glGetProgramiv",
14331 "context = %d, GLuint program = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14332 CID(context), program, GLenumToString(GLenumGroup::ProgramPropertyARB, pname),
14333 (uintptr_t)params);
14334
14335 if (context)
14336 {
14337 ASSERT(context == GetValidGlobalContext());
14338 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
14339 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14340 bool isCallValid = (context->skipValidation() ||
14341 ValidateGetProgramiv(context, programPacked, pname, params));
14342 if (isCallValid)
14343 {
14344 context->getProgramiv(programPacked, pname, params);
14345 }
14346 ANGLE_CAPTURE(GetProgramiv, isCallValid, context, programPacked, pname, params);
14347 }
14348 }
14349
GetQueryObjecti64vEXTContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLint64 * params)14350 void GL_APIENTRY GetQueryObjecti64vEXTContextANGLE(GLeglContext ctx,
14351 GLuint id,
14352 GLenum pname,
14353 GLint64 *params)
14354 {
14355 Context *context = static_cast<gl::Context *>(ctx);
14356 EVENT("glGetQueryObjecti64vEXT",
14357 "context = %d, GLuint id = %u, GLenum pname = %s, GLint64 *params = 0x%016" PRIxPTR "",
14358 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
14359 (uintptr_t)params);
14360
14361 if (context)
14362 {
14363 ASSERT(context == GetValidGlobalContext());
14364 QueryID idPacked = FromGL<QueryID>(id);
14365 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14366 bool isCallValid = (context->skipValidation() ||
14367 ValidateGetQueryObjecti64vEXT(context, idPacked, pname, params));
14368 if (isCallValid)
14369 {
14370 context->getQueryObjecti64v(idPacked, pname, params);
14371 }
14372 ANGLE_CAPTURE(GetQueryObjecti64vEXT, isCallValid, context, idPacked, pname, params);
14373 }
14374 }
14375
GetQueryObjectivEXTContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLint * params)14376 void GL_APIENTRY GetQueryObjectivEXTContextANGLE(GLeglContext ctx,
14377 GLuint id,
14378 GLenum pname,
14379 GLint *params)
14380 {
14381 Context *context = static_cast<gl::Context *>(ctx);
14382 EVENT("glGetQueryObjectivEXT",
14383 "context = %d, GLuint id = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14384 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
14385 (uintptr_t)params);
14386
14387 if (context)
14388 {
14389 ASSERT(context == GetValidGlobalContext());
14390 QueryID idPacked = FromGL<QueryID>(id);
14391 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14392 bool isCallValid = (context->skipValidation() ||
14393 ValidateGetQueryObjectivEXT(context, idPacked, pname, params));
14394 if (isCallValid)
14395 {
14396 context->getQueryObjectiv(idPacked, pname, params);
14397 }
14398 ANGLE_CAPTURE(GetQueryObjectivEXT, isCallValid, context, idPacked, pname, params);
14399 }
14400 }
14401
GetQueryObjectui64vEXTContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLuint64 * params)14402 void GL_APIENTRY GetQueryObjectui64vEXTContextANGLE(GLeglContext ctx,
14403 GLuint id,
14404 GLenum pname,
14405 GLuint64 *params)
14406 {
14407 Context *context = static_cast<gl::Context *>(ctx);
14408 EVENT("glGetQueryObjectui64vEXT",
14409 "context = %d, GLuint id = %u, GLenum pname = %s, GLuint64 *params = 0x%016" PRIxPTR "",
14410 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
14411 (uintptr_t)params);
14412
14413 if (context)
14414 {
14415 ASSERT(context == GetValidGlobalContext());
14416 QueryID idPacked = FromGL<QueryID>(id);
14417 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14418 bool isCallValid = (context->skipValidation() ||
14419 ValidateGetQueryObjectui64vEXT(context, idPacked, pname, params));
14420 if (isCallValid)
14421 {
14422 context->getQueryObjectui64v(idPacked, pname, params);
14423 }
14424 ANGLE_CAPTURE(GetQueryObjectui64vEXT, isCallValid, context, idPacked, pname, params);
14425 }
14426 }
14427
GetQueryObjectuivContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLuint * params)14428 void GL_APIENTRY GetQueryObjectuivContextANGLE(GLeglContext ctx,
14429 GLuint id,
14430 GLenum pname,
14431 GLuint *params)
14432 {
14433 Context *context = static_cast<gl::Context *>(ctx);
14434 EVENT("glGetQueryObjectuiv",
14435 "context = %d, GLuint id = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
14436 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
14437 (uintptr_t)params);
14438
14439 if (context)
14440 {
14441 ASSERT(context == GetValidGlobalContext());
14442 QueryID idPacked = FromGL<QueryID>(id);
14443 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14444 bool isCallValid = (context->skipValidation() ||
14445 ValidateGetQueryObjectuiv(context, idPacked, pname, params));
14446 if (isCallValid)
14447 {
14448 context->getQueryObjectuiv(idPacked, pname, params);
14449 }
14450 ANGLE_CAPTURE(GetQueryObjectuiv, isCallValid, context, idPacked, pname, params);
14451 }
14452 }
14453
GetQueryObjectuivEXTContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLuint * params)14454 void GL_APIENTRY GetQueryObjectuivEXTContextANGLE(GLeglContext ctx,
14455 GLuint id,
14456 GLenum pname,
14457 GLuint *params)
14458 {
14459 Context *context = static_cast<gl::Context *>(ctx);
14460 EVENT("glGetQueryObjectuivEXT",
14461 "context = %d, GLuint id = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
14462 CID(context), id, GLenumToString(GLenumGroup::QueryObjectParameterName, pname),
14463 (uintptr_t)params);
14464
14465 if (context)
14466 {
14467 ASSERT(context == GetValidGlobalContext());
14468 QueryID idPacked = FromGL<QueryID>(id);
14469 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14470 bool isCallValid = (context->skipValidation() ||
14471 ValidateGetQueryObjectuivEXT(context, idPacked, pname, params));
14472 if (isCallValid)
14473 {
14474 context->getQueryObjectuiv(idPacked, pname, params);
14475 }
14476 ANGLE_CAPTURE(GetQueryObjectuivEXT, isCallValid, context, idPacked, pname, params);
14477 }
14478 }
14479
GetQueryivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)14480 void GL_APIENTRY GetQueryivContextANGLE(GLeglContext ctx,
14481 GLenum target,
14482 GLenum pname,
14483 GLint *params)
14484 {
14485 Context *context = static_cast<gl::Context *>(ctx);
14486 EVENT("glGetQueryiv",
14487 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14488 CID(context), GLenumToString(GLenumGroup::QueryTarget, target),
14489 GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
14490
14491 if (context)
14492 {
14493 ASSERT(context == GetValidGlobalContext());
14494 QueryType targetPacked = FromGL<QueryType>(target);
14495 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14496 bool isCallValid =
14497 (context->skipValidation() || ValidateGetQueryiv(context, targetPacked, pname, params));
14498 if (isCallValid)
14499 {
14500 context->getQueryiv(targetPacked, pname, params);
14501 }
14502 ANGLE_CAPTURE(GetQueryiv, isCallValid, context, targetPacked, pname, params);
14503 }
14504 }
14505
GetQueryivEXTContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)14506 void GL_APIENTRY GetQueryivEXTContextANGLE(GLeglContext ctx,
14507 GLenum target,
14508 GLenum pname,
14509 GLint *params)
14510 {
14511 Context *context = static_cast<gl::Context *>(ctx);
14512 EVENT("glGetQueryivEXT",
14513 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14514 CID(context), GLenumToString(GLenumGroup::QueryTarget, target),
14515 GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
14516
14517 if (context)
14518 {
14519 ASSERT(context == GetValidGlobalContext());
14520 QueryType targetPacked = FromGL<QueryType>(target);
14521 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14522 bool isCallValid = (context->skipValidation() ||
14523 ValidateGetQueryivEXT(context, targetPacked, pname, params));
14524 if (isCallValid)
14525 {
14526 context->getQueryiv(targetPacked, pname, params);
14527 }
14528 ANGLE_CAPTURE(GetQueryivEXT, isCallValid, context, targetPacked, pname, params);
14529 }
14530 }
14531
GetRenderbufferParameterivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)14532 void GL_APIENTRY GetRenderbufferParameterivContextANGLE(GLeglContext ctx,
14533 GLenum target,
14534 GLenum pname,
14535 GLint *params)
14536 {
14537 Context *context = static_cast<gl::Context *>(ctx);
14538 EVENT("glGetRenderbufferParameteriv",
14539 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14540 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
14541 GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params);
14542
14543 if (context)
14544 {
14545 ASSERT(context == GetValidGlobalContext());
14546 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14547 bool isCallValid = (context->skipValidation() ||
14548 ValidateGetRenderbufferParameteriv(context, target, pname, params));
14549 if (isCallValid)
14550 {
14551 context->getRenderbufferParameteriv(target, pname, params);
14552 }
14553 ANGLE_CAPTURE(GetRenderbufferParameteriv, isCallValid, context, target, pname, params);
14554 }
14555 }
14556
GetRenderbufferParameterivOESContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)14557 void GL_APIENTRY GetRenderbufferParameterivOESContextANGLE(GLeglContext ctx,
14558 GLenum target,
14559 GLenum pname,
14560 GLint *params)
14561 {
14562 Context *context = static_cast<gl::Context *>(ctx);
14563 EVENT("glGetRenderbufferParameterivOES",
14564 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14565 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
14566 GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params);
14567
14568 if (context)
14569 {
14570 ASSERT(context == GetValidGlobalContext());
14571 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14572 bool isCallValid = (context->skipValidation() ||
14573 ValidateGetRenderbufferParameterivOES(context, target, pname, params));
14574 if (isCallValid)
14575 {
14576 context->getRenderbufferParameteriv(target, pname, params);
14577 }
14578 ANGLE_CAPTURE(GetRenderbufferParameterivOES, isCallValid, context, target, pname, params);
14579 }
14580 }
14581
GetSamplerParameterIivContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLint * params)14582 void GL_APIENTRY GetSamplerParameterIivContextANGLE(GLeglContext ctx,
14583 GLuint sampler,
14584 GLenum pname,
14585 GLint *params)
14586 {
14587 Context *context = static_cast<gl::Context *>(ctx);
14588 EVENT("glGetSamplerParameterIiv",
14589 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14590 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
14591 (uintptr_t)params);
14592
14593 if (context)
14594 {
14595 ASSERT(context == GetValidGlobalContext());
14596 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
14597 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14598 bool isCallValid = (context->skipValidation() ||
14599 ValidateGetSamplerParameterIiv(context, samplerPacked, pname, params));
14600 if (isCallValid)
14601 {
14602 context->getSamplerParameterIiv(samplerPacked, pname, params);
14603 }
14604 ANGLE_CAPTURE(GetSamplerParameterIiv, isCallValid, context, samplerPacked, pname, params);
14605 }
14606 }
14607
GetSamplerParameterIivOESContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLint * params)14608 void GL_APIENTRY GetSamplerParameterIivOESContextANGLE(GLeglContext ctx,
14609 GLuint sampler,
14610 GLenum pname,
14611 GLint *params)
14612 {
14613 Context *context = static_cast<gl::Context *>(ctx);
14614 EVENT("glGetSamplerParameterIivOES",
14615 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14616 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
14617 (uintptr_t)params);
14618
14619 if (context)
14620 {
14621 ASSERT(context == GetValidGlobalContext());
14622 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
14623 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14624 bool isCallValid =
14625 (context->skipValidation() ||
14626 ValidateGetSamplerParameterIivOES(context, samplerPacked, pname, params));
14627 if (isCallValid)
14628 {
14629 context->getSamplerParameterIiv(samplerPacked, pname, params);
14630 }
14631 ANGLE_CAPTURE(GetSamplerParameterIivOES, isCallValid, context, samplerPacked, pname,
14632 params);
14633 }
14634 }
14635
GetSamplerParameterIuivContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLuint * params)14636 void GL_APIENTRY GetSamplerParameterIuivContextANGLE(GLeglContext ctx,
14637 GLuint sampler,
14638 GLenum pname,
14639 GLuint *params)
14640 {
14641 Context *context = static_cast<gl::Context *>(ctx);
14642 EVENT("glGetSamplerParameterIuiv",
14643 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR
14644 "",
14645 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
14646 (uintptr_t)params);
14647
14648 if (context)
14649 {
14650 ASSERT(context == GetValidGlobalContext());
14651 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
14652 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14653 bool isCallValid = (context->skipValidation() ||
14654 ValidateGetSamplerParameterIuiv(context, samplerPacked, pname, params));
14655 if (isCallValid)
14656 {
14657 context->getSamplerParameterIuiv(samplerPacked, pname, params);
14658 }
14659 ANGLE_CAPTURE(GetSamplerParameterIuiv, isCallValid, context, samplerPacked, pname, params);
14660 }
14661 }
14662
GetSamplerParameterIuivOESContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLuint * params)14663 void GL_APIENTRY GetSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
14664 GLuint sampler,
14665 GLenum pname,
14666 GLuint *params)
14667 {
14668 Context *context = static_cast<gl::Context *>(ctx);
14669 EVENT("glGetSamplerParameterIuivOES",
14670 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR
14671 "",
14672 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
14673 (uintptr_t)params);
14674
14675 if (context)
14676 {
14677 ASSERT(context == GetValidGlobalContext());
14678 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
14679 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14680 bool isCallValid =
14681 (context->skipValidation() ||
14682 ValidateGetSamplerParameterIuivOES(context, samplerPacked, pname, params));
14683 if (isCallValid)
14684 {
14685 context->getSamplerParameterIuiv(samplerPacked, pname, params);
14686 }
14687 ANGLE_CAPTURE(GetSamplerParameterIuivOES, isCallValid, context, samplerPacked, pname,
14688 params);
14689 }
14690 }
14691
GetSamplerParameterfvContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLfloat * params)14692 void GL_APIENTRY GetSamplerParameterfvContextANGLE(GLeglContext ctx,
14693 GLuint sampler,
14694 GLenum pname,
14695 GLfloat *params)
14696 {
14697 Context *context = static_cast<gl::Context *>(ctx);
14698 EVENT("glGetSamplerParameterfv",
14699 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
14700 "",
14701 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
14702 (uintptr_t)params);
14703
14704 if (context)
14705 {
14706 ASSERT(context == GetValidGlobalContext());
14707 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
14708 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14709 bool isCallValid = (context->skipValidation() ||
14710 ValidateGetSamplerParameterfv(context, samplerPacked, pname, params));
14711 if (isCallValid)
14712 {
14713 context->getSamplerParameterfv(samplerPacked, pname, params);
14714 }
14715 ANGLE_CAPTURE(GetSamplerParameterfv, isCallValid, context, samplerPacked, pname, params);
14716 }
14717 }
14718
GetSamplerParameterivContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLint * params)14719 void GL_APIENTRY GetSamplerParameterivContextANGLE(GLeglContext ctx,
14720 GLuint sampler,
14721 GLenum pname,
14722 GLint *params)
14723 {
14724 Context *context = static_cast<gl::Context *>(ctx);
14725 EVENT("glGetSamplerParameteriv",
14726 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14727 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
14728 (uintptr_t)params);
14729
14730 if (context)
14731 {
14732 ASSERT(context == GetValidGlobalContext());
14733 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
14734 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14735 bool isCallValid = (context->skipValidation() ||
14736 ValidateGetSamplerParameteriv(context, samplerPacked, pname, params));
14737 if (isCallValid)
14738 {
14739 context->getSamplerParameteriv(samplerPacked, pname, params);
14740 }
14741 ANGLE_CAPTURE(GetSamplerParameteriv, isCallValid, context, samplerPacked, pname, params);
14742 }
14743 }
14744
GetSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,GLuint semaphore,GLenum pname,GLuint64 * params)14745 void GL_APIENTRY GetSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
14746 GLuint semaphore,
14747 GLenum pname,
14748 GLuint64 *params)
14749 {
14750 Context *context = static_cast<gl::Context *>(ctx);
14751 EVENT(
14752 "glGetSemaphoreParameterui64vEXT",
14753 "context = %d, GLuint semaphore = %u, GLenum pname = %s, GLuint64 *params = 0x%016" PRIxPTR
14754 "",
14755 CID(context), semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname),
14756 (uintptr_t)params);
14757
14758 if (context)
14759 {
14760 ASSERT(context == GetValidGlobalContext());
14761 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
14762 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14763 bool isCallValid =
14764 (context->skipValidation() ||
14765 ValidateGetSemaphoreParameterui64vEXT(context, semaphorePacked, pname, params));
14766 if (isCallValid)
14767 {
14768 context->getSemaphoreParameterui64v(semaphorePacked, pname, params);
14769 }
14770 ANGLE_CAPTURE(GetSemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
14771 params);
14772 }
14773 }
14774
GetShaderInfoLogContextANGLE(GLeglContext ctx,GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * infoLog)14775 void GL_APIENTRY GetShaderInfoLogContextANGLE(GLeglContext ctx,
14776 GLuint shader,
14777 GLsizei bufSize,
14778 GLsizei *length,
14779 GLchar *infoLog)
14780 {
14781 Context *context = static_cast<gl::Context *>(ctx);
14782 EVENT("glGetShaderInfoLog",
14783 "context = %d, GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
14784 ", GLchar *infoLog = 0x%016" PRIxPTR "",
14785 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
14786
14787 if (context)
14788 {
14789 ASSERT(context == GetValidGlobalContext());
14790 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
14791 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14792 bool isCallValid =
14793 (context->skipValidation() ||
14794 ValidateGetShaderInfoLog(context, shaderPacked, bufSize, length, infoLog));
14795 if (isCallValid)
14796 {
14797 context->getShaderInfoLog(shaderPacked, bufSize, length, infoLog);
14798 }
14799 ANGLE_CAPTURE(GetShaderInfoLog, isCallValid, context, shaderPacked, bufSize, length,
14800 infoLog);
14801 }
14802 }
14803
GetShaderPrecisionFormatContextANGLE(GLeglContext ctx,GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision)14804 void GL_APIENTRY GetShaderPrecisionFormatContextANGLE(GLeglContext ctx,
14805 GLenum shadertype,
14806 GLenum precisiontype,
14807 GLint *range,
14808 GLint *precision)
14809 {
14810 Context *context = static_cast<gl::Context *>(ctx);
14811 EVENT("glGetShaderPrecisionFormat",
14812 "context = %d, GLenum shadertype = %s, GLenum precisiontype = %s, GLint *range = "
14813 "0x%016" PRIxPTR ", GLint *precision = 0x%016" PRIxPTR "",
14814 CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype),
14815 GLenumToString(GLenumGroup::PrecisionType, precisiontype), (uintptr_t)range,
14816 (uintptr_t)precision);
14817
14818 if (context)
14819 {
14820 ASSERT(context == GetValidGlobalContext());
14821 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14822 bool isCallValid = (context->skipValidation() ||
14823 ValidateGetShaderPrecisionFormat(context, shadertype, precisiontype,
14824 range, precision));
14825 if (isCallValid)
14826 {
14827 context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
14828 }
14829 ANGLE_CAPTURE(GetShaderPrecisionFormat, isCallValid, context, shadertype, precisiontype,
14830 range, precision);
14831 }
14832 }
14833
GetShaderSourceContextANGLE(GLeglContext ctx,GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source)14834 void GL_APIENTRY GetShaderSourceContextANGLE(GLeglContext ctx,
14835 GLuint shader,
14836 GLsizei bufSize,
14837 GLsizei *length,
14838 GLchar *source)
14839 {
14840 Context *context = static_cast<gl::Context *>(ctx);
14841 EVENT("glGetShaderSource",
14842 "context = %d, GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
14843 ", GLchar *source = 0x%016" PRIxPTR "",
14844 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
14845
14846 if (context)
14847 {
14848 ASSERT(context == GetValidGlobalContext());
14849 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
14850 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14851 bool isCallValid =
14852 (context->skipValidation() ||
14853 ValidateGetShaderSource(context, shaderPacked, bufSize, length, source));
14854 if (isCallValid)
14855 {
14856 context->getShaderSource(shaderPacked, bufSize, length, source);
14857 }
14858 ANGLE_CAPTURE(GetShaderSource, isCallValid, context, shaderPacked, bufSize, length, source);
14859 }
14860 }
14861
GetShaderivContextANGLE(GLeglContext ctx,GLuint shader,GLenum pname,GLint * params)14862 void GL_APIENTRY GetShaderivContextANGLE(GLeglContext ctx,
14863 GLuint shader,
14864 GLenum pname,
14865 GLint *params)
14866 {
14867 Context *context = static_cast<gl::Context *>(ctx);
14868 EVENT("glGetShaderiv",
14869 "context = %d, GLuint shader = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
14870 CID(context), shader, GLenumToString(GLenumGroup::ShaderParameterName, pname),
14871 (uintptr_t)params);
14872
14873 if (context)
14874 {
14875 ASSERT(context == GetValidGlobalContext());
14876 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
14877 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14878 bool isCallValid = (context->skipValidation() ||
14879 ValidateGetShaderiv(context, shaderPacked, pname, params));
14880 if (isCallValid)
14881 {
14882 context->getShaderiv(shaderPacked, pname, params);
14883 }
14884 ANGLE_CAPTURE(GetShaderiv, isCallValid, context, shaderPacked, pname, params);
14885 }
14886 }
14887
GetStringContextANGLE(GLeglContext ctx,GLenum name)14888 const GLubyte *GL_APIENTRY GetStringContextANGLE(GLeglContext ctx, GLenum name)
14889 {
14890 Context *context = static_cast<gl::Context *>(ctx);
14891 EVENT("glGetString", "context = %d, GLenum name = %s", CID(context),
14892 GLenumToString(GLenumGroup::StringName, name));
14893
14894 const GLubyte *returnValue;
14895 if (context)
14896 {
14897 ASSERT(context == GetValidGlobalContext());
14898 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14899 bool isCallValid = (context->skipValidation() || ValidateGetString(context, name));
14900 if (isCallValid)
14901 {
14902 returnValue = context->getString(name);
14903 }
14904 else
14905 {
14906 returnValue = GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
14907 }
14908 ANGLE_CAPTURE(GetString, isCallValid, context, name, returnValue);
14909 }
14910 else
14911 {
14912 returnValue = GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
14913 }
14914 return returnValue;
14915 }
14916
GetStringiContextANGLE(GLeglContext ctx,GLenum name,GLuint index)14917 const GLubyte *GL_APIENTRY GetStringiContextANGLE(GLeglContext ctx, GLenum name, GLuint index)
14918 {
14919 Context *context = static_cast<gl::Context *>(ctx);
14920 EVENT("glGetStringi", "context = %d, GLenum name = %s, GLuint index = %u", CID(context),
14921 GLenumToString(GLenumGroup::StringName, name), index);
14922
14923 const GLubyte *returnValue;
14924 if (context)
14925 {
14926 ASSERT(context == GetValidGlobalContext());
14927 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14928 bool isCallValid = (context->skipValidation() || ValidateGetStringi(context, name, index));
14929 if (isCallValid)
14930 {
14931 returnValue = context->getStringi(name, index);
14932 }
14933 else
14934 {
14935 returnValue = GetDefaultReturnValue<EntryPoint::GetStringi, const GLubyte *>();
14936 }
14937 ANGLE_CAPTURE(GetStringi, isCallValid, context, name, index, returnValue);
14938 }
14939 else
14940 {
14941 returnValue = GetDefaultReturnValue<EntryPoint::GetStringi, const GLubyte *>();
14942 }
14943 return returnValue;
14944 }
14945
GetSyncivContextANGLE(GLeglContext ctx,GLsync sync,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * values)14946 void GL_APIENTRY GetSyncivContextANGLE(GLeglContext ctx,
14947 GLsync sync,
14948 GLenum pname,
14949 GLsizei bufSize,
14950 GLsizei *length,
14951 GLint *values)
14952 {
14953 Context *context = static_cast<gl::Context *>(ctx);
14954 EVENT("glGetSynciv",
14955 "context = %d, GLsync sync = 0x%016" PRIxPTR
14956 ", GLenum pname = %s, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
14957 ", GLint *values = 0x%016" PRIxPTR "",
14958 CID(context), (uintptr_t)sync, GLenumToString(GLenumGroup::SyncParameterName, pname),
14959 bufSize, (uintptr_t)length, (uintptr_t)values);
14960
14961 if (context)
14962 {
14963 ASSERT(context == GetValidGlobalContext());
14964 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14965 bool isCallValid = (context->skipValidation() ||
14966 ValidateGetSynciv(context, sync, pname, bufSize, length, values));
14967 if (isCallValid)
14968 {
14969 context->getSynciv(sync, pname, bufSize, length, values);
14970 }
14971 ANGLE_CAPTURE(GetSynciv, isCallValid, context, sync, pname, bufSize, length, values);
14972 }
14973 }
14974
GetTexEnvfvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfloat * params)14975 void GL_APIENTRY GetTexEnvfvContextANGLE(GLeglContext ctx,
14976 GLenum target,
14977 GLenum pname,
14978 GLfloat *params)
14979 {
14980 Context *context = static_cast<gl::Context *>(ctx);
14981 EVENT("glGetTexEnvfv",
14982 "context = %d, GLenum target = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
14983 "",
14984 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
14985 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
14986
14987 if (context)
14988 {
14989 ASSERT(context == GetValidGlobalContext());
14990 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
14991 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
14992 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
14993 bool isCallValid = (context->skipValidation() ||
14994 ValidateGetTexEnvfv(context, targetPacked, pnamePacked, params));
14995 if (isCallValid)
14996 {
14997 context->getTexEnvfv(targetPacked, pnamePacked, params);
14998 }
14999 ANGLE_CAPTURE(GetTexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
15000 }
15001 }
15002
GetTexEnvivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)15003 void GL_APIENTRY GetTexEnvivContextANGLE(GLeglContext ctx,
15004 GLenum target,
15005 GLenum pname,
15006 GLint *params)
15007 {
15008 Context *context = static_cast<gl::Context *>(ctx);
15009 EVENT("glGetTexEnviv",
15010 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15011 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
15012 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
15013
15014 if (context)
15015 {
15016 ASSERT(context == GetValidGlobalContext());
15017 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
15018 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
15019 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15020 bool isCallValid = (context->skipValidation() ||
15021 ValidateGetTexEnviv(context, targetPacked, pnamePacked, params));
15022 if (isCallValid)
15023 {
15024 context->getTexEnviv(targetPacked, pnamePacked, params);
15025 }
15026 ANGLE_CAPTURE(GetTexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
15027 }
15028 }
15029
GetTexEnvxvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfixed * params)15030 void GL_APIENTRY GetTexEnvxvContextANGLE(GLeglContext ctx,
15031 GLenum target,
15032 GLenum pname,
15033 GLfixed *params)
15034 {
15035 Context *context = static_cast<gl::Context *>(ctx);
15036 EVENT("glGetTexEnvxv",
15037 "context = %d, GLenum target = %s, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR
15038 "",
15039 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
15040 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
15041
15042 if (context)
15043 {
15044 ASSERT(context == GetValidGlobalContext());
15045 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
15046 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
15047 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15048 bool isCallValid = (context->skipValidation() ||
15049 ValidateGetTexEnvxv(context, targetPacked, pnamePacked, params));
15050 if (isCallValid)
15051 {
15052 context->getTexEnvxv(targetPacked, pnamePacked, params);
15053 }
15054 ANGLE_CAPTURE(GetTexEnvxv, isCallValid, context, targetPacked, pnamePacked, params);
15055 }
15056 }
15057
GetTexGenfvOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,GLfloat * params)15058 void GL_APIENTRY GetTexGenfvOESContextANGLE(GLeglContext ctx,
15059 GLenum coord,
15060 GLenum pname,
15061 GLfloat *params)
15062 {
15063 Context *context = static_cast<gl::Context *>(ctx);
15064 EVENT("glGetTexGenfvOES",
15065 "context = %d, GLenum coord = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
15066 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
15067 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
15068
15069 if (context)
15070 {
15071 ASSERT(context == GetValidGlobalContext());
15072 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15073 bool isCallValid =
15074 (context->skipValidation() || ValidateGetTexGenfvOES(context, coord, pname, params));
15075 if (isCallValid)
15076 {
15077 context->getTexGenfv(coord, pname, params);
15078 }
15079 ANGLE_CAPTURE(GetTexGenfvOES, isCallValid, context, coord, pname, params);
15080 }
15081 }
15082
GetTexGenivOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,GLint * params)15083 void GL_APIENTRY GetTexGenivOESContextANGLE(GLeglContext ctx,
15084 GLenum coord,
15085 GLenum pname,
15086 GLint *params)
15087 {
15088 Context *context = static_cast<gl::Context *>(ctx);
15089 EVENT("glGetTexGenivOES",
15090 "context = %d, GLenum coord = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15091 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
15092 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
15093
15094 if (context)
15095 {
15096 ASSERT(context == GetValidGlobalContext());
15097 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15098 bool isCallValid =
15099 (context->skipValidation() || ValidateGetTexGenivOES(context, coord, pname, params));
15100 if (isCallValid)
15101 {
15102 context->getTexGeniv(coord, pname, params);
15103 }
15104 ANGLE_CAPTURE(GetTexGenivOES, isCallValid, context, coord, pname, params);
15105 }
15106 }
15107
GetTexGenxvOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,GLfixed * params)15108 void GL_APIENTRY GetTexGenxvOESContextANGLE(GLeglContext ctx,
15109 GLenum coord,
15110 GLenum pname,
15111 GLfixed *params)
15112 {
15113 Context *context = static_cast<gl::Context *>(ctx);
15114 EVENT("glGetTexGenxvOES",
15115 "context = %d, GLenum coord = %s, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR "",
15116 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
15117 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
15118
15119 if (context)
15120 {
15121 ASSERT(context == GetValidGlobalContext());
15122 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15123 bool isCallValid =
15124 (context->skipValidation() || ValidateGetTexGenxvOES(context, coord, pname, params));
15125 if (isCallValid)
15126 {
15127 context->getTexGenxv(coord, pname, params);
15128 }
15129 ANGLE_CAPTURE(GetTexGenxvOES, isCallValid, context, coord, pname, params);
15130 }
15131 }
15132
GetTexLevelParameterfvContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum pname,GLfloat * params)15133 void GL_APIENTRY GetTexLevelParameterfvContextANGLE(GLeglContext ctx,
15134 GLenum target,
15135 GLint level,
15136 GLenum pname,
15137 GLfloat *params)
15138 {
15139 Context *context = static_cast<gl::Context *>(ctx);
15140 EVENT("glGetTexLevelParameterfv",
15141 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat *params "
15142 "= 0x%016" PRIxPTR "",
15143 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
15144 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15145
15146 if (context)
15147 {
15148 ASSERT(context == GetValidGlobalContext());
15149 TextureTarget targetPacked = FromGL<TextureTarget>(target);
15150 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15151 bool isCallValid =
15152 (context->skipValidation() ||
15153 ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params));
15154 if (isCallValid)
15155 {
15156 context->getTexLevelParameterfv(targetPacked, level, pname, params);
15157 }
15158 ANGLE_CAPTURE(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname,
15159 params);
15160 }
15161 }
15162
GetTexLevelParameterivContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum pname,GLint * params)15163 void GL_APIENTRY GetTexLevelParameterivContextANGLE(GLeglContext ctx,
15164 GLenum target,
15165 GLint level,
15166 GLenum pname,
15167 GLint *params)
15168 {
15169 Context *context = static_cast<gl::Context *>(ctx);
15170 EVENT("glGetTexLevelParameteriv",
15171 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint *params = "
15172 "0x%016" PRIxPTR "",
15173 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
15174 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15175
15176 if (context)
15177 {
15178 ASSERT(context == GetValidGlobalContext());
15179 TextureTarget targetPacked = FromGL<TextureTarget>(target);
15180 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15181 bool isCallValid =
15182 (context->skipValidation() ||
15183 ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params));
15184 if (isCallValid)
15185 {
15186 context->getTexLevelParameteriv(targetPacked, level, pname, params);
15187 }
15188 ANGLE_CAPTURE(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname,
15189 params);
15190 }
15191 }
15192
GetTexParameterIivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)15193 void GL_APIENTRY GetTexParameterIivContextANGLE(GLeglContext ctx,
15194 GLenum target,
15195 GLenum pname,
15196 GLint *params)
15197 {
15198 Context *context = static_cast<gl::Context *>(ctx);
15199 EVENT("glGetTexParameterIiv",
15200 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15201 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15202 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15203
15204 if (context)
15205 {
15206 ASSERT(context == GetValidGlobalContext());
15207 TextureType targetPacked = FromGL<TextureType>(target);
15208 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15209 bool isCallValid = (context->skipValidation() ||
15210 ValidateGetTexParameterIiv(context, targetPacked, pname, params));
15211 if (isCallValid)
15212 {
15213 context->getTexParameterIiv(targetPacked, pname, params);
15214 }
15215 ANGLE_CAPTURE(GetTexParameterIiv, isCallValid, context, targetPacked, pname, params);
15216 }
15217 }
15218
GetTexParameterIivOESContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)15219 void GL_APIENTRY GetTexParameterIivOESContextANGLE(GLeglContext ctx,
15220 GLenum target,
15221 GLenum pname,
15222 GLint *params)
15223 {
15224 Context *context = static_cast<gl::Context *>(ctx);
15225 EVENT("glGetTexParameterIivOES",
15226 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15227 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15228 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15229
15230 if (context)
15231 {
15232 ASSERT(context == GetValidGlobalContext());
15233 TextureType targetPacked = FromGL<TextureType>(target);
15234 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15235 bool isCallValid = (context->skipValidation() ||
15236 ValidateGetTexParameterIivOES(context, targetPacked, pname, params));
15237 if (isCallValid)
15238 {
15239 context->getTexParameterIiv(targetPacked, pname, params);
15240 }
15241 ANGLE_CAPTURE(GetTexParameterIivOES, isCallValid, context, targetPacked, pname, params);
15242 }
15243 }
15244
GetTexParameterIuivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLuint * params)15245 void GL_APIENTRY GetTexParameterIuivContextANGLE(GLeglContext ctx,
15246 GLenum target,
15247 GLenum pname,
15248 GLuint *params)
15249 {
15250 Context *context = static_cast<gl::Context *>(ctx);
15251 EVENT("glGetTexParameterIuiv",
15252 "context = %d, GLenum target = %s, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
15253 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15254 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15255
15256 if (context)
15257 {
15258 ASSERT(context == GetValidGlobalContext());
15259 TextureType targetPacked = FromGL<TextureType>(target);
15260 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15261 bool isCallValid = (context->skipValidation() ||
15262 ValidateGetTexParameterIuiv(context, targetPacked, pname, params));
15263 if (isCallValid)
15264 {
15265 context->getTexParameterIuiv(targetPacked, pname, params);
15266 }
15267 ANGLE_CAPTURE(GetTexParameterIuiv, isCallValid, context, targetPacked, pname, params);
15268 }
15269 }
15270
GetTexParameterIuivOESContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLuint * params)15271 void GL_APIENTRY GetTexParameterIuivOESContextANGLE(GLeglContext ctx,
15272 GLenum target,
15273 GLenum pname,
15274 GLuint *params)
15275 {
15276 Context *context = static_cast<gl::Context *>(ctx);
15277 EVENT("glGetTexParameterIuivOES",
15278 "context = %d, GLenum target = %s, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
15279 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15280 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15281
15282 if (context)
15283 {
15284 ASSERT(context == GetValidGlobalContext());
15285 TextureType targetPacked = FromGL<TextureType>(target);
15286 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15287 bool isCallValid = (context->skipValidation() ||
15288 ValidateGetTexParameterIuivOES(context, targetPacked, pname, params));
15289 if (isCallValid)
15290 {
15291 context->getTexParameterIuiv(targetPacked, pname, params);
15292 }
15293 ANGLE_CAPTURE(GetTexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
15294 }
15295 }
15296
GetTexParameterfvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfloat * params)15297 void GL_APIENTRY GetTexParameterfvContextANGLE(GLeglContext ctx,
15298 GLenum target,
15299 GLenum pname,
15300 GLfloat *params)
15301 {
15302 Context *context = static_cast<gl::Context *>(ctx);
15303 EVENT("glGetTexParameterfv",
15304 "context = %d, GLenum target = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
15305 "",
15306 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15307 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15308
15309 if (context)
15310 {
15311 ASSERT(context == GetValidGlobalContext());
15312 TextureType targetPacked = FromGL<TextureType>(target);
15313 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15314 bool isCallValid = (context->skipValidation() ||
15315 ValidateGetTexParameterfv(context, targetPacked, pname, params));
15316 if (isCallValid)
15317 {
15318 context->getTexParameterfv(targetPacked, pname, params);
15319 }
15320 ANGLE_CAPTURE(GetTexParameterfv, isCallValid, context, targetPacked, pname, params);
15321 }
15322 }
15323
GetTexParameterivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint * params)15324 void GL_APIENTRY GetTexParameterivContextANGLE(GLeglContext ctx,
15325 GLenum target,
15326 GLenum pname,
15327 GLint *params)
15328 {
15329 Context *context = static_cast<gl::Context *>(ctx);
15330 EVENT("glGetTexParameteriv",
15331 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15332 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15333 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15334
15335 if (context)
15336 {
15337 ASSERT(context == GetValidGlobalContext());
15338 TextureType targetPacked = FromGL<TextureType>(target);
15339 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15340 bool isCallValid = (context->skipValidation() ||
15341 ValidateGetTexParameteriv(context, targetPacked, pname, params));
15342 if (isCallValid)
15343 {
15344 context->getTexParameteriv(targetPacked, pname, params);
15345 }
15346 ANGLE_CAPTURE(GetTexParameteriv, isCallValid, context, targetPacked, pname, params);
15347 }
15348 }
15349
GetTexParameterxvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfixed * params)15350 void GL_APIENTRY GetTexParameterxvContextANGLE(GLeglContext ctx,
15351 GLenum target,
15352 GLenum pname,
15353 GLfixed *params)
15354 {
15355 Context *context = static_cast<gl::Context *>(ctx);
15356 EVENT("glGetTexParameterxv",
15357 "context = %d, GLenum target = %s, GLenum pname = %s, GLfixed *params = 0x%016" PRIxPTR
15358 "",
15359 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
15360 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
15361
15362 if (context)
15363 {
15364 ASSERT(context == GetValidGlobalContext());
15365 TextureType targetPacked = FromGL<TextureType>(target);
15366 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15367 bool isCallValid = (context->skipValidation() ||
15368 ValidateGetTexParameterxv(context, targetPacked, pname, params));
15369 if (isCallValid)
15370 {
15371 context->getTexParameterxv(targetPacked, pname, params);
15372 }
15373 ANGLE_CAPTURE(GetTexParameterxv, isCallValid, context, targetPacked, pname, params);
15374 }
15375 }
15376
GetTransformFeedbackVaryingContextANGLE(GLeglContext ctx,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLsizei * size,GLenum * type,GLchar * name)15377 void GL_APIENTRY GetTransformFeedbackVaryingContextANGLE(GLeglContext ctx,
15378 GLuint program,
15379 GLuint index,
15380 GLsizei bufSize,
15381 GLsizei *length,
15382 GLsizei *size,
15383 GLenum *type,
15384 GLchar *name)
15385 {
15386 Context *context = static_cast<gl::Context *>(ctx);
15387 EVENT("glGetTransformFeedbackVarying",
15388 "context = %d, GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei "
15389 "*length = 0x%016" PRIxPTR ", GLsizei *size = 0x%016" PRIxPTR
15390 ", GLenum *type = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
15391 CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
15392 (uintptr_t)type, (uintptr_t)name);
15393
15394 if (context)
15395 {
15396 ASSERT(context == GetValidGlobalContext());
15397 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15398 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15399 bool isCallValid = (context->skipValidation() ||
15400 ValidateGetTransformFeedbackVarying(context, programPacked, index,
15401 bufSize, length, size, type, name));
15402 if (isCallValid)
15403 {
15404 context->getTransformFeedbackVarying(programPacked, index, bufSize, length, size, type,
15405 name);
15406 }
15407 ANGLE_CAPTURE(GetTransformFeedbackVarying, isCallValid, context, programPacked, index,
15408 bufSize, length, size, type, name);
15409 }
15410 }
15411
GetTranslatedShaderSourceANGLEContextANGLE(GLeglContext ctx,GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * source)15412 void GL_APIENTRY GetTranslatedShaderSourceANGLEContextANGLE(GLeglContext ctx,
15413 GLuint shader,
15414 GLsizei bufsize,
15415 GLsizei *length,
15416 GLchar *source)
15417 {
15418 Context *context = static_cast<gl::Context *>(ctx);
15419 EVENT("glGetTranslatedShaderSourceANGLE",
15420 "context = %d, GLuint shader = %u, GLsizei bufsize = %d, GLsizei *length = 0x%016" PRIxPTR
15421 ", GLchar *source = 0x%016" PRIxPTR "",
15422 CID(context), shader, bufsize, (uintptr_t)length, (uintptr_t)source);
15423
15424 if (context)
15425 {
15426 ASSERT(context == GetValidGlobalContext());
15427 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
15428 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15429 bool isCallValid =
15430 (context->skipValidation() || ValidateGetTranslatedShaderSourceANGLE(
15431 context, shaderPacked, bufsize, length, source));
15432 if (isCallValid)
15433 {
15434 context->getTranslatedShaderSource(shaderPacked, bufsize, length, source);
15435 }
15436 ANGLE_CAPTURE(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked, bufsize,
15437 length, source);
15438 }
15439 }
15440
GetUniformBlockIndexContextANGLE(GLeglContext ctx,GLuint program,const GLchar * uniformBlockName)15441 GLuint GL_APIENTRY GetUniformBlockIndexContextANGLE(GLeglContext ctx,
15442 GLuint program,
15443 const GLchar *uniformBlockName)
15444 {
15445 Context *context = static_cast<gl::Context *>(ctx);
15446 EVENT("glGetUniformBlockIndex",
15447 "context = %d, GLuint program = %u, const GLchar *uniformBlockName = 0x%016" PRIxPTR "",
15448 CID(context), program, (uintptr_t)uniformBlockName);
15449
15450 GLuint returnValue;
15451 if (context)
15452 {
15453 ASSERT(context == GetValidGlobalContext());
15454 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15455 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15456 bool isCallValid = (context->skipValidation() ||
15457 ValidateGetUniformBlockIndex(context, programPacked, uniformBlockName));
15458 if (isCallValid)
15459 {
15460 returnValue = context->getUniformBlockIndex(programPacked, uniformBlockName);
15461 }
15462 else
15463 {
15464 returnValue = GetDefaultReturnValue<EntryPoint::GetUniformBlockIndex, GLuint>();
15465 }
15466 ANGLE_CAPTURE(GetUniformBlockIndex, isCallValid, context, programPacked, uniformBlockName,
15467 returnValue);
15468 }
15469 else
15470 {
15471 returnValue = GetDefaultReturnValue<EntryPoint::GetUniformBlockIndex, GLuint>();
15472 }
15473 return returnValue;
15474 }
15475
GetUniformIndicesContextANGLE(GLeglContext ctx,GLuint program,GLsizei uniformCount,const GLchar * const * uniformNames,GLuint * uniformIndices)15476 void GL_APIENTRY GetUniformIndicesContextANGLE(GLeglContext ctx,
15477 GLuint program,
15478 GLsizei uniformCount,
15479 const GLchar *const *uniformNames,
15480 GLuint *uniformIndices)
15481 {
15482 Context *context = static_cast<gl::Context *>(ctx);
15483 EVENT("glGetUniformIndices",
15484 "context = %d, GLuint program = %u, GLsizei uniformCount = %d, const GLchar "
15485 "*const*uniformNames = 0x%016" PRIxPTR ", GLuint *uniformIndices = 0x%016" PRIxPTR "",
15486 CID(context), program, uniformCount, (uintptr_t)uniformNames, (uintptr_t)uniformIndices);
15487
15488 if (context)
15489 {
15490 ASSERT(context == GetValidGlobalContext());
15491 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15492 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15493 bool isCallValid = (context->skipValidation() ||
15494 ValidateGetUniformIndices(context, programPacked, uniformCount,
15495 uniformNames, uniformIndices));
15496 if (isCallValid)
15497 {
15498 context->getUniformIndices(programPacked, uniformCount, uniformNames, uniformIndices);
15499 }
15500 ANGLE_CAPTURE(GetUniformIndices, isCallValid, context, programPacked, uniformCount,
15501 uniformNames, uniformIndices);
15502 }
15503 }
15504
GetUniformLocationContextANGLE(GLeglContext ctx,GLuint program,const GLchar * name)15505 GLint GL_APIENTRY GetUniformLocationContextANGLE(GLeglContext ctx,
15506 GLuint program,
15507 const GLchar *name)
15508 {
15509 Context *context = static_cast<gl::Context *>(ctx);
15510 EVENT("glGetUniformLocation",
15511 "context = %d, GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR "", CID(context),
15512 program, (uintptr_t)name);
15513
15514 GLint returnValue;
15515 if (context)
15516 {
15517 ASSERT(context == GetValidGlobalContext());
15518 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15519 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15520 bool isCallValid =
15521 (context->skipValidation() || ValidateGetUniformLocation(context, programPacked, name));
15522 if (isCallValid)
15523 {
15524 returnValue = context->getUniformLocation(programPacked, name);
15525 }
15526 else
15527 {
15528 returnValue = GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
15529 }
15530 ANGLE_CAPTURE(GetUniformLocation, isCallValid, context, programPacked, name, returnValue);
15531 }
15532 else
15533 {
15534 returnValue = GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
15535 }
15536 return returnValue;
15537 }
15538
GetUniformfvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLfloat * params)15539 void GL_APIENTRY GetUniformfvContextANGLE(GLeglContext ctx,
15540 GLuint program,
15541 GLint location,
15542 GLfloat *params)
15543 {
15544 Context *context = static_cast<gl::Context *>(ctx);
15545 EVENT("glGetUniformfv",
15546 "context = %d, GLuint program = %u, GLint location = %d, GLfloat *params = 0x%016" PRIxPTR
15547 "",
15548 CID(context), program, location, (uintptr_t)params);
15549
15550 if (context)
15551 {
15552 ASSERT(context == GetValidGlobalContext());
15553 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15554 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15555 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15556 bool isCallValid = (context->skipValidation() ||
15557 ValidateGetUniformfv(context, programPacked, locationPacked, params));
15558 if (isCallValid)
15559 {
15560 context->getUniformfv(programPacked, locationPacked, params);
15561 }
15562 ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
15563 }
15564 }
15565
GetUniformivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLint * params)15566 void GL_APIENTRY GetUniformivContextANGLE(GLeglContext ctx,
15567 GLuint program,
15568 GLint location,
15569 GLint *params)
15570 {
15571 Context *context = static_cast<gl::Context *>(ctx);
15572 EVENT("glGetUniformiv",
15573 "context = %d, GLuint program = %u, GLint location = %d, GLint *params = 0x%016" PRIxPTR
15574 "",
15575 CID(context), program, location, (uintptr_t)params);
15576
15577 if (context)
15578 {
15579 ASSERT(context == GetValidGlobalContext());
15580 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15581 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15582 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15583 bool isCallValid = (context->skipValidation() ||
15584 ValidateGetUniformiv(context, programPacked, locationPacked, params));
15585 if (isCallValid)
15586 {
15587 context->getUniformiv(programPacked, locationPacked, params);
15588 }
15589 ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
15590 }
15591 }
15592
GetUniformuivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLuint * params)15593 void GL_APIENTRY GetUniformuivContextANGLE(GLeglContext ctx,
15594 GLuint program,
15595 GLint location,
15596 GLuint *params)
15597 {
15598 Context *context = static_cast<gl::Context *>(ctx);
15599 EVENT("glGetUniformuiv",
15600 "context = %d, GLuint program = %u, GLint location = %d, GLuint *params = 0x%016" PRIxPTR
15601 "",
15602 CID(context), program, location, (uintptr_t)params);
15603
15604 if (context)
15605 {
15606 ASSERT(context == GetValidGlobalContext());
15607 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15608 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15609 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15610 bool isCallValid = (context->skipValidation() ||
15611 ValidateGetUniformuiv(context, programPacked, locationPacked, params));
15612 if (isCallValid)
15613 {
15614 context->getUniformuiv(programPacked, locationPacked, params);
15615 }
15616 ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, locationPacked, params);
15617 }
15618 }
15619
GetUnsignedBytevEXTContextANGLE(GLeglContext ctx,GLenum pname,GLubyte * data)15620 void GL_APIENTRY GetUnsignedBytevEXTContextANGLE(GLeglContext ctx, GLenum pname, GLubyte *data)
15621 {
15622 Context *context = static_cast<gl::Context *>(ctx);
15623 EVENT("glGetUnsignedBytevEXT",
15624 "context = %d, GLenum pname = %s, GLubyte *data = 0x%016" PRIxPTR "", CID(context),
15625 GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
15626
15627 if (context)
15628 {
15629 ASSERT(context == GetValidGlobalContext());
15630 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15631 bool isCallValid =
15632 (context->skipValidation() || ValidateGetUnsignedBytevEXT(context, pname, data));
15633 if (isCallValid)
15634 {
15635 context->getUnsignedBytev(pname, data);
15636 }
15637 ANGLE_CAPTURE(GetUnsignedBytevEXT, isCallValid, context, pname, data);
15638 }
15639 }
15640
GetUnsignedBytei_vEXTContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLubyte * data)15641 void GL_APIENTRY GetUnsignedBytei_vEXTContextANGLE(GLeglContext ctx,
15642 GLenum target,
15643 GLuint index,
15644 GLubyte *data)
15645 {
15646 Context *context = static_cast<gl::Context *>(ctx);
15647 EVENT("glGetUnsignedBytei_vEXT",
15648 "context = %d, GLenum target = %s, GLuint index = %u, GLubyte *data = 0x%016" PRIxPTR "",
15649 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, (uintptr_t)data);
15650
15651 if (context)
15652 {
15653 ASSERT(context == GetValidGlobalContext());
15654 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15655 bool isCallValid = (context->skipValidation() ||
15656 ValidateGetUnsignedBytei_vEXT(context, target, index, data));
15657 if (isCallValid)
15658 {
15659 context->getUnsignedBytei_v(target, index, data);
15660 }
15661 ANGLE_CAPTURE(GetUnsignedBytei_vEXT, isCallValid, context, target, index, data);
15662 }
15663 }
15664
GetVertexAttribIivContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLint * params)15665 void GL_APIENTRY GetVertexAttribIivContextANGLE(GLeglContext ctx,
15666 GLuint index,
15667 GLenum pname,
15668 GLint *params)
15669 {
15670 Context *context = static_cast<gl::Context *>(ctx);
15671 EVENT("glGetVertexAttribIiv",
15672 "context = %d, GLuint index = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15673 CID(context), index, GLenumToString(GLenumGroup::VertexAttribEnum, pname),
15674 (uintptr_t)params);
15675
15676 if (context)
15677 {
15678 ASSERT(context == GetValidGlobalContext());
15679 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15680 bool isCallValid = (context->skipValidation() ||
15681 ValidateGetVertexAttribIiv(context, index, pname, params));
15682 if (isCallValid)
15683 {
15684 context->getVertexAttribIiv(index, pname, params);
15685 }
15686 ANGLE_CAPTURE(GetVertexAttribIiv, isCallValid, context, index, pname, params);
15687 }
15688 }
15689
GetVertexAttribIuivContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLuint * params)15690 void GL_APIENTRY GetVertexAttribIuivContextANGLE(GLeglContext ctx,
15691 GLuint index,
15692 GLenum pname,
15693 GLuint *params)
15694 {
15695 Context *context = static_cast<gl::Context *>(ctx);
15696 EVENT("glGetVertexAttribIuiv",
15697 "context = %d, GLuint index = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
15698 CID(context), index, GLenumToString(GLenumGroup::VertexAttribEnum, pname),
15699 (uintptr_t)params);
15700
15701 if (context)
15702 {
15703 ASSERT(context == GetValidGlobalContext());
15704 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15705 bool isCallValid = (context->skipValidation() ||
15706 ValidateGetVertexAttribIuiv(context, index, pname, params));
15707 if (isCallValid)
15708 {
15709 context->getVertexAttribIuiv(index, pname, params);
15710 }
15711 ANGLE_CAPTURE(GetVertexAttribIuiv, isCallValid, context, index, pname, params);
15712 }
15713 }
15714
GetVertexAttribPointervContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,void ** pointer)15715 void GL_APIENTRY GetVertexAttribPointervContextANGLE(GLeglContext ctx,
15716 GLuint index,
15717 GLenum pname,
15718 void **pointer)
15719 {
15720 Context *context = static_cast<gl::Context *>(ctx);
15721 EVENT("glGetVertexAttribPointerv",
15722 "context = %d, GLuint index = %u, GLenum pname = %s, void **pointer = 0x%016" PRIxPTR "",
15723 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname),
15724 (uintptr_t)pointer);
15725
15726 if (context)
15727 {
15728 ASSERT(context == GetValidGlobalContext());
15729 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15730 bool isCallValid = (context->skipValidation() ||
15731 ValidateGetVertexAttribPointerv(context, index, pname, pointer));
15732 if (isCallValid)
15733 {
15734 context->getVertexAttribPointerv(index, pname, pointer);
15735 }
15736 ANGLE_CAPTURE(GetVertexAttribPointerv, isCallValid, context, index, pname, pointer);
15737 }
15738 }
15739
GetVertexAttribfvContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLfloat * params)15740 void GL_APIENTRY GetVertexAttribfvContextANGLE(GLeglContext ctx,
15741 GLuint index,
15742 GLenum pname,
15743 GLfloat *params)
15744 {
15745 Context *context = static_cast<gl::Context *>(ctx);
15746 EVENT("glGetVertexAttribfv",
15747 "context = %d, GLuint index = %u, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
15748 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
15749
15750 if (context)
15751 {
15752 ASSERT(context == GetValidGlobalContext());
15753 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15754 bool isCallValid =
15755 (context->skipValidation() || ValidateGetVertexAttribfv(context, index, pname, params));
15756 if (isCallValid)
15757 {
15758 context->getVertexAttribfv(index, pname, params);
15759 }
15760 ANGLE_CAPTURE(GetVertexAttribfv, isCallValid, context, index, pname, params);
15761 }
15762 }
15763
GetVertexAttribivContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLint * params)15764 void GL_APIENTRY GetVertexAttribivContextANGLE(GLeglContext ctx,
15765 GLuint index,
15766 GLenum pname,
15767 GLint *params)
15768 {
15769 Context *context = static_cast<gl::Context *>(ctx);
15770 EVENT("glGetVertexAttribiv",
15771 "context = %d, GLuint index = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
15772 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
15773
15774 if (context)
15775 {
15776 ASSERT(context == GetValidGlobalContext());
15777 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15778 bool isCallValid =
15779 (context->skipValidation() || ValidateGetVertexAttribiv(context, index, pname, params));
15780 if (isCallValid)
15781 {
15782 context->getVertexAttribiv(index, pname, params);
15783 }
15784 ANGLE_CAPTURE(GetVertexAttribiv, isCallValid, context, index, pname, params);
15785 }
15786 }
15787
GetnUniformfvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLfloat * params)15788 void GL_APIENTRY GetnUniformfvContextANGLE(GLeglContext ctx,
15789 GLuint program,
15790 GLint location,
15791 GLsizei bufSize,
15792 GLfloat *params)
15793 {
15794 Context *context = static_cast<gl::Context *>(ctx);
15795 EVENT("glGetnUniformfv",
15796 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLfloat "
15797 "*params = 0x%016" PRIxPTR "",
15798 CID(context), program, location, bufSize, (uintptr_t)params);
15799
15800 if (context)
15801 {
15802 ASSERT(context == GetValidGlobalContext());
15803 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15804 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15805 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15806 bool isCallValid =
15807 (context->skipValidation() ||
15808 ValidateGetnUniformfv(context, programPacked, locationPacked, bufSize, params));
15809 if (isCallValid)
15810 {
15811 context->getnUniformfv(programPacked, locationPacked, bufSize, params);
15812 }
15813 ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, locationPacked, bufSize,
15814 params);
15815 }
15816 }
15817
GetnUniformfvEXTContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLfloat * params)15818 void GL_APIENTRY GetnUniformfvEXTContextANGLE(GLeglContext ctx,
15819 GLuint program,
15820 GLint location,
15821 GLsizei bufSize,
15822 GLfloat *params)
15823 {
15824 Context *context = static_cast<gl::Context *>(ctx);
15825 EVENT("glGetnUniformfvEXT",
15826 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLfloat "
15827 "*params = 0x%016" PRIxPTR "",
15828 CID(context), program, location, bufSize, (uintptr_t)params);
15829
15830 if (context)
15831 {
15832 ASSERT(context == GetValidGlobalContext());
15833 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15834 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15835 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15836 bool isCallValid =
15837 (context->skipValidation() ||
15838 ValidateGetnUniformfvEXT(context, programPacked, locationPacked, bufSize, params));
15839 if (isCallValid)
15840 {
15841 context->getnUniformfv(programPacked, locationPacked, bufSize, params);
15842 }
15843 ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
15844 bufSize, params);
15845 }
15846 }
15847
GetnUniformivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLint * params)15848 void GL_APIENTRY GetnUniformivContextANGLE(GLeglContext ctx,
15849 GLuint program,
15850 GLint location,
15851 GLsizei bufSize,
15852 GLint *params)
15853 {
15854 Context *context = static_cast<gl::Context *>(ctx);
15855 EVENT("glGetnUniformiv",
15856 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLint "
15857 "*params = 0x%016" PRIxPTR "",
15858 CID(context), program, location, bufSize, (uintptr_t)params);
15859
15860 if (context)
15861 {
15862 ASSERT(context == GetValidGlobalContext());
15863 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15864 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15865 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15866 bool isCallValid =
15867 (context->skipValidation() ||
15868 ValidateGetnUniformiv(context, programPacked, locationPacked, bufSize, params));
15869 if (isCallValid)
15870 {
15871 context->getnUniformiv(programPacked, locationPacked, bufSize, params);
15872 }
15873 ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, locationPacked, bufSize,
15874 params);
15875 }
15876 }
15877
GetnUniformivEXTContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLint * params)15878 void GL_APIENTRY GetnUniformivEXTContextANGLE(GLeglContext ctx,
15879 GLuint program,
15880 GLint location,
15881 GLsizei bufSize,
15882 GLint *params)
15883 {
15884 Context *context = static_cast<gl::Context *>(ctx);
15885 EVENT("glGetnUniformivEXT",
15886 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLint "
15887 "*params = 0x%016" PRIxPTR "",
15888 CID(context), program, location, bufSize, (uintptr_t)params);
15889
15890 if (context)
15891 {
15892 ASSERT(context == GetValidGlobalContext());
15893 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15894 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15895 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15896 bool isCallValid =
15897 (context->skipValidation() ||
15898 ValidateGetnUniformivEXT(context, programPacked, locationPacked, bufSize, params));
15899 if (isCallValid)
15900 {
15901 context->getnUniformiv(programPacked, locationPacked, bufSize, params);
15902 }
15903 ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
15904 bufSize, params);
15905 }
15906 }
15907
GetnUniformuivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLuint * params)15908 void GL_APIENTRY GetnUniformuivContextANGLE(GLeglContext ctx,
15909 GLuint program,
15910 GLint location,
15911 GLsizei bufSize,
15912 GLuint *params)
15913 {
15914 Context *context = static_cast<gl::Context *>(ctx);
15915 EVENT("glGetnUniformuiv",
15916 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLuint "
15917 "*params = 0x%016" PRIxPTR "",
15918 CID(context), program, location, bufSize, (uintptr_t)params);
15919
15920 if (context)
15921 {
15922 ASSERT(context == GetValidGlobalContext());
15923 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
15924 UniformLocation locationPacked = FromGL<UniformLocation>(location);
15925 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15926 bool isCallValid =
15927 (context->skipValidation() ||
15928 ValidateGetnUniformuiv(context, programPacked, locationPacked, bufSize, params));
15929 if (isCallValid)
15930 {
15931 context->getnUniformuiv(programPacked, locationPacked, bufSize, params);
15932 }
15933 ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, locationPacked, bufSize,
15934 params);
15935 }
15936 }
15937
HintContextANGLE(GLeglContext ctx,GLenum target,GLenum mode)15938 void GL_APIENTRY HintContextANGLE(GLeglContext ctx, GLenum target, GLenum mode)
15939 {
15940 Context *context = static_cast<gl::Context *>(ctx);
15941 EVENT("glHint", "context = %d, GLenum target = %s, GLenum mode = %s", CID(context),
15942 GLenumToString(GLenumGroup::HintTarget, target),
15943 GLenumToString(GLenumGroup::HintMode, mode));
15944
15945 if (context)
15946 {
15947 ASSERT(context == GetValidGlobalContext());
15948 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15949 bool isCallValid = (context->skipValidation() || ValidateHint(context, target, mode));
15950 if (isCallValid)
15951 {
15952 context->hint(target, mode);
15953 }
15954 ANGLE_CAPTURE(Hint, isCallValid, context, target, mode);
15955 }
15956 }
15957
ImportMemoryFdEXTContextANGLE(GLeglContext ctx,GLuint memory,GLuint64 size,GLenum handleType,GLint fd)15958 void GL_APIENTRY ImportMemoryFdEXTContextANGLE(GLeglContext ctx,
15959 GLuint memory,
15960 GLuint64 size,
15961 GLenum handleType,
15962 GLint fd)
15963 {
15964 Context *context = static_cast<gl::Context *>(ctx);
15965 EVENT("glImportMemoryFdEXT",
15966 "context = %d, GLuint memory = %u, GLuint64 size = %llu, GLenum handleType = %s, GLint "
15967 "fd = %d",
15968 CID(context), memory, static_cast<unsigned long long>(size),
15969 GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
15970
15971 if (context)
15972 {
15973 ASSERT(context == GetValidGlobalContext());
15974 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
15975 HandleType handleTypePacked = FromGL<HandleType>(handleType);
15976 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
15977 bool isCallValid =
15978 (context->skipValidation() ||
15979 ValidateImportMemoryFdEXT(context, memoryPacked, size, handleTypePacked, fd));
15980 if (isCallValid)
15981 {
15982 context->importMemoryFd(memoryPacked, size, handleTypePacked, fd);
15983 }
15984 ANGLE_CAPTURE(ImportMemoryFdEXT, isCallValid, context, memoryPacked, size, handleTypePacked,
15985 fd);
15986 }
15987 }
15988
ImportSemaphoreFdEXTContextANGLE(GLeglContext ctx,GLuint semaphore,GLenum handleType,GLint fd)15989 void GL_APIENTRY ImportSemaphoreFdEXTContextANGLE(GLeglContext ctx,
15990 GLuint semaphore,
15991 GLenum handleType,
15992 GLint fd)
15993 {
15994 Context *context = static_cast<gl::Context *>(ctx);
15995 EVENT("glImportSemaphoreFdEXT",
15996 "context = %d, GLuint semaphore = %u, GLenum handleType = %s, GLint fd = %d",
15997 CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
15998
15999 if (context)
16000 {
16001 ASSERT(context == GetValidGlobalContext());
16002 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
16003 HandleType handleTypePacked = FromGL<HandleType>(handleType);
16004 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16005 bool isCallValid =
16006 (context->skipValidation() ||
16007 ValidateImportSemaphoreFdEXT(context, semaphorePacked, handleTypePacked, fd));
16008 if (isCallValid)
16009 {
16010 context->importSemaphoreFd(semaphorePacked, handleTypePacked, fd);
16011 }
16012 ANGLE_CAPTURE(ImportSemaphoreFdEXT, isCallValid, context, semaphorePacked, handleTypePacked,
16013 fd);
16014 }
16015 }
16016
InsertEventMarkerEXTContextANGLE(GLeglContext ctx,GLsizei length,const GLchar * marker)16017 void GL_APIENTRY InsertEventMarkerEXTContextANGLE(GLeglContext ctx,
16018 GLsizei length,
16019 const GLchar *marker)
16020 {
16021 Context *context = static_cast<gl::Context *>(ctx);
16022 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
16023 // It can interfere with the debug events being set by the caller.
16024 // EVENT("glInsertEventMarkerEXT", "context = %d, GLsizei length = %d, const GLchar *marker =
16025 // 0x%016" PRIxPTR "", CID(context), length, (uintptr_t)marker);
16026
16027 if (context)
16028 {
16029 ASSERT(context == GetValidGlobalContext());
16030 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16031 bool isCallValid =
16032 (context->skipValidation() || ValidateInsertEventMarkerEXT(context, length, marker));
16033 if (isCallValid)
16034 {
16035 context->insertEventMarker(length, marker);
16036 }
16037 ANGLE_CAPTURE(InsertEventMarkerEXT, isCallValid, context, length, marker);
16038 }
16039 }
16040
InvalidateFramebufferContextANGLE(GLeglContext ctx,GLenum target,GLsizei numAttachments,const GLenum * attachments)16041 void GL_APIENTRY InvalidateFramebufferContextANGLE(GLeglContext ctx,
16042 GLenum target,
16043 GLsizei numAttachments,
16044 const GLenum *attachments)
16045 {
16046 Context *context = static_cast<gl::Context *>(ctx);
16047 EVENT("glInvalidateFramebuffer",
16048 "context = %d, GLenum target = %s, GLsizei numAttachments = %d, const GLenum "
16049 "*attachments = 0x%016" PRIxPTR "",
16050 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments,
16051 (uintptr_t)attachments);
16052
16053 if (context)
16054 {
16055 ASSERT(context == GetValidGlobalContext());
16056 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16057 bool isCallValid =
16058 (context->skipValidation() ||
16059 ValidateInvalidateFramebuffer(context, target, numAttachments, attachments));
16060 if (isCallValid)
16061 {
16062 context->invalidateFramebuffer(target, numAttachments, attachments);
16063 }
16064 ANGLE_CAPTURE(InvalidateFramebuffer, isCallValid, context, target, numAttachments,
16065 attachments);
16066 }
16067 }
16068
InvalidateSubFramebufferContextANGLE(GLeglContext ctx,GLenum target,GLsizei numAttachments,const GLenum * attachments,GLint x,GLint y,GLsizei width,GLsizei height)16069 void GL_APIENTRY InvalidateSubFramebufferContextANGLE(GLeglContext ctx,
16070 GLenum target,
16071 GLsizei numAttachments,
16072 const GLenum *attachments,
16073 GLint x,
16074 GLint y,
16075 GLsizei width,
16076 GLsizei height)
16077 {
16078 Context *context = static_cast<gl::Context *>(ctx);
16079 EVENT("glInvalidateSubFramebuffer",
16080 "context = %d, GLenum target = %s, GLsizei numAttachments = %d, const GLenum "
16081 "*attachments = 0x%016" PRIxPTR
16082 ", GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d",
16083 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), numAttachments,
16084 (uintptr_t)attachments, x, y, width, height);
16085
16086 if (context)
16087 {
16088 ASSERT(context == GetValidGlobalContext());
16089 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16090 bool isCallValid = (context->skipValidation() ||
16091 ValidateInvalidateSubFramebuffer(context, target, numAttachments,
16092 attachments, x, y, width, height));
16093 if (isCallValid)
16094 {
16095 context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
16096 height);
16097 }
16098 ANGLE_CAPTURE(InvalidateSubFramebuffer, isCallValid, context, target, numAttachments,
16099 attachments, x, y, width, height);
16100 }
16101 }
16102
IsBufferContextANGLE(GLeglContext ctx,GLuint buffer)16103 GLboolean GL_APIENTRY IsBufferContextANGLE(GLeglContext ctx, GLuint buffer)
16104 {
16105 Context *context = static_cast<gl::Context *>(ctx);
16106 EVENT("glIsBuffer", "context = %d, GLuint buffer = %u", CID(context), buffer);
16107
16108 GLboolean returnValue;
16109 if (context)
16110 {
16111 ASSERT(context == GetValidGlobalContext());
16112 BufferID bufferPacked = FromGL<BufferID>(buffer);
16113 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16114 bool isCallValid = (context->skipValidation() || ValidateIsBuffer(context, bufferPacked));
16115 if (isCallValid)
16116 {
16117 returnValue = context->isBuffer(bufferPacked);
16118 }
16119 else
16120 {
16121 returnValue = GetDefaultReturnValue<EntryPoint::IsBuffer, GLboolean>();
16122 }
16123 ANGLE_CAPTURE(IsBuffer, isCallValid, context, bufferPacked, returnValue);
16124 }
16125 else
16126 {
16127 returnValue = GetDefaultReturnValue<EntryPoint::IsBuffer, GLboolean>();
16128 }
16129 return returnValue;
16130 }
16131
IsEnabledContextANGLE(GLeglContext ctx,GLenum cap)16132 GLboolean GL_APIENTRY IsEnabledContextANGLE(GLeglContext ctx, GLenum cap)
16133 {
16134 Context *context = static_cast<gl::Context *>(ctx);
16135 EVENT("glIsEnabled", "context = %d, GLenum cap = %s", CID(context),
16136 GLenumToString(GLenumGroup::EnableCap, cap));
16137
16138 GLboolean returnValue;
16139 if (context)
16140 {
16141 ASSERT(context == GetValidGlobalContext());
16142 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16143 bool isCallValid = (context->skipValidation() || ValidateIsEnabled(context, cap));
16144 if (isCallValid)
16145 {
16146 returnValue = context->isEnabled(cap);
16147 }
16148 else
16149 {
16150 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
16151 }
16152 ANGLE_CAPTURE(IsEnabled, isCallValid, context, cap, returnValue);
16153 }
16154 else
16155 {
16156 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
16157 }
16158 return returnValue;
16159 }
16160
IsEnablediContextANGLE(GLeglContext ctx,GLenum target,GLuint index)16161 GLboolean GL_APIENTRY IsEnablediContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
16162 {
16163 Context *context = static_cast<gl::Context *>(ctx);
16164 EVENT("glIsEnabledi", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
16165 GLenumToString(GLenumGroup::EnableCap, target), index);
16166
16167 GLboolean returnValue;
16168 if (context)
16169 {
16170 ASSERT(context == GetValidGlobalContext());
16171 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16172 bool isCallValid =
16173 (context->skipValidation() || ValidateIsEnabledi(context, target, index));
16174 if (isCallValid)
16175 {
16176 returnValue = context->isEnabledi(target, index);
16177 }
16178 else
16179 {
16180 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabledi, GLboolean>();
16181 }
16182 ANGLE_CAPTURE(IsEnabledi, isCallValid, context, target, index, returnValue);
16183 }
16184 else
16185 {
16186 returnValue = GetDefaultReturnValue<EntryPoint::IsEnabledi, GLboolean>();
16187 }
16188 return returnValue;
16189 }
16190
IsEnablediEXTContextANGLE(GLeglContext ctx,GLenum target,GLuint index)16191 GLboolean GL_APIENTRY IsEnablediEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
16192 {
16193 Context *context = static_cast<gl::Context *>(ctx);
16194 EVENT("glIsEnablediEXT", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
16195 GLenumToString(GLenumGroup::EnableCap, target), index);
16196
16197 GLboolean returnValue;
16198 if (context)
16199 {
16200 ASSERT(context == GetValidGlobalContext());
16201 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16202 bool isCallValid =
16203 (context->skipValidation() || ValidateIsEnablediEXT(context, target, index));
16204 if (isCallValid)
16205 {
16206 returnValue = context->isEnabledi(target, index);
16207 }
16208 else
16209 {
16210 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediEXT, GLboolean>();
16211 }
16212 ANGLE_CAPTURE(IsEnablediEXT, isCallValid, context, target, index, returnValue);
16213 }
16214 else
16215 {
16216 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediEXT, GLboolean>();
16217 }
16218 return returnValue;
16219 }
16220
IsEnablediOESContextANGLE(GLeglContext ctx,GLenum target,GLuint index)16221 GLboolean GL_APIENTRY IsEnablediOESContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
16222 {
16223 Context *context = static_cast<gl::Context *>(ctx);
16224 EVENT("glIsEnablediOES", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
16225 GLenumToString(GLenumGroup::EnableCap, target), index);
16226
16227 GLboolean returnValue;
16228 if (context)
16229 {
16230 ASSERT(context == GetValidGlobalContext());
16231 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16232 bool isCallValid =
16233 (context->skipValidation() || ValidateIsEnablediOES(context, target, index));
16234 if (isCallValid)
16235 {
16236 returnValue = context->isEnabledi(target, index);
16237 }
16238 else
16239 {
16240 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediOES, GLboolean>();
16241 }
16242 ANGLE_CAPTURE(IsEnablediOES, isCallValid, context, target, index, returnValue);
16243 }
16244 else
16245 {
16246 returnValue = GetDefaultReturnValue<EntryPoint::IsEnablediOES, GLboolean>();
16247 }
16248 return returnValue;
16249 }
16250
IsFenceNVContextANGLE(GLeglContext ctx,GLuint fence)16251 GLboolean GL_APIENTRY IsFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
16252 {
16253 Context *context = static_cast<gl::Context *>(ctx);
16254 EVENT("glIsFenceNV", "context = %d, GLuint fence = %u", CID(context), fence);
16255
16256 GLboolean returnValue;
16257 if (context)
16258 {
16259 ASSERT(context == GetValidGlobalContext());
16260 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
16261 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16262 bool isCallValid = (context->skipValidation() || ValidateIsFenceNV(context, fencePacked));
16263 if (isCallValid)
16264 {
16265 returnValue = context->isFenceNV(fencePacked);
16266 }
16267 else
16268 {
16269 returnValue = GetDefaultReturnValue<EntryPoint::IsFenceNV, GLboolean>();
16270 }
16271 ANGLE_CAPTURE(IsFenceNV, isCallValid, context, fencePacked, returnValue);
16272 }
16273 else
16274 {
16275 returnValue = GetDefaultReturnValue<EntryPoint::IsFenceNV, GLboolean>();
16276 }
16277 return returnValue;
16278 }
16279
IsFramebufferContextANGLE(GLeglContext ctx,GLuint framebuffer)16280 GLboolean GL_APIENTRY IsFramebufferContextANGLE(GLeglContext ctx, GLuint framebuffer)
16281 {
16282 Context *context = static_cast<gl::Context *>(ctx);
16283 EVENT("glIsFramebuffer", "context = %d, GLuint framebuffer = %u", CID(context), framebuffer);
16284
16285 GLboolean returnValue;
16286 if (context)
16287 {
16288 ASSERT(context == GetValidGlobalContext());
16289 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
16290 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16291 bool isCallValid =
16292 (context->skipValidation() || ValidateIsFramebuffer(context, framebufferPacked));
16293 if (isCallValid)
16294 {
16295 returnValue = context->isFramebuffer(framebufferPacked);
16296 }
16297 else
16298 {
16299 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebuffer, GLboolean>();
16300 }
16301 ANGLE_CAPTURE(IsFramebuffer, isCallValid, context, framebufferPacked, returnValue);
16302 }
16303 else
16304 {
16305 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebuffer, GLboolean>();
16306 }
16307 return returnValue;
16308 }
16309
IsFramebufferOESContextANGLE(GLeglContext ctx,GLuint framebuffer)16310 GLboolean GL_APIENTRY IsFramebufferOESContextANGLE(GLeglContext ctx, GLuint framebuffer)
16311 {
16312 Context *context = static_cast<gl::Context *>(ctx);
16313 EVENT("glIsFramebufferOES", "context = %d, GLuint framebuffer = %u", CID(context), framebuffer);
16314
16315 GLboolean returnValue;
16316 if (context)
16317 {
16318 ASSERT(context == GetValidGlobalContext());
16319 FramebufferID framebufferPacked = FromGL<FramebufferID>(framebuffer);
16320 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16321 bool isCallValid =
16322 (context->skipValidation() || ValidateIsFramebufferOES(context, framebufferPacked));
16323 if (isCallValid)
16324 {
16325 returnValue = context->isFramebuffer(framebufferPacked);
16326 }
16327 else
16328 {
16329 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebufferOES, GLboolean>();
16330 }
16331 ANGLE_CAPTURE(IsFramebufferOES, isCallValid, context, framebufferPacked, returnValue);
16332 }
16333 else
16334 {
16335 returnValue = GetDefaultReturnValue<EntryPoint::IsFramebufferOES, GLboolean>();
16336 }
16337 return returnValue;
16338 }
16339
IsMemoryObjectEXTContextANGLE(GLeglContext ctx,GLuint memoryObject)16340 GLboolean GL_APIENTRY IsMemoryObjectEXTContextANGLE(GLeglContext ctx, GLuint memoryObject)
16341 {
16342 Context *context = static_cast<gl::Context *>(ctx);
16343 EVENT("glIsMemoryObjectEXT", "context = %d, GLuint memoryObject = %u", CID(context),
16344 memoryObject);
16345
16346 GLboolean returnValue;
16347 if (context)
16348 {
16349 ASSERT(context == GetValidGlobalContext());
16350 MemoryObjectID memoryObjectPacked = FromGL<MemoryObjectID>(memoryObject);
16351 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16352 bool isCallValid =
16353 (context->skipValidation() || ValidateIsMemoryObjectEXT(context, memoryObjectPacked));
16354 if (isCallValid)
16355 {
16356 returnValue = context->isMemoryObject(memoryObjectPacked);
16357 }
16358 else
16359 {
16360 returnValue = GetDefaultReturnValue<EntryPoint::IsMemoryObjectEXT, GLboolean>();
16361 }
16362 ANGLE_CAPTURE(IsMemoryObjectEXT, isCallValid, context, memoryObjectPacked, returnValue);
16363 }
16364 else
16365 {
16366 returnValue = GetDefaultReturnValue<EntryPoint::IsMemoryObjectEXT, GLboolean>();
16367 }
16368 return returnValue;
16369 }
16370
IsProgramContextANGLE(GLeglContext ctx,GLuint program)16371 GLboolean GL_APIENTRY IsProgramContextANGLE(GLeglContext ctx, GLuint program)
16372 {
16373 Context *context = static_cast<gl::Context *>(ctx);
16374 EVENT("glIsProgram", "context = %d, GLuint program = %u", CID(context), program);
16375
16376 GLboolean returnValue;
16377 if (context)
16378 {
16379 ASSERT(context == GetValidGlobalContext());
16380 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
16381 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16382 bool isCallValid = (context->skipValidation() || ValidateIsProgram(context, programPacked));
16383 if (isCallValid)
16384 {
16385 returnValue = context->isProgram(programPacked);
16386 }
16387 else
16388 {
16389 returnValue = GetDefaultReturnValue<EntryPoint::IsProgram, GLboolean>();
16390 }
16391 ANGLE_CAPTURE(IsProgram, isCallValid, context, programPacked, returnValue);
16392 }
16393 else
16394 {
16395 returnValue = GetDefaultReturnValue<EntryPoint::IsProgram, GLboolean>();
16396 }
16397 return returnValue;
16398 }
16399
IsProgramPipelineContextANGLE(GLeglContext ctx,GLuint pipeline)16400 GLboolean GL_APIENTRY IsProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
16401 {
16402 Context *context = static_cast<gl::Context *>(ctx);
16403 EVENT("glIsProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), pipeline);
16404
16405 GLboolean returnValue;
16406 if (context)
16407 {
16408 ASSERT(context == GetValidGlobalContext());
16409 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
16410 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16411 bool isCallValid =
16412 (context->skipValidation() || ValidateIsProgramPipeline(context, pipelinePacked));
16413 if (isCallValid)
16414 {
16415 returnValue = context->isProgramPipeline(pipelinePacked);
16416 }
16417 else
16418 {
16419 returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
16420 }
16421 ANGLE_CAPTURE(IsProgramPipeline, isCallValid, context, pipelinePacked, returnValue);
16422 }
16423 else
16424 {
16425 returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
16426 }
16427 return returnValue;
16428 }
16429
IsQueryContextANGLE(GLeglContext ctx,GLuint id)16430 GLboolean GL_APIENTRY IsQueryContextANGLE(GLeglContext ctx, GLuint id)
16431 {
16432 Context *context = static_cast<gl::Context *>(ctx);
16433 EVENT("glIsQuery", "context = %d, GLuint id = %u", CID(context), id);
16434
16435 GLboolean returnValue;
16436 if (context)
16437 {
16438 ASSERT(context == GetValidGlobalContext());
16439 QueryID idPacked = FromGL<QueryID>(id);
16440 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16441 bool isCallValid = (context->skipValidation() || ValidateIsQuery(context, idPacked));
16442 if (isCallValid)
16443 {
16444 returnValue = context->isQuery(idPacked);
16445 }
16446 else
16447 {
16448 returnValue = GetDefaultReturnValue<EntryPoint::IsQuery, GLboolean>();
16449 }
16450 ANGLE_CAPTURE(IsQuery, isCallValid, context, idPacked, returnValue);
16451 }
16452 else
16453 {
16454 returnValue = GetDefaultReturnValue<EntryPoint::IsQuery, GLboolean>();
16455 }
16456 return returnValue;
16457 }
16458
IsQueryEXTContextANGLE(GLeglContext ctx,GLuint id)16459 GLboolean GL_APIENTRY IsQueryEXTContextANGLE(GLeglContext ctx, GLuint id)
16460 {
16461 Context *context = static_cast<gl::Context *>(ctx);
16462 EVENT("glIsQueryEXT", "context = %d, GLuint id = %u", CID(context), id);
16463
16464 GLboolean returnValue;
16465 if (context)
16466 {
16467 ASSERT(context == GetValidGlobalContext());
16468 QueryID idPacked = FromGL<QueryID>(id);
16469 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16470 bool isCallValid = (context->skipValidation() || ValidateIsQueryEXT(context, idPacked));
16471 if (isCallValid)
16472 {
16473 returnValue = context->isQuery(idPacked);
16474 }
16475 else
16476 {
16477 returnValue = GetDefaultReturnValue<EntryPoint::IsQueryEXT, GLboolean>();
16478 }
16479 ANGLE_CAPTURE(IsQueryEXT, isCallValid, context, idPacked, returnValue);
16480 }
16481 else
16482 {
16483 returnValue = GetDefaultReturnValue<EntryPoint::IsQueryEXT, GLboolean>();
16484 }
16485 return returnValue;
16486 }
16487
IsRenderbufferContextANGLE(GLeglContext ctx,GLuint renderbuffer)16488 GLboolean GL_APIENTRY IsRenderbufferContextANGLE(GLeglContext ctx, GLuint renderbuffer)
16489 {
16490 Context *context = static_cast<gl::Context *>(ctx);
16491 EVENT("glIsRenderbuffer", "context = %d, GLuint renderbuffer = %u", CID(context), renderbuffer);
16492
16493 GLboolean returnValue;
16494 if (context)
16495 {
16496 ASSERT(context == GetValidGlobalContext());
16497 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
16498 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16499 bool isCallValid =
16500 (context->skipValidation() || ValidateIsRenderbuffer(context, renderbufferPacked));
16501 if (isCallValid)
16502 {
16503 returnValue = context->isRenderbuffer(renderbufferPacked);
16504 }
16505 else
16506 {
16507 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbuffer, GLboolean>();
16508 }
16509 ANGLE_CAPTURE(IsRenderbuffer, isCallValid, context, renderbufferPacked, returnValue);
16510 }
16511 else
16512 {
16513 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbuffer, GLboolean>();
16514 }
16515 return returnValue;
16516 }
16517
IsRenderbufferOESContextANGLE(GLeglContext ctx,GLuint renderbuffer)16518 GLboolean GL_APIENTRY IsRenderbufferOESContextANGLE(GLeglContext ctx, GLuint renderbuffer)
16519 {
16520 Context *context = static_cast<gl::Context *>(ctx);
16521 EVENT("glIsRenderbufferOES", "context = %d, GLuint renderbuffer = %u", CID(context),
16522 renderbuffer);
16523
16524 GLboolean returnValue;
16525 if (context)
16526 {
16527 ASSERT(context == GetValidGlobalContext());
16528 RenderbufferID renderbufferPacked = FromGL<RenderbufferID>(renderbuffer);
16529 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16530 bool isCallValid =
16531 (context->skipValidation() || ValidateIsRenderbufferOES(context, renderbufferPacked));
16532 if (isCallValid)
16533 {
16534 returnValue = context->isRenderbuffer(renderbufferPacked);
16535 }
16536 else
16537 {
16538 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbufferOES, GLboolean>();
16539 }
16540 ANGLE_CAPTURE(IsRenderbufferOES, isCallValid, context, renderbufferPacked, returnValue);
16541 }
16542 else
16543 {
16544 returnValue = GetDefaultReturnValue<EntryPoint::IsRenderbufferOES, GLboolean>();
16545 }
16546 return returnValue;
16547 }
16548
IsSemaphoreEXTContextANGLE(GLeglContext ctx,GLuint semaphore)16549 GLboolean GL_APIENTRY IsSemaphoreEXTContextANGLE(GLeglContext ctx, GLuint semaphore)
16550 {
16551 Context *context = static_cast<gl::Context *>(ctx);
16552 EVENT("glIsSemaphoreEXT", "context = %d, GLuint semaphore = %u", CID(context), semaphore);
16553
16554 GLboolean returnValue;
16555 if (context)
16556 {
16557 ASSERT(context == GetValidGlobalContext());
16558 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
16559 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16560 bool isCallValid =
16561 (context->skipValidation() || ValidateIsSemaphoreEXT(context, semaphorePacked));
16562 if (isCallValid)
16563 {
16564 returnValue = context->isSemaphore(semaphorePacked);
16565 }
16566 else
16567 {
16568 returnValue = GetDefaultReturnValue<EntryPoint::IsSemaphoreEXT, GLboolean>();
16569 }
16570 ANGLE_CAPTURE(IsSemaphoreEXT, isCallValid, context, semaphorePacked, returnValue);
16571 }
16572 else
16573 {
16574 returnValue = GetDefaultReturnValue<EntryPoint::IsSemaphoreEXT, GLboolean>();
16575 }
16576 return returnValue;
16577 }
16578
IsSamplerContextANGLE(GLeglContext ctx,GLuint sampler)16579 GLboolean GL_APIENTRY IsSamplerContextANGLE(GLeglContext ctx, GLuint sampler)
16580 {
16581 Context *context = static_cast<gl::Context *>(ctx);
16582 EVENT("glIsSampler", "context = %d, GLuint sampler = %u", CID(context), sampler);
16583
16584 GLboolean returnValue;
16585 if (context)
16586 {
16587 ASSERT(context == GetValidGlobalContext());
16588 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
16589 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16590 bool isCallValid = (context->skipValidation() || ValidateIsSampler(context, samplerPacked));
16591 if (isCallValid)
16592 {
16593 returnValue = context->isSampler(samplerPacked);
16594 }
16595 else
16596 {
16597 returnValue = GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
16598 }
16599 ANGLE_CAPTURE(IsSampler, isCallValid, context, samplerPacked, returnValue);
16600 }
16601 else
16602 {
16603 returnValue = GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
16604 }
16605 return returnValue;
16606 }
16607
IsShaderContextANGLE(GLeglContext ctx,GLuint shader)16608 GLboolean GL_APIENTRY IsShaderContextANGLE(GLeglContext ctx, GLuint shader)
16609 {
16610 Context *context = static_cast<gl::Context *>(ctx);
16611 EVENT("glIsShader", "context = %d, GLuint shader = %u", CID(context), shader);
16612
16613 GLboolean returnValue;
16614 if (context)
16615 {
16616 ASSERT(context == GetValidGlobalContext());
16617 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
16618 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16619 bool isCallValid = (context->skipValidation() || ValidateIsShader(context, shaderPacked));
16620 if (isCallValid)
16621 {
16622 returnValue = context->isShader(shaderPacked);
16623 }
16624 else
16625 {
16626 returnValue = GetDefaultReturnValue<EntryPoint::IsShader, GLboolean>();
16627 }
16628 ANGLE_CAPTURE(IsShader, isCallValid, context, shaderPacked, returnValue);
16629 }
16630 else
16631 {
16632 returnValue = GetDefaultReturnValue<EntryPoint::IsShader, GLboolean>();
16633 }
16634 return returnValue;
16635 }
16636
IsSyncContextANGLE(GLeglContext ctx,GLsync sync)16637 GLboolean GL_APIENTRY IsSyncContextANGLE(GLeglContext ctx, GLsync sync)
16638 {
16639 Context *context = static_cast<gl::Context *>(ctx);
16640 EVENT("glIsSync", "context = %d, GLsync sync = 0x%016" PRIxPTR "", CID(context),
16641 (uintptr_t)sync);
16642
16643 GLboolean returnValue;
16644 if (context)
16645 {
16646 ASSERT(context == GetValidGlobalContext());
16647 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16648 bool isCallValid = (context->skipValidation() || ValidateIsSync(context, sync));
16649 if (isCallValid)
16650 {
16651 returnValue = context->isSync(sync);
16652 }
16653 else
16654 {
16655 returnValue = GetDefaultReturnValue<EntryPoint::IsSync, GLboolean>();
16656 }
16657 ANGLE_CAPTURE(IsSync, isCallValid, context, sync, returnValue);
16658 }
16659 else
16660 {
16661 returnValue = GetDefaultReturnValue<EntryPoint::IsSync, GLboolean>();
16662 }
16663 return returnValue;
16664 }
16665
IsTextureContextANGLE(GLeglContext ctx,GLuint texture)16666 GLboolean GL_APIENTRY IsTextureContextANGLE(GLeglContext ctx, GLuint texture)
16667 {
16668 Context *context = static_cast<gl::Context *>(ctx);
16669 EVENT("glIsTexture", "context = %d, GLuint texture = %u", CID(context), texture);
16670
16671 GLboolean returnValue;
16672 if (context)
16673 {
16674 ASSERT(context == GetValidGlobalContext());
16675 TextureID texturePacked = FromGL<TextureID>(texture);
16676 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16677 bool isCallValid = (context->skipValidation() || ValidateIsTexture(context, texturePacked));
16678 if (isCallValid)
16679 {
16680 returnValue = context->isTexture(texturePacked);
16681 }
16682 else
16683 {
16684 returnValue = GetDefaultReturnValue<EntryPoint::IsTexture, GLboolean>();
16685 }
16686 ANGLE_CAPTURE(IsTexture, isCallValid, context, texturePacked, returnValue);
16687 }
16688 else
16689 {
16690 returnValue = GetDefaultReturnValue<EntryPoint::IsTexture, GLboolean>();
16691 }
16692 return returnValue;
16693 }
16694
IsTransformFeedbackContextANGLE(GLeglContext ctx,GLuint id)16695 GLboolean GL_APIENTRY IsTransformFeedbackContextANGLE(GLeglContext ctx, GLuint id)
16696 {
16697 Context *context = static_cast<gl::Context *>(ctx);
16698 EVENT("glIsTransformFeedback", "context = %d, GLuint id = %u", CID(context), id);
16699
16700 GLboolean returnValue;
16701 if (context)
16702 {
16703 ASSERT(context == GetValidGlobalContext());
16704 TransformFeedbackID idPacked = FromGL<TransformFeedbackID>(id);
16705 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16706 bool isCallValid =
16707 (context->skipValidation() || ValidateIsTransformFeedback(context, idPacked));
16708 if (isCallValid)
16709 {
16710 returnValue = context->isTransformFeedback(idPacked);
16711 }
16712 else
16713 {
16714 returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
16715 }
16716 ANGLE_CAPTURE(IsTransformFeedback, isCallValid, context, idPacked, returnValue);
16717 }
16718 else
16719 {
16720 returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
16721 }
16722 return returnValue;
16723 }
16724
IsVertexArrayContextANGLE(GLeglContext ctx,GLuint array)16725 GLboolean GL_APIENTRY IsVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
16726 {
16727 Context *context = static_cast<gl::Context *>(ctx);
16728 EVENT("glIsVertexArray", "context = %d, GLuint array = %u", CID(context), array);
16729
16730 GLboolean returnValue;
16731 if (context)
16732 {
16733 ASSERT(context == GetValidGlobalContext());
16734 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
16735 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16736 bool isCallValid =
16737 (context->skipValidation() || ValidateIsVertexArray(context, arrayPacked));
16738 if (isCallValid)
16739 {
16740 returnValue = context->isVertexArray(arrayPacked);
16741 }
16742 else
16743 {
16744 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArray, GLboolean>();
16745 }
16746 ANGLE_CAPTURE(IsVertexArray, isCallValid, context, arrayPacked, returnValue);
16747 }
16748 else
16749 {
16750 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArray, GLboolean>();
16751 }
16752 return returnValue;
16753 }
16754
IsVertexArrayOESContextANGLE(GLeglContext ctx,GLuint array)16755 GLboolean GL_APIENTRY IsVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
16756 {
16757 Context *context = static_cast<gl::Context *>(ctx);
16758 EVENT("glIsVertexArrayOES", "context = %d, GLuint array = %u", CID(context), array);
16759
16760 GLboolean returnValue;
16761 if (context)
16762 {
16763 ASSERT(context == GetValidGlobalContext());
16764 VertexArrayID arrayPacked = FromGL<VertexArrayID>(array);
16765 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16766 bool isCallValid =
16767 (context->skipValidation() || ValidateIsVertexArrayOES(context, arrayPacked));
16768 if (isCallValid)
16769 {
16770 returnValue = context->isVertexArray(arrayPacked);
16771 }
16772 else
16773 {
16774 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArrayOES, GLboolean>();
16775 }
16776 ANGLE_CAPTURE(IsVertexArrayOES, isCallValid, context, arrayPacked, returnValue);
16777 }
16778 else
16779 {
16780 returnValue = GetDefaultReturnValue<EntryPoint::IsVertexArrayOES, GLboolean>();
16781 }
16782 return returnValue;
16783 }
16784
LightModelfContextANGLE(GLeglContext ctx,GLenum pname,GLfloat param)16785 void GL_APIENTRY LightModelfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
16786 {
16787 Context *context = static_cast<gl::Context *>(ctx);
16788 EVENT("glLightModelf", "context = %d, GLenum pname = %s, GLfloat param = %f", CID(context),
16789 GLenumToString(GLenumGroup::LightModelParameter, pname), param);
16790
16791 if (context)
16792 {
16793 ASSERT(context == GetValidGlobalContext());
16794 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16795 bool isCallValid =
16796 (context->skipValidation() || ValidateLightModelf(context, pname, param));
16797 if (isCallValid)
16798 {
16799 context->lightModelf(pname, param);
16800 }
16801 ANGLE_CAPTURE(LightModelf, isCallValid, context, pname, param);
16802 }
16803 }
16804
LightModelfvContextANGLE(GLeglContext ctx,GLenum pname,const GLfloat * params)16805 void GL_APIENTRY LightModelfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
16806 {
16807 Context *context = static_cast<gl::Context *>(ctx);
16808 EVENT("glLightModelfv",
16809 "context = %d, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR "",
16810 CID(context), GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)params);
16811
16812 if (context)
16813 {
16814 ASSERT(context == GetValidGlobalContext());
16815 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16816 bool isCallValid =
16817 (context->skipValidation() || ValidateLightModelfv(context, pname, params));
16818 if (isCallValid)
16819 {
16820 context->lightModelfv(pname, params);
16821 }
16822 ANGLE_CAPTURE(LightModelfv, isCallValid, context, pname, params);
16823 }
16824 }
16825
LightModelxContextANGLE(GLeglContext ctx,GLenum pname,GLfixed param)16826 void GL_APIENTRY LightModelxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
16827 {
16828 Context *context = static_cast<gl::Context *>(ctx);
16829 EVENT("glLightModelx", "context = %d, GLenum pname = %s, GLfixed param = 0x%X", CID(context),
16830 GLenumToString(GLenumGroup::LightModelParameter, pname), param);
16831
16832 if (context)
16833 {
16834 ASSERT(context == GetValidGlobalContext());
16835 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16836 bool isCallValid =
16837 (context->skipValidation() || ValidateLightModelx(context, pname, param));
16838 if (isCallValid)
16839 {
16840 context->lightModelx(pname, param);
16841 }
16842 ANGLE_CAPTURE(LightModelx, isCallValid, context, pname, param);
16843 }
16844 }
16845
LightModelxvContextANGLE(GLeglContext ctx,GLenum pname,const GLfixed * param)16846 void GL_APIENTRY LightModelxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
16847 {
16848 Context *context = static_cast<gl::Context *>(ctx);
16849 EVENT("glLightModelxv",
16850 "context = %d, GLenum pname = %s, const GLfixed *param = 0x%016" PRIxPTR "", CID(context),
16851 GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)param);
16852
16853 if (context)
16854 {
16855 ASSERT(context == GetValidGlobalContext());
16856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16857 bool isCallValid =
16858 (context->skipValidation() || ValidateLightModelxv(context, pname, param));
16859 if (isCallValid)
16860 {
16861 context->lightModelxv(pname, param);
16862 }
16863 ANGLE_CAPTURE(LightModelxv, isCallValid, context, pname, param);
16864 }
16865 }
16866
LightfContextANGLE(GLeglContext ctx,GLenum light,GLenum pname,GLfloat param)16867 void GL_APIENTRY LightfContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfloat param)
16868 {
16869 Context *context = static_cast<gl::Context *>(ctx);
16870 EVENT("glLightf", "context = %d, GLenum light = %s, GLenum pname = %s, GLfloat param = %f",
16871 CID(context), GLenumToString(GLenumGroup::LightName, light),
16872 GLenumToString(GLenumGroup::LightParameter, pname), param);
16873
16874 if (context)
16875 {
16876 ASSERT(context == GetValidGlobalContext());
16877 LightParameter pnamePacked = FromGL<LightParameter>(pname);
16878 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16879 bool isCallValid =
16880 (context->skipValidation() || ValidateLightf(context, light, pnamePacked, param));
16881 if (isCallValid)
16882 {
16883 context->lightf(light, pnamePacked, param);
16884 }
16885 ANGLE_CAPTURE(Lightf, isCallValid, context, light, pnamePacked, param);
16886 }
16887 }
16888
LightfvContextANGLE(GLeglContext ctx,GLenum light,GLenum pname,const GLfloat * params)16889 void GL_APIENTRY LightfvContextANGLE(GLeglContext ctx,
16890 GLenum light,
16891 GLenum pname,
16892 const GLfloat *params)
16893 {
16894 Context *context = static_cast<gl::Context *>(ctx);
16895 EVENT(
16896 "glLightfv",
16897 "context = %d, GLenum light = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR
16898 "",
16899 CID(context), GLenumToString(GLenumGroup::LightName, light),
16900 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
16901
16902 if (context)
16903 {
16904 ASSERT(context == GetValidGlobalContext());
16905 LightParameter pnamePacked = FromGL<LightParameter>(pname);
16906 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16907 bool isCallValid =
16908 (context->skipValidation() || ValidateLightfv(context, light, pnamePacked, params));
16909 if (isCallValid)
16910 {
16911 context->lightfv(light, pnamePacked, params);
16912 }
16913 ANGLE_CAPTURE(Lightfv, isCallValid, context, light, pnamePacked, params);
16914 }
16915 }
16916
LightxContextANGLE(GLeglContext ctx,GLenum light,GLenum pname,GLfixed param)16917 void GL_APIENTRY LightxContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfixed param)
16918 {
16919 Context *context = static_cast<gl::Context *>(ctx);
16920 EVENT("glLightx", "context = %d, GLenum light = %s, GLenum pname = %s, GLfixed param = 0x%X",
16921 CID(context), GLenumToString(GLenumGroup::LightName, light),
16922 GLenumToString(GLenumGroup::LightParameter, pname), param);
16923
16924 if (context)
16925 {
16926 ASSERT(context == GetValidGlobalContext());
16927 LightParameter pnamePacked = FromGL<LightParameter>(pname);
16928 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16929 bool isCallValid =
16930 (context->skipValidation() || ValidateLightx(context, light, pnamePacked, param));
16931 if (isCallValid)
16932 {
16933 context->lightx(light, pnamePacked, param);
16934 }
16935 ANGLE_CAPTURE(Lightx, isCallValid, context, light, pnamePacked, param);
16936 }
16937 }
16938
LightxvContextANGLE(GLeglContext ctx,GLenum light,GLenum pname,const GLfixed * params)16939 void GL_APIENTRY LightxvContextANGLE(GLeglContext ctx,
16940 GLenum light,
16941 GLenum pname,
16942 const GLfixed *params)
16943 {
16944 Context *context = static_cast<gl::Context *>(ctx);
16945 EVENT(
16946 "glLightxv",
16947 "context = %d, GLenum light = %s, GLenum pname = %s, const GLfixed *params = 0x%016" PRIxPTR
16948 "",
16949 CID(context), GLenumToString(GLenumGroup::LightName, light),
16950 GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
16951
16952 if (context)
16953 {
16954 ASSERT(context == GetValidGlobalContext());
16955 LightParameter pnamePacked = FromGL<LightParameter>(pname);
16956 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16957 bool isCallValid =
16958 (context->skipValidation() || ValidateLightxv(context, light, pnamePacked, params));
16959 if (isCallValid)
16960 {
16961 context->lightxv(light, pnamePacked, params);
16962 }
16963 ANGLE_CAPTURE(Lightxv, isCallValid, context, light, pnamePacked, params);
16964 }
16965 }
16966
LineWidthContextANGLE(GLeglContext ctx,GLfloat width)16967 void GL_APIENTRY LineWidthContextANGLE(GLeglContext ctx, GLfloat width)
16968 {
16969 Context *context = static_cast<gl::Context *>(ctx);
16970 EVENT("glLineWidth", "context = %d, GLfloat width = %f", CID(context), width);
16971
16972 if (context)
16973 {
16974 ASSERT(context == GetValidGlobalContext());
16975 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16976 bool isCallValid = (context->skipValidation() || ValidateLineWidth(context, width));
16977 if (isCallValid)
16978 {
16979 context->lineWidth(width);
16980 }
16981 ANGLE_CAPTURE(LineWidth, isCallValid, context, width);
16982 }
16983 }
16984
LineWidthxContextANGLE(GLeglContext ctx,GLfixed width)16985 void GL_APIENTRY LineWidthxContextANGLE(GLeglContext ctx, GLfixed width)
16986 {
16987 Context *context = static_cast<gl::Context *>(ctx);
16988 EVENT("glLineWidthx", "context = %d, GLfixed width = 0x%X", CID(context), width);
16989
16990 if (context)
16991 {
16992 ASSERT(context == GetValidGlobalContext());
16993 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
16994 bool isCallValid = (context->skipValidation() || ValidateLineWidthx(context, width));
16995 if (isCallValid)
16996 {
16997 context->lineWidthx(width);
16998 }
16999 ANGLE_CAPTURE(LineWidthx, isCallValid, context, width);
17000 }
17001 }
17002
LinkProgramContextANGLE(GLeglContext ctx,GLuint program)17003 void GL_APIENTRY LinkProgramContextANGLE(GLeglContext ctx, GLuint program)
17004 {
17005 Context *context = static_cast<gl::Context *>(ctx);
17006 EVENT("glLinkProgram", "context = %d, GLuint program = %u", CID(context), program);
17007
17008 if (context)
17009 {
17010 ASSERT(context == GetValidGlobalContext());
17011 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
17012 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17013 bool isCallValid =
17014 (context->skipValidation() || ValidateLinkProgram(context, programPacked));
17015 if (isCallValid)
17016 {
17017 context->linkProgram(programPacked);
17018 }
17019 ANGLE_CAPTURE(LinkProgram, isCallValid, context, programPacked);
17020 }
17021 }
17022
LoadIdentityContextANGLE(GLeglContext ctx)17023 void GL_APIENTRY LoadIdentityContextANGLE(GLeglContext ctx)
17024 {
17025 Context *context = static_cast<gl::Context *>(ctx);
17026 EVENT("glLoadIdentity", "context = %d", CID(context));
17027
17028 if (context)
17029 {
17030 ASSERT(context == GetValidGlobalContext());
17031 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17032 bool isCallValid = (context->skipValidation() || ValidateLoadIdentity(context));
17033 if (isCallValid)
17034 {
17035 context->loadIdentity();
17036 }
17037 ANGLE_CAPTURE(LoadIdentity, isCallValid, context);
17038 }
17039 }
17040
LoadMatrixfContextANGLE(GLeglContext ctx,const GLfloat * m)17041 void GL_APIENTRY LoadMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
17042 {
17043 Context *context = static_cast<gl::Context *>(ctx);
17044 EVENT("glLoadMatrixf", "context = %d, const GLfloat *m = 0x%016" PRIxPTR "", CID(context),
17045 (uintptr_t)m);
17046
17047 if (context)
17048 {
17049 ASSERT(context == GetValidGlobalContext());
17050 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17051 bool isCallValid = (context->skipValidation() || ValidateLoadMatrixf(context, m));
17052 if (isCallValid)
17053 {
17054 context->loadMatrixf(m);
17055 }
17056 ANGLE_CAPTURE(LoadMatrixf, isCallValid, context, m);
17057 }
17058 }
17059
LoadMatrixxContextANGLE(GLeglContext ctx,const GLfixed * m)17060 void GL_APIENTRY LoadMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
17061 {
17062 Context *context = static_cast<gl::Context *>(ctx);
17063 EVENT("glLoadMatrixx", "context = %d, const GLfixed *m = 0x%016" PRIxPTR "", CID(context),
17064 (uintptr_t)m);
17065
17066 if (context)
17067 {
17068 ASSERT(context == GetValidGlobalContext());
17069 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17070 bool isCallValid = (context->skipValidation() || ValidateLoadMatrixx(context, m));
17071 if (isCallValid)
17072 {
17073 context->loadMatrixx(m);
17074 }
17075 ANGLE_CAPTURE(LoadMatrixx, isCallValid, context, m);
17076 }
17077 }
17078
LoadPaletteFromModelViewMatrixOESContextANGLE(GLeglContext ctx)17079 void GL_APIENTRY LoadPaletteFromModelViewMatrixOESContextANGLE(GLeglContext ctx)
17080 {
17081 Context *context = static_cast<gl::Context *>(ctx);
17082 EVENT("glLoadPaletteFromModelViewMatrixOES", "context = %d", CID(context));
17083
17084 if (context)
17085 {
17086 ASSERT(context == GetValidGlobalContext());
17087 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17088 bool isCallValid =
17089 (context->skipValidation() || ValidateLoadPaletteFromModelViewMatrixOES(context));
17090 if (isCallValid)
17091 {
17092 context->loadPaletteFromModelViewMatrix();
17093 }
17094 ANGLE_CAPTURE(LoadPaletteFromModelViewMatrixOES, isCallValid, context);
17095 }
17096 }
17097
LogicOpContextANGLE(GLeglContext ctx,GLenum opcode)17098 void GL_APIENTRY LogicOpContextANGLE(GLeglContext ctx, GLenum opcode)
17099 {
17100 Context *context = static_cast<gl::Context *>(ctx);
17101 EVENT("glLogicOp", "context = %d, GLenum opcode = %s", CID(context),
17102 GLenumToString(GLenumGroup::LogicOp, opcode));
17103
17104 if (context)
17105 {
17106 ASSERT(context == GetValidGlobalContext());
17107 LogicalOperation opcodePacked = FromGL<LogicalOperation>(opcode);
17108 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17109 bool isCallValid = (context->skipValidation() || ValidateLogicOp(context, opcodePacked));
17110 if (isCallValid)
17111 {
17112 context->logicOp(opcodePacked);
17113 }
17114 ANGLE_CAPTURE(LogicOp, isCallValid, context, opcodePacked);
17115 }
17116 }
17117
MapBufferOESContextANGLE(GLeglContext ctx,GLenum target,GLenum access)17118 void *GL_APIENTRY MapBufferOESContextANGLE(GLeglContext ctx, GLenum target, GLenum access)
17119 {
17120 Context *context = static_cast<gl::Context *>(ctx);
17121 EVENT("glMapBufferOES", "context = %d, GLenum target = %s, GLenum access = %s", CID(context),
17122 GLenumToString(GLenumGroup::BufferTargetARB, target),
17123 GLenumToString(GLenumGroup::BufferAccessARB, access));
17124
17125 void *returnValue;
17126 if (context)
17127 {
17128 ASSERT(context == GetValidGlobalContext());
17129 BufferBinding targetPacked = FromGL<BufferBinding>(target);
17130 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17131 bool isCallValid =
17132 (context->skipValidation() || ValidateMapBufferOES(context, targetPacked, access));
17133 if (isCallValid)
17134 {
17135 returnValue = context->mapBuffer(targetPacked, access);
17136 }
17137 else
17138 {
17139 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferOES, void *>();
17140 }
17141 ANGLE_CAPTURE(MapBufferOES, isCallValid, context, targetPacked, access, returnValue);
17142 }
17143 else
17144 {
17145 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferOES, void *>();
17146 }
17147 return returnValue;
17148 }
17149
MapBufferRangeContextANGLE(GLeglContext ctx,GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)17150 void *GL_APIENTRY MapBufferRangeContextANGLE(GLeglContext ctx,
17151 GLenum target,
17152 GLintptr offset,
17153 GLsizeiptr length,
17154 GLbitfield access)
17155 {
17156 Context *context = static_cast<gl::Context *>(ctx);
17157 EVENT("glMapBufferRange",
17158 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu, "
17159 "GLbitfield access = %s",
17160 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
17161 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
17162 GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
17163
17164 void *returnValue;
17165 if (context)
17166 {
17167 ASSERT(context == GetValidGlobalContext());
17168 BufferBinding targetPacked = FromGL<BufferBinding>(target);
17169 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17170 bool isCallValid = (context->skipValidation() ||
17171 ValidateMapBufferRange(context, targetPacked, offset, length, access));
17172 if (isCallValid)
17173 {
17174 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
17175 }
17176 else
17177 {
17178 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRange, void *>();
17179 }
17180 ANGLE_CAPTURE(MapBufferRange, isCallValid, context, targetPacked, offset, length, access,
17181 returnValue);
17182 }
17183 else
17184 {
17185 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRange, void *>();
17186 }
17187 return returnValue;
17188 }
17189
MapBufferRangeEXTContextANGLE(GLeglContext ctx,GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)17190 void *GL_APIENTRY MapBufferRangeEXTContextANGLE(GLeglContext ctx,
17191 GLenum target,
17192 GLintptr offset,
17193 GLsizeiptr length,
17194 GLbitfield access)
17195 {
17196 Context *context = static_cast<gl::Context *>(ctx);
17197 EVENT("glMapBufferRangeEXT",
17198 "context = %d, GLenum target = %s, GLintptr offset = %llu, GLsizeiptr length = %llu, "
17199 "GLbitfield access = %s",
17200 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target),
17201 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
17202 GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
17203
17204 void *returnValue;
17205 if (context)
17206 {
17207 ASSERT(context == GetValidGlobalContext());
17208 BufferBinding targetPacked = FromGL<BufferBinding>(target);
17209 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17210 bool isCallValid =
17211 (context->skipValidation() ||
17212 ValidateMapBufferRangeEXT(context, targetPacked, offset, length, access));
17213 if (isCallValid)
17214 {
17215 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
17216 }
17217 else
17218 {
17219 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRangeEXT, void *>();
17220 }
17221 ANGLE_CAPTURE(MapBufferRangeEXT, isCallValid, context, targetPacked, offset, length, access,
17222 returnValue);
17223 }
17224 else
17225 {
17226 returnValue = GetDefaultReturnValue<EntryPoint::MapBufferRangeEXT, void *>();
17227 }
17228 return returnValue;
17229 }
17230
MaterialfContextANGLE(GLeglContext ctx,GLenum face,GLenum pname,GLfloat param)17231 void GL_APIENTRY MaterialfContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfloat param)
17232 {
17233 Context *context = static_cast<gl::Context *>(ctx);
17234 EVENT("glMaterialf", "context = %d, GLenum face = %s, GLenum pname = %s, GLfloat param = %f",
17235 CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
17236 GLenumToString(GLenumGroup::MaterialParameter, pname), param);
17237
17238 if (context)
17239 {
17240 ASSERT(context == GetValidGlobalContext());
17241 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
17242 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17243 bool isCallValid =
17244 (context->skipValidation() || ValidateMaterialf(context, face, pnamePacked, param));
17245 if (isCallValid)
17246 {
17247 context->materialf(face, pnamePacked, param);
17248 }
17249 ANGLE_CAPTURE(Materialf, isCallValid, context, face, pnamePacked, param);
17250 }
17251 }
17252
MaterialfvContextANGLE(GLeglContext ctx,GLenum face,GLenum pname,const GLfloat * params)17253 void GL_APIENTRY MaterialfvContextANGLE(GLeglContext ctx,
17254 GLenum face,
17255 GLenum pname,
17256 const GLfloat *params)
17257 {
17258 Context *context = static_cast<gl::Context *>(ctx);
17259 EVENT(
17260 "glMaterialfv",
17261 "context = %d, GLenum face = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR
17262 "",
17263 CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
17264 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
17265
17266 if (context)
17267 {
17268 ASSERT(context == GetValidGlobalContext());
17269 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
17270 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17271 bool isCallValid =
17272 (context->skipValidation() || ValidateMaterialfv(context, face, pnamePacked, params));
17273 if (isCallValid)
17274 {
17275 context->materialfv(face, pnamePacked, params);
17276 }
17277 ANGLE_CAPTURE(Materialfv, isCallValid, context, face, pnamePacked, params);
17278 }
17279 }
17280
MaterialxContextANGLE(GLeglContext ctx,GLenum face,GLenum pname,GLfixed param)17281 void GL_APIENTRY MaterialxContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfixed param)
17282 {
17283 Context *context = static_cast<gl::Context *>(ctx);
17284 EVENT("glMaterialx", "context = %d, GLenum face = %s, GLenum pname = %s, GLfixed param = 0x%X",
17285 CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
17286 GLenumToString(GLenumGroup::MaterialParameter, pname), param);
17287
17288 if (context)
17289 {
17290 ASSERT(context == GetValidGlobalContext());
17291 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
17292 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17293 bool isCallValid =
17294 (context->skipValidation() || ValidateMaterialx(context, face, pnamePacked, param));
17295 if (isCallValid)
17296 {
17297 context->materialx(face, pnamePacked, param);
17298 }
17299 ANGLE_CAPTURE(Materialx, isCallValid, context, face, pnamePacked, param);
17300 }
17301 }
17302
MaterialxvContextANGLE(GLeglContext ctx,GLenum face,GLenum pname,const GLfixed * param)17303 void GL_APIENTRY MaterialxvContextANGLE(GLeglContext ctx,
17304 GLenum face,
17305 GLenum pname,
17306 const GLfixed *param)
17307 {
17308 Context *context = static_cast<gl::Context *>(ctx);
17309 EVENT("glMaterialxv",
17310 "context = %d, GLenum face = %s, GLenum pname = %s, const GLfixed *param = 0x%016" PRIxPTR
17311 "",
17312 CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
17313 GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)param);
17314
17315 if (context)
17316 {
17317 ASSERT(context == GetValidGlobalContext());
17318 MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
17319 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17320 bool isCallValid =
17321 (context->skipValidation() || ValidateMaterialxv(context, face, pnamePacked, param));
17322 if (isCallValid)
17323 {
17324 context->materialxv(face, pnamePacked, param);
17325 }
17326 ANGLE_CAPTURE(Materialxv, isCallValid, context, face, pnamePacked, param);
17327 }
17328 }
17329
MatrixIndexPointerOESContextANGLE(GLeglContext ctx,GLint size,GLenum type,GLsizei stride,const void * pointer)17330 void GL_APIENTRY MatrixIndexPointerOESContextANGLE(GLeglContext ctx,
17331 GLint size,
17332 GLenum type,
17333 GLsizei stride,
17334 const void *pointer)
17335 {
17336 Context *context = static_cast<gl::Context *>(ctx);
17337 EVENT("glMatrixIndexPointerOES",
17338 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
17339 "*pointer = 0x%016" PRIxPTR "",
17340 CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
17341 (uintptr_t)pointer);
17342
17343 if (context)
17344 {
17345 ASSERT(context == GetValidGlobalContext());
17346 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17347 bool isCallValid = (context->skipValidation() ||
17348 ValidateMatrixIndexPointerOES(context, size, type, stride, pointer));
17349 if (isCallValid)
17350 {
17351 context->matrixIndexPointer(size, type, stride, pointer);
17352 }
17353 ANGLE_CAPTURE(MatrixIndexPointerOES, isCallValid, context, size, type, stride, pointer);
17354 }
17355 }
17356
MatrixModeContextANGLE(GLeglContext ctx,GLenum mode)17357 void GL_APIENTRY MatrixModeContextANGLE(GLeglContext ctx, GLenum mode)
17358 {
17359 Context *context = static_cast<gl::Context *>(ctx);
17360 EVENT("glMatrixMode", "context = %d, GLenum mode = %s", CID(context),
17361 GLenumToString(GLenumGroup::MatrixMode, mode));
17362
17363 if (context)
17364 {
17365 ASSERT(context == GetValidGlobalContext());
17366 MatrixType modePacked = FromGL<MatrixType>(mode);
17367 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17368 bool isCallValid = (context->skipValidation() || ValidateMatrixMode(context, modePacked));
17369 if (isCallValid)
17370 {
17371 context->matrixMode(modePacked);
17372 }
17373 ANGLE_CAPTURE(MatrixMode, isCallValid, context, modePacked);
17374 }
17375 }
17376
MaxShaderCompilerThreadsKHRContextANGLE(GLeglContext ctx,GLuint count)17377 void GL_APIENTRY MaxShaderCompilerThreadsKHRContextANGLE(GLeglContext ctx, GLuint count)
17378 {
17379 Context *context = static_cast<gl::Context *>(ctx);
17380 EVENT("glMaxShaderCompilerThreadsKHR", "context = %d, GLuint count = %u", CID(context), count);
17381
17382 if (context)
17383 {
17384 ASSERT(context == GetValidGlobalContext());
17385 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17386 bool isCallValid =
17387 (context->skipValidation() || ValidateMaxShaderCompilerThreadsKHR(context, count));
17388 if (isCallValid)
17389 {
17390 context->maxShaderCompilerThreads(count);
17391 }
17392 ANGLE_CAPTURE(MaxShaderCompilerThreadsKHR, isCallValid, context, count);
17393 }
17394 }
17395
MemoryBarrierContextANGLE(GLeglContext ctx,GLbitfield barriers)17396 void GL_APIENTRY MemoryBarrierContextANGLE(GLeglContext ctx, GLbitfield barriers)
17397 {
17398 Context *context = static_cast<gl::Context *>(ctx);
17399 EVENT("glMemoryBarrier", "context = %d, GLbitfield barriers = %s", CID(context),
17400 GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str());
17401
17402 if (context)
17403 {
17404 ASSERT(context == GetValidGlobalContext());
17405 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17406 bool isCallValid = (context->skipValidation() || ValidateMemoryBarrier(context, barriers));
17407 if (isCallValid)
17408 {
17409 context->memoryBarrier(barriers);
17410 }
17411 ANGLE_CAPTURE(MemoryBarrier, isCallValid, context, barriers);
17412 }
17413 }
17414
MemoryBarrierByRegionContextANGLE(GLeglContext ctx,GLbitfield barriers)17415 void GL_APIENTRY MemoryBarrierByRegionContextANGLE(GLeglContext ctx, GLbitfield barriers)
17416 {
17417 Context *context = static_cast<gl::Context *>(ctx);
17418 EVENT("glMemoryBarrierByRegion", "context = %d, GLbitfield barriers = %s", CID(context),
17419 GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str());
17420
17421 if (context)
17422 {
17423 ASSERT(context == GetValidGlobalContext());
17424 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17425 bool isCallValid =
17426 (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers));
17427 if (isCallValid)
17428 {
17429 context->memoryBarrierByRegion(barriers);
17430 }
17431 ANGLE_CAPTURE(MemoryBarrierByRegion, isCallValid, context, barriers);
17432 }
17433 }
17434
MemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,GLuint memoryObject,GLenum pname,const GLint * params)17435 void GL_APIENTRY MemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
17436 GLuint memoryObject,
17437 GLenum pname,
17438 const GLint *params)
17439 {
17440 Context *context = static_cast<gl::Context *>(ctx);
17441 EVENT("glMemoryObjectParameterivEXT",
17442 "context = %d, GLuint memoryObject = %u, GLenum pname = %s, const GLint *params = "
17443 "0x%016" PRIxPTR "",
17444 CID(context), memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
17445 (uintptr_t)params);
17446
17447 if (context)
17448 {
17449 ASSERT(context == GetValidGlobalContext());
17450 MemoryObjectID memoryObjectPacked = FromGL<MemoryObjectID>(memoryObject);
17451 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17452 bool isCallValid =
17453 (context->skipValidation() ||
17454 ValidateMemoryObjectParameterivEXT(context, memoryObjectPacked, pname, params));
17455 if (isCallValid)
17456 {
17457 context->memoryObjectParameteriv(memoryObjectPacked, pname, params);
17458 }
17459 ANGLE_CAPTURE(MemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked, pname,
17460 params);
17461 }
17462 }
17463
MinSampleShadingContextANGLE(GLeglContext ctx,GLfloat value)17464 void GL_APIENTRY MinSampleShadingContextANGLE(GLeglContext ctx, GLfloat value)
17465 {
17466 Context *context = static_cast<gl::Context *>(ctx);
17467 EVENT("glMinSampleShading", "context = %d, GLfloat value = %f", CID(context), value);
17468
17469 if (context)
17470 {
17471 ASSERT(context == GetValidGlobalContext());
17472 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17473 bool isCallValid = (context->skipValidation() || ValidateMinSampleShading(context, value));
17474 if (isCallValid)
17475 {
17476 context->minSampleShading(value);
17477 }
17478 ANGLE_CAPTURE(MinSampleShading, isCallValid, context, value);
17479 }
17480 }
17481
MultMatrixfContextANGLE(GLeglContext ctx,const GLfloat * m)17482 void GL_APIENTRY MultMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
17483 {
17484 Context *context = static_cast<gl::Context *>(ctx);
17485 EVENT("glMultMatrixf", "context = %d, const GLfloat *m = 0x%016" PRIxPTR "", CID(context),
17486 (uintptr_t)m);
17487
17488 if (context)
17489 {
17490 ASSERT(context == GetValidGlobalContext());
17491 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17492 bool isCallValid = (context->skipValidation() || ValidateMultMatrixf(context, m));
17493 if (isCallValid)
17494 {
17495 context->multMatrixf(m);
17496 }
17497 ANGLE_CAPTURE(MultMatrixf, isCallValid, context, m);
17498 }
17499 }
17500
MultMatrixxContextANGLE(GLeglContext ctx,const GLfixed * m)17501 void GL_APIENTRY MultMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
17502 {
17503 Context *context = static_cast<gl::Context *>(ctx);
17504 EVENT("glMultMatrixx", "context = %d, const GLfixed *m = 0x%016" PRIxPTR "", CID(context),
17505 (uintptr_t)m);
17506
17507 if (context)
17508 {
17509 ASSERT(context == GetValidGlobalContext());
17510 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17511 bool isCallValid = (context->skipValidation() || ValidateMultMatrixx(context, m));
17512 if (isCallValid)
17513 {
17514 context->multMatrixx(m);
17515 }
17516 ANGLE_CAPTURE(MultMatrixx, isCallValid, context, m);
17517 }
17518 }
17519
MultiDrawElementsBaseVertexEXTContextANGLE(GLeglContext ctx,GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei primcount,const GLint * basevertex)17520 void GL_APIENTRY MultiDrawElementsBaseVertexEXTContextANGLE(GLeglContext ctx,
17521 GLenum mode,
17522 const GLsizei *count,
17523 GLenum type,
17524 const void *const *indices,
17525 GLsizei primcount,
17526 const GLint *basevertex)
17527 {
17528 Context *context = static_cast<gl::Context *>(ctx);
17529 EVENT("glMultiDrawElementsBaseVertexEXT",
17530 "context = %d, GLenum mode = %s, const GLsizei *count = 0x%016" PRIxPTR
17531 ", GLenum type = %s, const void *const*indices = 0x%016" PRIxPTR
17532 ", GLsizei primcount = %d, const GLint *basevertex = 0x%016" PRIxPTR "",
17533 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count,
17534 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount,
17535 (uintptr_t)basevertex);
17536
17537 if (context)
17538 {
17539 ASSERT(context == GetValidGlobalContext());
17540 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
17541 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
17542 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17543 bool isCallValid = (context->skipValidation() || ValidateMultiDrawElementsBaseVertexEXT(
17544 context, modePacked, count, typePacked,
17545 indices, primcount, basevertex));
17546 if (isCallValid)
17547 {
17548 context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, primcount,
17549 basevertex);
17550 }
17551 ANGLE_CAPTURE(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
17552 typePacked, indices, primcount, basevertex);
17553 }
17554 }
17555
MultiTexCoord4fContextANGLE(GLeglContext ctx,GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)17556 void GL_APIENTRY MultiTexCoord4fContextANGLE(GLeglContext ctx,
17557 GLenum target,
17558 GLfloat s,
17559 GLfloat t,
17560 GLfloat r,
17561 GLfloat q)
17562 {
17563 Context *context = static_cast<gl::Context *>(ctx);
17564 EVENT("glMultiTexCoord4f",
17565 "context = %d, GLenum target = %s, GLfloat s = %f, GLfloat t = %f, GLfloat r = %f, "
17566 "GLfloat q = %f",
17567 CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q);
17568
17569 if (context)
17570 {
17571 ASSERT(context == GetValidGlobalContext());
17572 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17573 bool isCallValid =
17574 (context->skipValidation() || ValidateMultiTexCoord4f(context, target, s, t, r, q));
17575 if (isCallValid)
17576 {
17577 context->multiTexCoord4f(target, s, t, r, q);
17578 }
17579 ANGLE_CAPTURE(MultiTexCoord4f, isCallValid, context, target, s, t, r, q);
17580 }
17581 }
17582
MultiTexCoord4xContextANGLE(GLeglContext ctx,GLenum texture,GLfixed s,GLfixed t,GLfixed r,GLfixed q)17583 void GL_APIENTRY MultiTexCoord4xContextANGLE(GLeglContext ctx,
17584 GLenum texture,
17585 GLfixed s,
17586 GLfixed t,
17587 GLfixed r,
17588 GLfixed q)
17589 {
17590 Context *context = static_cast<gl::Context *>(ctx);
17591 EVENT("glMultiTexCoord4x",
17592 "context = %d, GLenum texture = %s, GLfixed s = 0x%X, GLfixed t = 0x%X, GLfixed r = "
17593 "0x%X, GLfixed q = 0x%X",
17594 CID(context), GLenumToString(GLenumGroup::TextureUnit, texture), s, t, r, q);
17595
17596 if (context)
17597 {
17598 ASSERT(context == GetValidGlobalContext());
17599 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17600 bool isCallValid =
17601 (context->skipValidation() || ValidateMultiTexCoord4x(context, texture, s, t, r, q));
17602 if (isCallValid)
17603 {
17604 context->multiTexCoord4x(texture, s, t, r, q);
17605 }
17606 ANGLE_CAPTURE(MultiTexCoord4x, isCallValid, context, texture, s, t, r, q);
17607 }
17608 }
17609
Normal3fContextANGLE(GLeglContext ctx,GLfloat nx,GLfloat ny,GLfloat nz)17610 void GL_APIENTRY Normal3fContextANGLE(GLeglContext ctx, GLfloat nx, GLfloat ny, GLfloat nz)
17611 {
17612 Context *context = static_cast<gl::Context *>(ctx);
17613 EVENT("glNormal3f", "context = %d, GLfloat nx = %f, GLfloat ny = %f, GLfloat nz = %f",
17614 CID(context), nx, ny, nz);
17615
17616 if (context)
17617 {
17618 ASSERT(context == GetValidGlobalContext());
17619 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17620 bool isCallValid = (context->skipValidation() || ValidateNormal3f(context, nx, ny, nz));
17621 if (isCallValid)
17622 {
17623 context->normal3f(nx, ny, nz);
17624 }
17625 ANGLE_CAPTURE(Normal3f, isCallValid, context, nx, ny, nz);
17626 }
17627 }
17628
Normal3xContextANGLE(GLeglContext ctx,GLfixed nx,GLfixed ny,GLfixed nz)17629 void GL_APIENTRY Normal3xContextANGLE(GLeglContext ctx, GLfixed nx, GLfixed ny, GLfixed nz)
17630 {
17631 Context *context = static_cast<gl::Context *>(ctx);
17632 EVENT("glNormal3x", "context = %d, GLfixed nx = 0x%X, GLfixed ny = 0x%X, GLfixed nz = 0x%X",
17633 CID(context), nx, ny, nz);
17634
17635 if (context)
17636 {
17637 ASSERT(context == GetValidGlobalContext());
17638 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17639 bool isCallValid = (context->skipValidation() || ValidateNormal3x(context, nx, ny, nz));
17640 if (isCallValid)
17641 {
17642 context->normal3x(nx, ny, nz);
17643 }
17644 ANGLE_CAPTURE(Normal3x, isCallValid, context, nx, ny, nz);
17645 }
17646 }
17647
NormalPointerContextANGLE(GLeglContext ctx,GLenum type,GLsizei stride,const void * pointer)17648 void GL_APIENTRY NormalPointerContextANGLE(GLeglContext ctx,
17649 GLenum type,
17650 GLsizei stride,
17651 const void *pointer)
17652 {
17653 Context *context = static_cast<gl::Context *>(ctx);
17654 EVENT(
17655 "glNormalPointer",
17656 "context = %d, GLenum type = %s, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR
17657 "",
17658 CID(context), GLenumToString(GLenumGroup::NormalPointerType, type), stride,
17659 (uintptr_t)pointer);
17660
17661 if (context)
17662 {
17663 ASSERT(context == GetValidGlobalContext());
17664 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
17665 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17666 bool isCallValid = (context->skipValidation() ||
17667 ValidateNormalPointer(context, typePacked, stride, pointer));
17668 if (isCallValid)
17669 {
17670 context->normalPointer(typePacked, stride, pointer);
17671 }
17672 ANGLE_CAPTURE(NormalPointer, isCallValid, context, typePacked, stride, pointer);
17673 }
17674 }
17675
ObjectLabelContextANGLE(GLeglContext ctx,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)17676 void GL_APIENTRY ObjectLabelContextANGLE(GLeglContext ctx,
17677 GLenum identifier,
17678 GLuint name,
17679 GLsizei length,
17680 const GLchar *label)
17681 {
17682 Context *context = static_cast<gl::Context *>(ctx);
17683 EVENT("glObjectLabel",
17684 "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei length = %d, const "
17685 "GLchar *label = 0x%016" PRIxPTR "",
17686 CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length,
17687 (uintptr_t)label);
17688
17689 if (context)
17690 {
17691 ASSERT(context == GetValidGlobalContext());
17692 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17693 bool isCallValid = (context->skipValidation() ||
17694 ValidateObjectLabel(context, identifier, name, length, label));
17695 if (isCallValid)
17696 {
17697 context->objectLabel(identifier, name, length, label);
17698 }
17699 ANGLE_CAPTURE(ObjectLabel, isCallValid, context, identifier, name, length, label);
17700 }
17701 }
17702
ObjectLabelKHRContextANGLE(GLeglContext ctx,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)17703 void GL_APIENTRY ObjectLabelKHRContextANGLE(GLeglContext ctx,
17704 GLenum identifier,
17705 GLuint name,
17706 GLsizei length,
17707 const GLchar *label)
17708 {
17709 Context *context = static_cast<gl::Context *>(ctx);
17710 EVENT("glObjectLabelKHR",
17711 "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei length = %d, const "
17712 "GLchar *label = 0x%016" PRIxPTR "",
17713 CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length,
17714 (uintptr_t)label);
17715
17716 if (context)
17717 {
17718 ASSERT(context == GetValidGlobalContext());
17719 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17720 bool isCallValid = (context->skipValidation() ||
17721 ValidateObjectLabelKHR(context, identifier, name, length, label));
17722 if (isCallValid)
17723 {
17724 context->objectLabel(identifier, name, length, label);
17725 }
17726 ANGLE_CAPTURE(ObjectLabelKHR, isCallValid, context, identifier, name, length, label);
17727 }
17728 }
17729
ObjectPtrLabelContextANGLE(GLeglContext ctx,const void * ptr,GLsizei length,const GLchar * label)17730 void GL_APIENTRY ObjectPtrLabelContextANGLE(GLeglContext ctx,
17731 const void *ptr,
17732 GLsizei length,
17733 const GLchar *label)
17734 {
17735 Context *context = static_cast<gl::Context *>(ctx);
17736 EVENT("glObjectPtrLabel",
17737 "context = %d, const void *ptr = 0x%016" PRIxPTR
17738 ", GLsizei length = %d, const GLchar *label = 0x%016" PRIxPTR "",
17739 CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
17740
17741 if (context)
17742 {
17743 ASSERT(context == GetValidGlobalContext());
17744 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17745 bool isCallValid =
17746 (context->skipValidation() || ValidateObjectPtrLabel(context, ptr, length, label));
17747 if (isCallValid)
17748 {
17749 context->objectPtrLabel(ptr, length, label);
17750 }
17751 ANGLE_CAPTURE(ObjectPtrLabel, isCallValid, context, ptr, length, label);
17752 }
17753 }
17754
ObjectPtrLabelKHRContextANGLE(GLeglContext ctx,const void * ptr,GLsizei length,const GLchar * label)17755 void GL_APIENTRY ObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
17756 const void *ptr,
17757 GLsizei length,
17758 const GLchar *label)
17759 {
17760 Context *context = static_cast<gl::Context *>(ctx);
17761 EVENT("glObjectPtrLabelKHR",
17762 "context = %d, const void *ptr = 0x%016" PRIxPTR
17763 ", GLsizei length = %d, const GLchar *label = 0x%016" PRIxPTR "",
17764 CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
17765
17766 if (context)
17767 {
17768 ASSERT(context == GetValidGlobalContext());
17769 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17770 bool isCallValid =
17771 (context->skipValidation() || ValidateObjectPtrLabelKHR(context, ptr, length, label));
17772 if (isCallValid)
17773 {
17774 context->objectPtrLabel(ptr, length, label);
17775 }
17776 ANGLE_CAPTURE(ObjectPtrLabelKHR, isCallValid, context, ptr, length, label);
17777 }
17778 }
17779
OrthofContextANGLE(GLeglContext ctx,GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f)17780 void GL_APIENTRY OrthofContextANGLE(GLeglContext ctx,
17781 GLfloat l,
17782 GLfloat r,
17783 GLfloat b,
17784 GLfloat t,
17785 GLfloat n,
17786 GLfloat f)
17787 {
17788 Context *context = static_cast<gl::Context *>(ctx);
17789 EVENT("glOrthof",
17790 "context = %d, GLfloat l = %f, GLfloat r = %f, GLfloat b = %f, GLfloat t = %f, GLfloat n "
17791 "= %f, GLfloat f = %f",
17792 CID(context), l, r, b, t, n, f);
17793
17794 if (context)
17795 {
17796 ASSERT(context == GetValidGlobalContext());
17797 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17798 bool isCallValid = (context->skipValidation() || ValidateOrthof(context, l, r, b, t, n, f));
17799 if (isCallValid)
17800 {
17801 context->orthof(l, r, b, t, n, f);
17802 }
17803 ANGLE_CAPTURE(Orthof, isCallValid, context, l, r, b, t, n, f);
17804 }
17805 }
17806
OrthoxContextANGLE(GLeglContext ctx,GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f)17807 void GL_APIENTRY OrthoxContextANGLE(GLeglContext ctx,
17808 GLfixed l,
17809 GLfixed r,
17810 GLfixed b,
17811 GLfixed t,
17812 GLfixed n,
17813 GLfixed f)
17814 {
17815 Context *context = static_cast<gl::Context *>(ctx);
17816 EVENT("glOrthox",
17817 "context = %d, GLfixed l = 0x%X, GLfixed r = 0x%X, GLfixed b = 0x%X, GLfixed t = 0x%X, "
17818 "GLfixed n = 0x%X, GLfixed f = 0x%X",
17819 CID(context), l, r, b, t, n, f);
17820
17821 if (context)
17822 {
17823 ASSERT(context == GetValidGlobalContext());
17824 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17825 bool isCallValid = (context->skipValidation() || ValidateOrthox(context, l, r, b, t, n, f));
17826 if (isCallValid)
17827 {
17828 context->orthox(l, r, b, t, n, f);
17829 }
17830 ANGLE_CAPTURE(Orthox, isCallValid, context, l, r, b, t, n, f);
17831 }
17832 }
17833
PatchParameteriContextANGLE(GLeglContext ctx,GLenum pname,GLint value)17834 void GL_APIENTRY PatchParameteriContextANGLE(GLeglContext ctx, GLenum pname, GLint value)
17835 {
17836 Context *context = static_cast<gl::Context *>(ctx);
17837 EVENT("glPatchParameteri", "context = %d, GLenum pname = %s, GLint value = %d", CID(context),
17838 GLenumToString(GLenumGroup::PatchParameterName, pname), value);
17839
17840 if (context)
17841 {
17842 ASSERT(context == GetValidGlobalContext());
17843 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17844 bool isCallValid =
17845 (context->skipValidation() || ValidatePatchParameteri(context, pname, value));
17846 if (isCallValid)
17847 {
17848 context->patchParameteri(pname, value);
17849 }
17850 ANGLE_CAPTURE(PatchParameteri, isCallValid, context, pname, value);
17851 }
17852 }
17853
PauseTransformFeedbackContextANGLE(GLeglContext ctx)17854 void GL_APIENTRY PauseTransformFeedbackContextANGLE(GLeglContext ctx)
17855 {
17856 Context *context = static_cast<gl::Context *>(ctx);
17857 EVENT("glPauseTransformFeedback", "context = %d", CID(context));
17858
17859 if (context)
17860 {
17861 ASSERT(context == GetValidGlobalContext());
17862 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17863 bool isCallValid = (context->skipValidation() || ValidatePauseTransformFeedback(context));
17864 if (isCallValid)
17865 {
17866 context->pauseTransformFeedback();
17867 }
17868 ANGLE_CAPTURE(PauseTransformFeedback, isCallValid, context);
17869 }
17870 }
17871
PixelStoreiContextANGLE(GLeglContext ctx,GLenum pname,GLint param)17872 void GL_APIENTRY PixelStoreiContextANGLE(GLeglContext ctx, GLenum pname, GLint param)
17873 {
17874 Context *context = static_cast<gl::Context *>(ctx);
17875 EVENT("glPixelStorei", "context = %d, GLenum pname = %s, GLint param = %d", CID(context),
17876 GLenumToString(GLenumGroup::PixelStoreParameter, pname), param);
17877
17878 if (context)
17879 {
17880 ASSERT(context == GetValidGlobalContext());
17881 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17882 bool isCallValid =
17883 (context->skipValidation() || ValidatePixelStorei(context, pname, param));
17884 if (isCallValid)
17885 {
17886 context->pixelStorei(pname, param);
17887 }
17888 ANGLE_CAPTURE(PixelStorei, isCallValid, context, pname, param);
17889 }
17890 }
17891
PointParameterfContextANGLE(GLeglContext ctx,GLenum pname,GLfloat param)17892 void GL_APIENTRY PointParameterfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
17893 {
17894 Context *context = static_cast<gl::Context *>(ctx);
17895 EVENT("glPointParameterf", "context = %d, GLenum pname = %s, GLfloat param = %f", CID(context),
17896 GLenumToString(GLenumGroup::DefaultGroup, pname), param);
17897
17898 if (context)
17899 {
17900 ASSERT(context == GetValidGlobalContext());
17901 PointParameter pnamePacked = FromGL<PointParameter>(pname);
17902 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17903 bool isCallValid =
17904 (context->skipValidation() || ValidatePointParameterf(context, pnamePacked, param));
17905 if (isCallValid)
17906 {
17907 context->pointParameterf(pnamePacked, param);
17908 }
17909 ANGLE_CAPTURE(PointParameterf, isCallValid, context, pnamePacked, param);
17910 }
17911 }
17912
PointParameterfvContextANGLE(GLeglContext ctx,GLenum pname,const GLfloat * params)17913 void GL_APIENTRY PointParameterfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
17914 {
17915 Context *context = static_cast<gl::Context *>(ctx);
17916 EVENT("glPointParameterfv",
17917 "context = %d, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR "",
17918 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
17919
17920 if (context)
17921 {
17922 ASSERT(context == GetValidGlobalContext());
17923 PointParameter pnamePacked = FromGL<PointParameter>(pname);
17924 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17925 bool isCallValid =
17926 (context->skipValidation() || ValidatePointParameterfv(context, pnamePacked, params));
17927 if (isCallValid)
17928 {
17929 context->pointParameterfv(pnamePacked, params);
17930 }
17931 ANGLE_CAPTURE(PointParameterfv, isCallValid, context, pnamePacked, params);
17932 }
17933 }
17934
PointParameterxContextANGLE(GLeglContext ctx,GLenum pname,GLfixed param)17935 void GL_APIENTRY PointParameterxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
17936 {
17937 Context *context = static_cast<gl::Context *>(ctx);
17938 EVENT("glPointParameterx", "context = %d, GLenum pname = %s, GLfixed param = 0x%X",
17939 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), param);
17940
17941 if (context)
17942 {
17943 ASSERT(context == GetValidGlobalContext());
17944 PointParameter pnamePacked = FromGL<PointParameter>(pname);
17945 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17946 bool isCallValid =
17947 (context->skipValidation() || ValidatePointParameterx(context, pnamePacked, param));
17948 if (isCallValid)
17949 {
17950 context->pointParameterx(pnamePacked, param);
17951 }
17952 ANGLE_CAPTURE(PointParameterx, isCallValid, context, pnamePacked, param);
17953 }
17954 }
17955
PointParameterxvContextANGLE(GLeglContext ctx,GLenum pname,const GLfixed * params)17956 void GL_APIENTRY PointParameterxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *params)
17957 {
17958 Context *context = static_cast<gl::Context *>(ctx);
17959 EVENT("glPointParameterxv",
17960 "context = %d, GLenum pname = %s, const GLfixed *params = 0x%016" PRIxPTR "",
17961 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
17962
17963 if (context)
17964 {
17965 ASSERT(context == GetValidGlobalContext());
17966 PointParameter pnamePacked = FromGL<PointParameter>(pname);
17967 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17968 bool isCallValid =
17969 (context->skipValidation() || ValidatePointParameterxv(context, pnamePacked, params));
17970 if (isCallValid)
17971 {
17972 context->pointParameterxv(pnamePacked, params);
17973 }
17974 ANGLE_CAPTURE(PointParameterxv, isCallValid, context, pnamePacked, params);
17975 }
17976 }
17977
PointSizeContextANGLE(GLeglContext ctx,GLfloat size)17978 void GL_APIENTRY PointSizeContextANGLE(GLeglContext ctx, GLfloat size)
17979 {
17980 Context *context = static_cast<gl::Context *>(ctx);
17981 EVENT("glPointSize", "context = %d, GLfloat size = %f", CID(context), size);
17982
17983 if (context)
17984 {
17985 ASSERT(context == GetValidGlobalContext());
17986 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
17987 bool isCallValid = (context->skipValidation() || ValidatePointSize(context, size));
17988 if (isCallValid)
17989 {
17990 context->pointSize(size);
17991 }
17992 ANGLE_CAPTURE(PointSize, isCallValid, context, size);
17993 }
17994 }
17995
PointSizePointerOESContextANGLE(GLeglContext ctx,GLenum type,GLsizei stride,const void * pointer)17996 void GL_APIENTRY PointSizePointerOESContextANGLE(GLeglContext ctx,
17997 GLenum type,
17998 GLsizei stride,
17999 const void *pointer)
18000 {
18001 Context *context = static_cast<gl::Context *>(ctx);
18002 EVENT(
18003 "glPointSizePointerOES",
18004 "context = %d, GLenum type = %s, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR
18005 "",
18006 CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), stride, (uintptr_t)pointer);
18007
18008 if (context)
18009 {
18010 ASSERT(context == GetValidGlobalContext());
18011 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
18012 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18013 bool isCallValid = (context->skipValidation() ||
18014 ValidatePointSizePointerOES(context, typePacked, stride, pointer));
18015 if (isCallValid)
18016 {
18017 context->pointSizePointer(typePacked, stride, pointer);
18018 }
18019 ANGLE_CAPTURE(PointSizePointerOES, isCallValid, context, typePacked, stride, pointer);
18020 }
18021 }
18022
PointSizexContextANGLE(GLeglContext ctx,GLfixed size)18023 void GL_APIENTRY PointSizexContextANGLE(GLeglContext ctx, GLfixed size)
18024 {
18025 Context *context = static_cast<gl::Context *>(ctx);
18026 EVENT("glPointSizex", "context = %d, GLfixed size = 0x%X", CID(context), size);
18027
18028 if (context)
18029 {
18030 ASSERT(context == GetValidGlobalContext());
18031 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18032 bool isCallValid = (context->skipValidation() || ValidatePointSizex(context, size));
18033 if (isCallValid)
18034 {
18035 context->pointSizex(size);
18036 }
18037 ANGLE_CAPTURE(PointSizex, isCallValid, context, size);
18038 }
18039 }
18040
PolygonOffsetContextANGLE(GLeglContext ctx,GLfloat factor,GLfloat units)18041 void GL_APIENTRY PolygonOffsetContextANGLE(GLeglContext ctx, GLfloat factor, GLfloat units)
18042 {
18043 Context *context = static_cast<gl::Context *>(ctx);
18044 EVENT("glPolygonOffset", "context = %d, GLfloat factor = %f, GLfloat units = %f", CID(context),
18045 factor, units);
18046
18047 if (context)
18048 {
18049 ASSERT(context == GetValidGlobalContext());
18050 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18051 bool isCallValid =
18052 (context->skipValidation() || ValidatePolygonOffset(context, factor, units));
18053 if (isCallValid)
18054 {
18055 context->polygonOffset(factor, units);
18056 }
18057 ANGLE_CAPTURE(PolygonOffset, isCallValid, context, factor, units);
18058 }
18059 }
18060
PolygonOffsetxContextANGLE(GLeglContext ctx,GLfixed factor,GLfixed units)18061 void GL_APIENTRY PolygonOffsetxContextANGLE(GLeglContext ctx, GLfixed factor, GLfixed units)
18062 {
18063 Context *context = static_cast<gl::Context *>(ctx);
18064 EVENT("glPolygonOffsetx", "context = %d, GLfixed factor = 0x%X, GLfixed units = 0x%X",
18065 CID(context), factor, units);
18066
18067 if (context)
18068 {
18069 ASSERT(context == GetValidGlobalContext());
18070 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18071 bool isCallValid =
18072 (context->skipValidation() || ValidatePolygonOffsetx(context, factor, units));
18073 if (isCallValid)
18074 {
18075 context->polygonOffsetx(factor, units);
18076 }
18077 ANGLE_CAPTURE(PolygonOffsetx, isCallValid, context, factor, units);
18078 }
18079 }
18080
PopDebugGroupContextANGLE(GLeglContext ctx)18081 void GL_APIENTRY PopDebugGroupContextANGLE(GLeglContext ctx)
18082 {
18083 Context *context = static_cast<gl::Context *>(ctx);
18084 EVENT("glPopDebugGroup", "context = %d", CID(context));
18085
18086 if (context)
18087 {
18088 ASSERT(context == GetValidGlobalContext());
18089 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18090 bool isCallValid = (context->skipValidation() || ValidatePopDebugGroup(context));
18091 if (isCallValid)
18092 {
18093 context->popDebugGroup();
18094 }
18095 ANGLE_CAPTURE(PopDebugGroup, isCallValid, context);
18096 }
18097 }
18098
PopDebugGroupKHRContextANGLE(GLeglContext ctx)18099 void GL_APIENTRY PopDebugGroupKHRContextANGLE(GLeglContext ctx)
18100 {
18101 Context *context = static_cast<gl::Context *>(ctx);
18102 EVENT("glPopDebugGroupKHR", "context = %d", CID(context));
18103
18104 if (context)
18105 {
18106 ASSERT(context == GetValidGlobalContext());
18107 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18108 bool isCallValid = (context->skipValidation() || ValidatePopDebugGroupKHR(context));
18109 if (isCallValid)
18110 {
18111 context->popDebugGroup();
18112 }
18113 ANGLE_CAPTURE(PopDebugGroupKHR, isCallValid, context);
18114 }
18115 }
18116
PopGroupMarkerEXTContextANGLE(GLeglContext ctx)18117 void GL_APIENTRY PopGroupMarkerEXTContextANGLE(GLeglContext ctx)
18118 {
18119 Context *context = static_cast<gl::Context *>(ctx);
18120 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
18121 // It can interfere with the debug events being set by the caller.
18122 // EVENT("glPopGroupMarkerEXT", "context = %d", CID(context));
18123
18124 if (context)
18125 {
18126 ASSERT(context == GetValidGlobalContext());
18127 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18128 bool isCallValid = (context->skipValidation() || ValidatePopGroupMarkerEXT(context));
18129 if (isCallValid)
18130 {
18131 context->popGroupMarker();
18132 }
18133 ANGLE_CAPTURE(PopGroupMarkerEXT, isCallValid, context);
18134 }
18135 }
18136
PopMatrixContextANGLE(GLeglContext ctx)18137 void GL_APIENTRY PopMatrixContextANGLE(GLeglContext ctx)
18138 {
18139 Context *context = static_cast<gl::Context *>(ctx);
18140 EVENT("glPopMatrix", "context = %d", CID(context));
18141
18142 if (context)
18143 {
18144 ASSERT(context == GetValidGlobalContext());
18145 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18146 bool isCallValid = (context->skipValidation() || ValidatePopMatrix(context));
18147 if (isCallValid)
18148 {
18149 context->popMatrix();
18150 }
18151 ANGLE_CAPTURE(PopMatrix, isCallValid, context);
18152 }
18153 }
18154
PrimitiveBoundingBoxContextANGLE(GLeglContext ctx,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)18155 void GL_APIENTRY PrimitiveBoundingBoxContextANGLE(GLeglContext ctx,
18156 GLfloat minX,
18157 GLfloat minY,
18158 GLfloat minZ,
18159 GLfloat minW,
18160 GLfloat maxX,
18161 GLfloat maxY,
18162 GLfloat maxZ,
18163 GLfloat maxW)
18164 {
18165 Context *context = static_cast<gl::Context *>(ctx);
18166 EVENT("glPrimitiveBoundingBox",
18167 "context = %d, GLfloat minX = %f, GLfloat minY = %f, GLfloat minZ = %f, GLfloat minW = "
18168 "%f, GLfloat maxX = %f, GLfloat maxY = %f, GLfloat maxZ = %f, GLfloat maxW = %f",
18169 CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
18170
18171 if (context)
18172 {
18173 ASSERT(context == GetValidGlobalContext());
18174 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18175 bool isCallValid =
18176 (context->skipValidation() ||
18177 ValidatePrimitiveBoundingBox(context, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
18178 if (isCallValid)
18179 {
18180 context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
18181 }
18182 ANGLE_CAPTURE(PrimitiveBoundingBox, isCallValid, context, minX, minY, minZ, minW, maxX,
18183 maxY, maxZ, maxW);
18184 }
18185 }
18186
ProgramBinaryContextANGLE(GLeglContext ctx,GLuint program,GLenum binaryFormat,const void * binary,GLsizei length)18187 void GL_APIENTRY ProgramBinaryContextANGLE(GLeglContext ctx,
18188 GLuint program,
18189 GLenum binaryFormat,
18190 const void *binary,
18191 GLsizei length)
18192 {
18193 Context *context = static_cast<gl::Context *>(ctx);
18194 EVENT("glProgramBinary",
18195 "context = %d, GLuint program = %u, GLenum binaryFormat = %s, const void *binary = "
18196 "0x%016" PRIxPTR ", GLsizei length = %d",
18197 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat),
18198 (uintptr_t)binary, length);
18199
18200 if (context)
18201 {
18202 ASSERT(context == GetValidGlobalContext());
18203 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18204 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18205 bool isCallValid =
18206 (context->skipValidation() ||
18207 ValidateProgramBinary(context, programPacked, binaryFormat, binary, length));
18208 if (isCallValid)
18209 {
18210 context->programBinary(programPacked, binaryFormat, binary, length);
18211 }
18212 ANGLE_CAPTURE(ProgramBinary, isCallValid, context, programPacked, binaryFormat, binary,
18213 length);
18214 }
18215 }
18216
ProgramBinaryOESContextANGLE(GLeglContext ctx,GLuint program,GLenum binaryFormat,const void * binary,GLint length)18217 void GL_APIENTRY ProgramBinaryOESContextANGLE(GLeglContext ctx,
18218 GLuint program,
18219 GLenum binaryFormat,
18220 const void *binary,
18221 GLint length)
18222 {
18223 Context *context = static_cast<gl::Context *>(ctx);
18224 EVENT("glProgramBinaryOES",
18225 "context = %d, GLuint program = %u, GLenum binaryFormat = %s, const void *binary = "
18226 "0x%016" PRIxPTR ", GLint length = %d",
18227 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat),
18228 (uintptr_t)binary, length);
18229
18230 if (context)
18231 {
18232 ASSERT(context == GetValidGlobalContext());
18233 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18234 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18235 bool isCallValid =
18236 (context->skipValidation() ||
18237 ValidateProgramBinaryOES(context, programPacked, binaryFormat, binary, length));
18238 if (isCallValid)
18239 {
18240 context->programBinary(programPacked, binaryFormat, binary, length);
18241 }
18242 ANGLE_CAPTURE(ProgramBinaryOES, isCallValid, context, programPacked, binaryFormat, binary,
18243 length);
18244 }
18245 }
18246
ProgramParameteriContextANGLE(GLeglContext ctx,GLuint program,GLenum pname,GLint value)18247 void GL_APIENTRY ProgramParameteriContextANGLE(GLeglContext ctx,
18248 GLuint program,
18249 GLenum pname,
18250 GLint value)
18251 {
18252 Context *context = static_cast<gl::Context *>(ctx);
18253 EVENT("glProgramParameteri",
18254 "context = %d, GLuint program = %u, GLenum pname = %s, GLint value = %d", CID(context),
18255 program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value);
18256
18257 if (context)
18258 {
18259 ASSERT(context == GetValidGlobalContext());
18260 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18261 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18262 bool isCallValid = (context->skipValidation() ||
18263 ValidateProgramParameteri(context, programPacked, pname, value));
18264 if (isCallValid)
18265 {
18266 context->programParameteri(programPacked, pname, value);
18267 }
18268 ANGLE_CAPTURE(ProgramParameteri, isCallValid, context, programPacked, pname, value);
18269 }
18270 }
18271
ProgramUniform1fContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLfloat v0)18272 void GL_APIENTRY ProgramUniform1fContextANGLE(GLeglContext ctx,
18273 GLuint program,
18274 GLint location,
18275 GLfloat v0)
18276 {
18277 Context *context = static_cast<gl::Context *>(ctx);
18278 EVENT("glProgramUniform1f",
18279 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f", CID(context),
18280 program, location, v0);
18281
18282 if (context)
18283 {
18284 ASSERT(context == GetValidGlobalContext());
18285 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18286 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18287 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18288 bool isCallValid = (context->skipValidation() ||
18289 ValidateProgramUniform1f(context, programPacked, locationPacked, v0));
18290 if (isCallValid)
18291 {
18292 context->programUniform1f(programPacked, locationPacked, v0);
18293 }
18294 ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0);
18295 }
18296 }
18297
ProgramUniform1fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLfloat * value)18298 void GL_APIENTRY ProgramUniform1fvContextANGLE(GLeglContext ctx,
18299 GLuint program,
18300 GLint location,
18301 GLsizei count,
18302 const GLfloat *value)
18303 {
18304 Context *context = static_cast<gl::Context *>(ctx);
18305 EVENT("glProgramUniform1fv",
18306 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18307 "GLfloat *value = 0x%016" PRIxPTR "",
18308 CID(context), program, location, count, (uintptr_t)value);
18309
18310 if (context)
18311 {
18312 ASSERT(context == GetValidGlobalContext());
18313 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18314 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18315 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18316 bool isCallValid =
18317 (context->skipValidation() ||
18318 ValidateProgramUniform1fv(context, programPacked, locationPacked, count, value));
18319 if (isCallValid)
18320 {
18321 context->programUniform1fv(programPacked, locationPacked, count, value);
18322 }
18323 ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, count,
18324 value);
18325 }
18326 }
18327
ProgramUniform1iContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLint v0)18328 void GL_APIENTRY ProgramUniform1iContextANGLE(GLeglContext ctx,
18329 GLuint program,
18330 GLint location,
18331 GLint v0)
18332 {
18333 Context *context = static_cast<gl::Context *>(ctx);
18334 EVENT("glProgramUniform1i",
18335 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d", CID(context),
18336 program, location, v0);
18337
18338 if (context)
18339 {
18340 ASSERT(context == GetValidGlobalContext());
18341 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18342 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18343 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18344 bool isCallValid = (context->skipValidation() ||
18345 ValidateProgramUniform1i(context, programPacked, locationPacked, v0));
18346 if (isCallValid)
18347 {
18348 context->programUniform1i(programPacked, locationPacked, v0);
18349 }
18350 ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0);
18351 }
18352 }
18353
ProgramUniform1ivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLint * value)18354 void GL_APIENTRY ProgramUniform1ivContextANGLE(GLeglContext ctx,
18355 GLuint program,
18356 GLint location,
18357 GLsizei count,
18358 const GLint *value)
18359 {
18360 Context *context = static_cast<gl::Context *>(ctx);
18361 EVENT("glProgramUniform1iv",
18362 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
18363 "*value = 0x%016" PRIxPTR "",
18364 CID(context), program, location, count, (uintptr_t)value);
18365
18366 if (context)
18367 {
18368 ASSERT(context == GetValidGlobalContext());
18369 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18370 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18371 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18372 bool isCallValid =
18373 (context->skipValidation() ||
18374 ValidateProgramUniform1iv(context, programPacked, locationPacked, count, value));
18375 if (isCallValid)
18376 {
18377 context->programUniform1iv(programPacked, locationPacked, count, value);
18378 }
18379 ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, count,
18380 value);
18381 }
18382 }
18383
ProgramUniform1uiContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLuint v0)18384 void GL_APIENTRY ProgramUniform1uiContextANGLE(GLeglContext ctx,
18385 GLuint program,
18386 GLint location,
18387 GLuint v0)
18388 {
18389 Context *context = static_cast<gl::Context *>(ctx);
18390 EVENT("glProgramUniform1ui",
18391 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u", CID(context),
18392 program, location, v0);
18393
18394 if (context)
18395 {
18396 ASSERT(context == GetValidGlobalContext());
18397 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18398 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18399 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18400 bool isCallValid = (context->skipValidation() ||
18401 ValidateProgramUniform1ui(context, programPacked, locationPacked, v0));
18402 if (isCallValid)
18403 {
18404 context->programUniform1ui(programPacked, locationPacked, v0);
18405 }
18406 ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, v0);
18407 }
18408 }
18409
ProgramUniform1uivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLuint * value)18410 void GL_APIENTRY ProgramUniform1uivContextANGLE(GLeglContext ctx,
18411 GLuint program,
18412 GLint location,
18413 GLsizei count,
18414 const GLuint *value)
18415 {
18416 Context *context = static_cast<gl::Context *>(ctx);
18417 EVENT("glProgramUniform1uiv",
18418 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18419 "GLuint *value = 0x%016" PRIxPTR "",
18420 CID(context), program, location, count, (uintptr_t)value);
18421
18422 if (context)
18423 {
18424 ASSERT(context == GetValidGlobalContext());
18425 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18426 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18427 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18428 bool isCallValid =
18429 (context->skipValidation() ||
18430 ValidateProgramUniform1uiv(context, programPacked, locationPacked, count, value));
18431 if (isCallValid)
18432 {
18433 context->programUniform1uiv(programPacked, locationPacked, count, value);
18434 }
18435 ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked,
18436 count, value);
18437 }
18438 }
18439
ProgramUniform2fContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLfloat v0,GLfloat v1)18440 void GL_APIENTRY ProgramUniform2fContextANGLE(GLeglContext ctx,
18441 GLuint program,
18442 GLint location,
18443 GLfloat v0,
18444 GLfloat v1)
18445 {
18446 Context *context = static_cast<gl::Context *>(ctx);
18447 EVENT(
18448 "glProgramUniform2f",
18449 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f",
18450 CID(context), program, location, v0, v1);
18451
18452 if (context)
18453 {
18454 ASSERT(context == GetValidGlobalContext());
18455 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18456 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18457 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18458 bool isCallValid =
18459 (context->skipValidation() ||
18460 ValidateProgramUniform2f(context, programPacked, locationPacked, v0, v1));
18461 if (isCallValid)
18462 {
18463 context->programUniform2f(programPacked, locationPacked, v0, v1);
18464 }
18465 ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0,
18466 v1);
18467 }
18468 }
18469
ProgramUniform2fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLfloat * value)18470 void GL_APIENTRY ProgramUniform2fvContextANGLE(GLeglContext ctx,
18471 GLuint program,
18472 GLint location,
18473 GLsizei count,
18474 const GLfloat *value)
18475 {
18476 Context *context = static_cast<gl::Context *>(ctx);
18477 EVENT("glProgramUniform2fv",
18478 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18479 "GLfloat *value = 0x%016" PRIxPTR "",
18480 CID(context), program, location, count, (uintptr_t)value);
18481
18482 if (context)
18483 {
18484 ASSERT(context == GetValidGlobalContext());
18485 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18486 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18487 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18488 bool isCallValid =
18489 (context->skipValidation() ||
18490 ValidateProgramUniform2fv(context, programPacked, locationPacked, count, value));
18491 if (isCallValid)
18492 {
18493 context->programUniform2fv(programPacked, locationPacked, count, value);
18494 }
18495 ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, count,
18496 value);
18497 }
18498 }
18499
18500 void GL_APIENTRY
ProgramUniform2iContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLint v0,GLint v1)18501 ProgramUniform2iContextANGLE(GLeglContext ctx, GLuint program, GLint location, GLint v0, GLint v1)
18502 {
18503 Context *context = static_cast<gl::Context *>(ctx);
18504 EVENT("glProgramUniform2i",
18505 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d",
18506 CID(context), program, location, v0, v1);
18507
18508 if (context)
18509 {
18510 ASSERT(context == GetValidGlobalContext());
18511 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18512 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18513 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18514 bool isCallValid =
18515 (context->skipValidation() ||
18516 ValidateProgramUniform2i(context, programPacked, locationPacked, v0, v1));
18517 if (isCallValid)
18518 {
18519 context->programUniform2i(programPacked, locationPacked, v0, v1);
18520 }
18521 ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0,
18522 v1);
18523 }
18524 }
18525
ProgramUniform2ivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLint * value)18526 void GL_APIENTRY ProgramUniform2ivContextANGLE(GLeglContext ctx,
18527 GLuint program,
18528 GLint location,
18529 GLsizei count,
18530 const GLint *value)
18531 {
18532 Context *context = static_cast<gl::Context *>(ctx);
18533 EVENT("glProgramUniform2iv",
18534 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
18535 "*value = 0x%016" PRIxPTR "",
18536 CID(context), program, location, count, (uintptr_t)value);
18537
18538 if (context)
18539 {
18540 ASSERT(context == GetValidGlobalContext());
18541 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18542 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18543 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18544 bool isCallValid =
18545 (context->skipValidation() ||
18546 ValidateProgramUniform2iv(context, programPacked, locationPacked, count, value));
18547 if (isCallValid)
18548 {
18549 context->programUniform2iv(programPacked, locationPacked, count, value);
18550 }
18551 ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, count,
18552 value);
18553 }
18554 }
18555
ProgramUniform2uiContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLuint v0,GLuint v1)18556 void GL_APIENTRY ProgramUniform2uiContextANGLE(GLeglContext ctx,
18557 GLuint program,
18558 GLint location,
18559 GLuint v0,
18560 GLuint v1)
18561 {
18562 Context *context = static_cast<gl::Context *>(ctx);
18563 EVENT("glProgramUniform2ui",
18564 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u",
18565 CID(context), program, location, v0, v1);
18566
18567 if (context)
18568 {
18569 ASSERT(context == GetValidGlobalContext());
18570 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18571 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18572 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18573 bool isCallValid =
18574 (context->skipValidation() ||
18575 ValidateProgramUniform2ui(context, programPacked, locationPacked, v0, v1));
18576 if (isCallValid)
18577 {
18578 context->programUniform2ui(programPacked, locationPacked, v0, v1);
18579 }
18580 ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0,
18581 v1);
18582 }
18583 }
18584
ProgramUniform2uivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLuint * value)18585 void GL_APIENTRY ProgramUniform2uivContextANGLE(GLeglContext ctx,
18586 GLuint program,
18587 GLint location,
18588 GLsizei count,
18589 const GLuint *value)
18590 {
18591 Context *context = static_cast<gl::Context *>(ctx);
18592 EVENT("glProgramUniform2uiv",
18593 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18594 "GLuint *value = 0x%016" PRIxPTR "",
18595 CID(context), program, location, count, (uintptr_t)value);
18596
18597 if (context)
18598 {
18599 ASSERT(context == GetValidGlobalContext());
18600 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18601 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18602 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18603 bool isCallValid =
18604 (context->skipValidation() ||
18605 ValidateProgramUniform2uiv(context, programPacked, locationPacked, count, value));
18606 if (isCallValid)
18607 {
18608 context->programUniform2uiv(programPacked, locationPacked, count, value);
18609 }
18610 ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked,
18611 count, value);
18612 }
18613 }
18614
ProgramUniform3fContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)18615 void GL_APIENTRY ProgramUniform3fContextANGLE(GLeglContext ctx,
18616 GLuint program,
18617 GLint location,
18618 GLfloat v0,
18619 GLfloat v1,
18620 GLfloat v2)
18621 {
18622 Context *context = static_cast<gl::Context *>(ctx);
18623 EVENT("glProgramUniform3f",
18624 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = "
18625 "%f, GLfloat v2 = %f",
18626 CID(context), program, location, v0, v1, v2);
18627
18628 if (context)
18629 {
18630 ASSERT(context == GetValidGlobalContext());
18631 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18632 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18633 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18634 bool isCallValid =
18635 (context->skipValidation() ||
18636 ValidateProgramUniform3f(context, programPacked, locationPacked, v0, v1, v2));
18637 if (isCallValid)
18638 {
18639 context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
18640 }
18641 ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, v1,
18642 v2);
18643 }
18644 }
18645
ProgramUniform3fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLfloat * value)18646 void GL_APIENTRY ProgramUniform3fvContextANGLE(GLeglContext ctx,
18647 GLuint program,
18648 GLint location,
18649 GLsizei count,
18650 const GLfloat *value)
18651 {
18652 Context *context = static_cast<gl::Context *>(ctx);
18653 EVENT("glProgramUniform3fv",
18654 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18655 "GLfloat *value = 0x%016" PRIxPTR "",
18656 CID(context), program, location, count, (uintptr_t)value);
18657
18658 if (context)
18659 {
18660 ASSERT(context == GetValidGlobalContext());
18661 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18662 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18663 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18664 bool isCallValid =
18665 (context->skipValidation() ||
18666 ValidateProgramUniform3fv(context, programPacked, locationPacked, count, value));
18667 if (isCallValid)
18668 {
18669 context->programUniform3fv(programPacked, locationPacked, count, value);
18670 }
18671 ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, count,
18672 value);
18673 }
18674 }
18675
ProgramUniform3iContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLint v0,GLint v1,GLint v2)18676 void GL_APIENTRY ProgramUniform3iContextANGLE(GLeglContext ctx,
18677 GLuint program,
18678 GLint location,
18679 GLint v0,
18680 GLint v1,
18681 GLint v2)
18682 {
18683 Context *context = static_cast<gl::Context *>(ctx);
18684 EVENT("glProgramUniform3i",
18685 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, "
18686 "GLint v2 = %d",
18687 CID(context), program, location, v0, v1, v2);
18688
18689 if (context)
18690 {
18691 ASSERT(context == GetValidGlobalContext());
18692 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18693 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18694 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18695 bool isCallValid =
18696 (context->skipValidation() ||
18697 ValidateProgramUniform3i(context, programPacked, locationPacked, v0, v1, v2));
18698 if (isCallValid)
18699 {
18700 context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
18701 }
18702 ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, v1,
18703 v2);
18704 }
18705 }
18706
ProgramUniform3ivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLint * value)18707 void GL_APIENTRY ProgramUniform3ivContextANGLE(GLeglContext ctx,
18708 GLuint program,
18709 GLint location,
18710 GLsizei count,
18711 const GLint *value)
18712 {
18713 Context *context = static_cast<gl::Context *>(ctx);
18714 EVENT("glProgramUniform3iv",
18715 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
18716 "*value = 0x%016" PRIxPTR "",
18717 CID(context), program, location, count, (uintptr_t)value);
18718
18719 if (context)
18720 {
18721 ASSERT(context == GetValidGlobalContext());
18722 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18723 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18724 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18725 bool isCallValid =
18726 (context->skipValidation() ||
18727 ValidateProgramUniform3iv(context, programPacked, locationPacked, count, value));
18728 if (isCallValid)
18729 {
18730 context->programUniform3iv(programPacked, locationPacked, count, value);
18731 }
18732 ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, count,
18733 value);
18734 }
18735 }
18736
ProgramUniform3uiContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)18737 void GL_APIENTRY ProgramUniform3uiContextANGLE(GLeglContext ctx,
18738 GLuint program,
18739 GLint location,
18740 GLuint v0,
18741 GLuint v1,
18742 GLuint v2)
18743 {
18744 Context *context = static_cast<gl::Context *>(ctx);
18745 EVENT("glProgramUniform3ui",
18746 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, "
18747 "GLuint v2 = %u",
18748 CID(context), program, location, v0, v1, v2);
18749
18750 if (context)
18751 {
18752 ASSERT(context == GetValidGlobalContext());
18753 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18754 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18755 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18756 bool isCallValid =
18757 (context->skipValidation() ||
18758 ValidateProgramUniform3ui(context, programPacked, locationPacked, v0, v1, v2));
18759 if (isCallValid)
18760 {
18761 context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
18762 }
18763 ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0,
18764 v1, v2);
18765 }
18766 }
18767
ProgramUniform3uivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLuint * value)18768 void GL_APIENTRY ProgramUniform3uivContextANGLE(GLeglContext ctx,
18769 GLuint program,
18770 GLint location,
18771 GLsizei count,
18772 const GLuint *value)
18773 {
18774 Context *context = static_cast<gl::Context *>(ctx);
18775 EVENT("glProgramUniform3uiv",
18776 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18777 "GLuint *value = 0x%016" PRIxPTR "",
18778 CID(context), program, location, count, (uintptr_t)value);
18779
18780 if (context)
18781 {
18782 ASSERT(context == GetValidGlobalContext());
18783 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18784 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18785 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18786 bool isCallValid =
18787 (context->skipValidation() ||
18788 ValidateProgramUniform3uiv(context, programPacked, locationPacked, count, value));
18789 if (isCallValid)
18790 {
18791 context->programUniform3uiv(programPacked, locationPacked, count, value);
18792 }
18793 ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked,
18794 count, value);
18795 }
18796 }
18797
ProgramUniform4fContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)18798 void GL_APIENTRY ProgramUniform4fContextANGLE(GLeglContext ctx,
18799 GLuint program,
18800 GLint location,
18801 GLfloat v0,
18802 GLfloat v1,
18803 GLfloat v2,
18804 GLfloat v3)
18805 {
18806 Context *context = static_cast<gl::Context *>(ctx);
18807 EVENT("glProgramUniform4f",
18808 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = "
18809 "%f, GLfloat v2 = %f, GLfloat v3 = %f",
18810 CID(context), program, location, v0, v1, v2, v3);
18811
18812 if (context)
18813 {
18814 ASSERT(context == GetValidGlobalContext());
18815 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18816 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18817 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18818 bool isCallValid =
18819 (context->skipValidation() ||
18820 ValidateProgramUniform4f(context, programPacked, locationPacked, v0, v1, v2, v3));
18821 if (isCallValid)
18822 {
18823 context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
18824 }
18825 ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, v1,
18826 v2, v3);
18827 }
18828 }
18829
ProgramUniform4fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLfloat * value)18830 void GL_APIENTRY ProgramUniform4fvContextANGLE(GLeglContext ctx,
18831 GLuint program,
18832 GLint location,
18833 GLsizei count,
18834 const GLfloat *value)
18835 {
18836 Context *context = static_cast<gl::Context *>(ctx);
18837 EVENT("glProgramUniform4fv",
18838 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18839 "GLfloat *value = 0x%016" PRIxPTR "",
18840 CID(context), program, location, count, (uintptr_t)value);
18841
18842 if (context)
18843 {
18844 ASSERT(context == GetValidGlobalContext());
18845 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18846 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18847 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18848 bool isCallValid =
18849 (context->skipValidation() ||
18850 ValidateProgramUniform4fv(context, programPacked, locationPacked, count, value));
18851 if (isCallValid)
18852 {
18853 context->programUniform4fv(programPacked, locationPacked, count, value);
18854 }
18855 ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, count,
18856 value);
18857 }
18858 }
18859
ProgramUniform4iContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)18860 void GL_APIENTRY ProgramUniform4iContextANGLE(GLeglContext ctx,
18861 GLuint program,
18862 GLint location,
18863 GLint v0,
18864 GLint v1,
18865 GLint v2,
18866 GLint v3)
18867 {
18868 Context *context = static_cast<gl::Context *>(ctx);
18869 EVENT("glProgramUniform4i",
18870 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, "
18871 "GLint v2 = %d, GLint v3 = %d",
18872 CID(context), program, location, v0, v1, v2, v3);
18873
18874 if (context)
18875 {
18876 ASSERT(context == GetValidGlobalContext());
18877 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18878 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18879 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18880 bool isCallValid =
18881 (context->skipValidation() ||
18882 ValidateProgramUniform4i(context, programPacked, locationPacked, v0, v1, v2, v3));
18883 if (isCallValid)
18884 {
18885 context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
18886 }
18887 ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, v1,
18888 v2, v3);
18889 }
18890 }
18891
ProgramUniform4ivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLint * value)18892 void GL_APIENTRY ProgramUniform4ivContextANGLE(GLeglContext ctx,
18893 GLuint program,
18894 GLint location,
18895 GLsizei count,
18896 const GLint *value)
18897 {
18898 Context *context = static_cast<gl::Context *>(ctx);
18899 EVENT("glProgramUniform4iv",
18900 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
18901 "*value = 0x%016" PRIxPTR "",
18902 CID(context), program, location, count, (uintptr_t)value);
18903
18904 if (context)
18905 {
18906 ASSERT(context == GetValidGlobalContext());
18907 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18908 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18909 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18910 bool isCallValid =
18911 (context->skipValidation() ||
18912 ValidateProgramUniform4iv(context, programPacked, locationPacked, count, value));
18913 if (isCallValid)
18914 {
18915 context->programUniform4iv(programPacked, locationPacked, count, value);
18916 }
18917 ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, count,
18918 value);
18919 }
18920 }
18921
ProgramUniform4uiContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)18922 void GL_APIENTRY ProgramUniform4uiContextANGLE(GLeglContext ctx,
18923 GLuint program,
18924 GLint location,
18925 GLuint v0,
18926 GLuint v1,
18927 GLuint v2,
18928 GLuint v3)
18929 {
18930 Context *context = static_cast<gl::Context *>(ctx);
18931 EVENT("glProgramUniform4ui",
18932 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, "
18933 "GLuint v2 = %u, GLuint v3 = %u",
18934 CID(context), program, location, v0, v1, v2, v3);
18935
18936 if (context)
18937 {
18938 ASSERT(context == GetValidGlobalContext());
18939 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18940 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18941 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18942 bool isCallValid =
18943 (context->skipValidation() ||
18944 ValidateProgramUniform4ui(context, programPacked, locationPacked, v0, v1, v2, v3));
18945 if (isCallValid)
18946 {
18947 context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
18948 }
18949 ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0,
18950 v1, v2, v3);
18951 }
18952 }
18953
ProgramUniform4uivContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,const GLuint * value)18954 void GL_APIENTRY ProgramUniform4uivContextANGLE(GLeglContext ctx,
18955 GLuint program,
18956 GLint location,
18957 GLsizei count,
18958 const GLuint *value)
18959 {
18960 Context *context = static_cast<gl::Context *>(ctx);
18961 EVENT("glProgramUniform4uiv",
18962 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
18963 "GLuint *value = 0x%016" PRIxPTR "",
18964 CID(context), program, location, count, (uintptr_t)value);
18965
18966 if (context)
18967 {
18968 ASSERT(context == GetValidGlobalContext());
18969 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
18970 UniformLocation locationPacked = FromGL<UniformLocation>(location);
18971 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
18972 bool isCallValid =
18973 (context->skipValidation() ||
18974 ValidateProgramUniform4uiv(context, programPacked, locationPacked, count, value));
18975 if (isCallValid)
18976 {
18977 context->programUniform4uiv(programPacked, locationPacked, count, value);
18978 }
18979 ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked,
18980 count, value);
18981 }
18982 }
18983
ProgramUniformMatrix2fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)18984 void GL_APIENTRY ProgramUniformMatrix2fvContextANGLE(GLeglContext ctx,
18985 GLuint program,
18986 GLint location,
18987 GLsizei count,
18988 GLboolean transpose,
18989 const GLfloat *value)
18990 {
18991 Context *context = static_cast<gl::Context *>(ctx);
18992 EVENT("glProgramUniformMatrix2fv",
18993 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
18994 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
18995 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
18996
18997 if (context)
18998 {
18999 ASSERT(context == GetValidGlobalContext());
19000 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19001 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19002 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19003 bool isCallValid = (context->skipValidation() ||
19004 ValidateProgramUniformMatrix2fv(context, programPacked, locationPacked,
19005 count, transpose, value));
19006 if (isCallValid)
19007 {
19008 context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
19009 value);
19010 }
19011 ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, locationPacked,
19012 count, transpose, value);
19013 }
19014 }
19015
ProgramUniformMatrix2x3fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19016 void GL_APIENTRY ProgramUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
19017 GLuint program,
19018 GLint location,
19019 GLsizei count,
19020 GLboolean transpose,
19021 const GLfloat *value)
19022 {
19023 Context *context = static_cast<gl::Context *>(ctx);
19024 EVENT("glProgramUniformMatrix2x3fv",
19025 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19026 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19027 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19028
19029 if (context)
19030 {
19031 ASSERT(context == GetValidGlobalContext());
19032 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19033 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19034 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19035 bool isCallValid = (context->skipValidation() ||
19036 ValidateProgramUniformMatrix2x3fv(
19037 context, programPacked, locationPacked, count, transpose, value));
19038 if (isCallValid)
19039 {
19040 context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
19041 value);
19042 }
19043 ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked,
19044 locationPacked, count, transpose, value);
19045 }
19046 }
19047
ProgramUniformMatrix2x4fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19048 void GL_APIENTRY ProgramUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
19049 GLuint program,
19050 GLint location,
19051 GLsizei count,
19052 GLboolean transpose,
19053 const GLfloat *value)
19054 {
19055 Context *context = static_cast<gl::Context *>(ctx);
19056 EVENT("glProgramUniformMatrix2x4fv",
19057 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19058 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19059 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19060
19061 if (context)
19062 {
19063 ASSERT(context == GetValidGlobalContext());
19064 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19065 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19066 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19067 bool isCallValid = (context->skipValidation() ||
19068 ValidateProgramUniformMatrix2x4fv(
19069 context, programPacked, locationPacked, count, transpose, value));
19070 if (isCallValid)
19071 {
19072 context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
19073 value);
19074 }
19075 ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked,
19076 locationPacked, count, transpose, value);
19077 }
19078 }
19079
ProgramUniformMatrix3fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19080 void GL_APIENTRY ProgramUniformMatrix3fvContextANGLE(GLeglContext ctx,
19081 GLuint program,
19082 GLint location,
19083 GLsizei count,
19084 GLboolean transpose,
19085 const GLfloat *value)
19086 {
19087 Context *context = static_cast<gl::Context *>(ctx);
19088 EVENT("glProgramUniformMatrix3fv",
19089 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19090 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19091 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19092
19093 if (context)
19094 {
19095 ASSERT(context == GetValidGlobalContext());
19096 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19097 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19098 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19099 bool isCallValid = (context->skipValidation() ||
19100 ValidateProgramUniformMatrix3fv(context, programPacked, locationPacked,
19101 count, transpose, value));
19102 if (isCallValid)
19103 {
19104 context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
19105 value);
19106 }
19107 ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, locationPacked,
19108 count, transpose, value);
19109 }
19110 }
19111
ProgramUniformMatrix3x2fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19112 void GL_APIENTRY ProgramUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
19113 GLuint program,
19114 GLint location,
19115 GLsizei count,
19116 GLboolean transpose,
19117 const GLfloat *value)
19118 {
19119 Context *context = static_cast<gl::Context *>(ctx);
19120 EVENT("glProgramUniformMatrix3x2fv",
19121 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19122 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19123 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19124
19125 if (context)
19126 {
19127 ASSERT(context == GetValidGlobalContext());
19128 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19129 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19130 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19131 bool isCallValid = (context->skipValidation() ||
19132 ValidateProgramUniformMatrix3x2fv(
19133 context, programPacked, locationPacked, count, transpose, value));
19134 if (isCallValid)
19135 {
19136 context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
19137 value);
19138 }
19139 ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked,
19140 locationPacked, count, transpose, value);
19141 }
19142 }
19143
ProgramUniformMatrix3x4fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19144 void GL_APIENTRY ProgramUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
19145 GLuint program,
19146 GLint location,
19147 GLsizei count,
19148 GLboolean transpose,
19149 const GLfloat *value)
19150 {
19151 Context *context = static_cast<gl::Context *>(ctx);
19152 EVENT("glProgramUniformMatrix3x4fv",
19153 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19154 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19155 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19156
19157 if (context)
19158 {
19159 ASSERT(context == GetValidGlobalContext());
19160 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19161 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19162 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19163 bool isCallValid = (context->skipValidation() ||
19164 ValidateProgramUniformMatrix3x4fv(
19165 context, programPacked, locationPacked, count, transpose, value));
19166 if (isCallValid)
19167 {
19168 context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
19169 value);
19170 }
19171 ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked,
19172 locationPacked, count, transpose, value);
19173 }
19174 }
19175
ProgramUniformMatrix4fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19176 void GL_APIENTRY ProgramUniformMatrix4fvContextANGLE(GLeglContext ctx,
19177 GLuint program,
19178 GLint location,
19179 GLsizei count,
19180 GLboolean transpose,
19181 const GLfloat *value)
19182 {
19183 Context *context = static_cast<gl::Context *>(ctx);
19184 EVENT("glProgramUniformMatrix4fv",
19185 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19186 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19187 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19188
19189 if (context)
19190 {
19191 ASSERT(context == GetValidGlobalContext());
19192 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19193 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19194 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19195 bool isCallValid = (context->skipValidation() ||
19196 ValidateProgramUniformMatrix4fv(context, programPacked, locationPacked,
19197 count, transpose, value));
19198 if (isCallValid)
19199 {
19200 context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
19201 value);
19202 }
19203 ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, locationPacked,
19204 count, transpose, value);
19205 }
19206 }
19207
ProgramUniformMatrix4x2fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19208 void GL_APIENTRY ProgramUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
19209 GLuint program,
19210 GLint location,
19211 GLsizei count,
19212 GLboolean transpose,
19213 const GLfloat *value)
19214 {
19215 Context *context = static_cast<gl::Context *>(ctx);
19216 EVENT("glProgramUniformMatrix4x2fv",
19217 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19218 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19219 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19220
19221 if (context)
19222 {
19223 ASSERT(context == GetValidGlobalContext());
19224 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19225 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19226 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19227 bool isCallValid = (context->skipValidation() ||
19228 ValidateProgramUniformMatrix4x2fv(
19229 context, programPacked, locationPacked, count, transpose, value));
19230 if (isCallValid)
19231 {
19232 context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
19233 value);
19234 }
19235 ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked,
19236 locationPacked, count, transpose, value);
19237 }
19238 }
19239
ProgramUniformMatrix4x3fvContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)19240 void GL_APIENTRY ProgramUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
19241 GLuint program,
19242 GLint location,
19243 GLsizei count,
19244 GLboolean transpose,
19245 const GLfloat *value)
19246 {
19247 Context *context = static_cast<gl::Context *>(ctx);
19248 EVENT("glProgramUniformMatrix4x3fv",
19249 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
19250 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
19251 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
19252
19253 if (context)
19254 {
19255 ASSERT(context == GetValidGlobalContext());
19256 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
19257 UniformLocation locationPacked = FromGL<UniformLocation>(location);
19258 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19259 bool isCallValid = (context->skipValidation() ||
19260 ValidateProgramUniformMatrix4x3fv(
19261 context, programPacked, locationPacked, count, transpose, value));
19262 if (isCallValid)
19263 {
19264 context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
19265 value);
19266 }
19267 ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked,
19268 locationPacked, count, transpose, value);
19269 }
19270 }
19271
PushDebugGroupContextANGLE(GLeglContext ctx,GLenum source,GLuint id,GLsizei length,const GLchar * message)19272 void GL_APIENTRY PushDebugGroupContextANGLE(GLeglContext ctx,
19273 GLenum source,
19274 GLuint id,
19275 GLsizei length,
19276 const GLchar *message)
19277 {
19278 Context *context = static_cast<gl::Context *>(ctx);
19279 EVENT("glPushDebugGroup",
19280 "context = %d, GLenum source = %s, GLuint id = %u, GLsizei length = %d, const GLchar "
19281 "*message = 0x%016" PRIxPTR "",
19282 CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length,
19283 (uintptr_t)message);
19284
19285 if (context)
19286 {
19287 ASSERT(context == GetValidGlobalContext());
19288 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19289 bool isCallValid = (context->skipValidation() ||
19290 ValidatePushDebugGroup(context, source, id, length, message));
19291 if (isCallValid)
19292 {
19293 context->pushDebugGroup(source, id, length, message);
19294 }
19295 ANGLE_CAPTURE(PushDebugGroup, isCallValid, context, source, id, length, message);
19296 }
19297 }
19298
PushDebugGroupKHRContextANGLE(GLeglContext ctx,GLenum source,GLuint id,GLsizei length,const GLchar * message)19299 void GL_APIENTRY PushDebugGroupKHRContextANGLE(GLeglContext ctx,
19300 GLenum source,
19301 GLuint id,
19302 GLsizei length,
19303 const GLchar *message)
19304 {
19305 Context *context = static_cast<gl::Context *>(ctx);
19306 EVENT("glPushDebugGroupKHR",
19307 "context = %d, GLenum source = %s, GLuint id = %u, GLsizei length = %d, const GLchar "
19308 "*message = 0x%016" PRIxPTR "",
19309 CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length,
19310 (uintptr_t)message);
19311
19312 if (context)
19313 {
19314 ASSERT(context == GetValidGlobalContext());
19315 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19316 bool isCallValid = (context->skipValidation() ||
19317 ValidatePushDebugGroupKHR(context, source, id, length, message));
19318 if (isCallValid)
19319 {
19320 context->pushDebugGroup(source, id, length, message);
19321 }
19322 ANGLE_CAPTURE(PushDebugGroupKHR, isCallValid, context, source, id, length, message);
19323 }
19324 }
19325
PushGroupMarkerEXTContextANGLE(GLeglContext ctx,GLsizei length,const GLchar * marker)19326 void GL_APIENTRY PushGroupMarkerEXTContextANGLE(GLeglContext ctx,
19327 GLsizei length,
19328 const GLchar *marker)
19329 {
19330 Context *context = static_cast<gl::Context *>(ctx);
19331 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
19332 // It can interfere with the debug events being set by the caller.
19333 // EVENT("glPushGroupMarkerEXT", "context = %d, GLsizei length = %d, const GLchar *marker =
19334 // 0x%016" PRIxPTR "", CID(context), length, (uintptr_t)marker);
19335
19336 if (context)
19337 {
19338 ASSERT(context == GetValidGlobalContext());
19339 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19340 bool isCallValid =
19341 (context->skipValidation() || ValidatePushGroupMarkerEXT(context, length, marker));
19342 if (isCallValid)
19343 {
19344 context->pushGroupMarker(length, marker);
19345 }
19346 ANGLE_CAPTURE(PushGroupMarkerEXT, isCallValid, context, length, marker);
19347 }
19348 }
19349
PushMatrixContextANGLE(GLeglContext ctx)19350 void GL_APIENTRY PushMatrixContextANGLE(GLeglContext ctx)
19351 {
19352 Context *context = static_cast<gl::Context *>(ctx);
19353 EVENT("glPushMatrix", "context = %d", CID(context));
19354
19355 if (context)
19356 {
19357 ASSERT(context == GetValidGlobalContext());
19358 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19359 bool isCallValid = (context->skipValidation() || ValidatePushMatrix(context));
19360 if (isCallValid)
19361 {
19362 context->pushMatrix();
19363 }
19364 ANGLE_CAPTURE(PushMatrix, isCallValid, context);
19365 }
19366 }
19367
QueryCounterEXTContextANGLE(GLeglContext ctx,GLuint id,GLenum target)19368 void GL_APIENTRY QueryCounterEXTContextANGLE(GLeglContext ctx, GLuint id, GLenum target)
19369 {
19370 Context *context = static_cast<gl::Context *>(ctx);
19371 EVENT("glQueryCounterEXT", "context = %d, GLuint id = %u, GLenum target = %s", CID(context), id,
19372 GLenumToString(GLenumGroup::QueryTarget, target));
19373
19374 if (context)
19375 {
19376 ASSERT(context == GetValidGlobalContext());
19377 QueryID idPacked = FromGL<QueryID>(id);
19378 QueryType targetPacked = FromGL<QueryType>(target);
19379 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19380 bool isCallValid =
19381 (context->skipValidation() || ValidateQueryCounterEXT(context, idPacked, targetPacked));
19382 if (isCallValid)
19383 {
19384 context->queryCounter(idPacked, targetPacked);
19385 }
19386 ANGLE_CAPTURE(QueryCounterEXT, isCallValid, context, idPacked, targetPacked);
19387 }
19388 }
19389
QueryMatrixxOESContextANGLE(GLeglContext ctx,GLfixed * mantissa,GLint * exponent)19390 GLbitfield GL_APIENTRY QueryMatrixxOESContextANGLE(GLeglContext ctx,
19391 GLfixed *mantissa,
19392 GLint *exponent)
19393 {
19394 Context *context = static_cast<gl::Context *>(ctx);
19395 EVENT("glQueryMatrixxOES",
19396 "context = %d, GLfixed *mantissa = 0x%016" PRIxPTR ", GLint *exponent = 0x%016" PRIxPTR
19397 "",
19398 CID(context), (uintptr_t)mantissa, (uintptr_t)exponent);
19399
19400 GLbitfield returnValue;
19401 if (context)
19402 {
19403 ASSERT(context == GetValidGlobalContext());
19404 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19405 bool isCallValid =
19406 (context->skipValidation() || ValidateQueryMatrixxOES(context, mantissa, exponent));
19407 if (isCallValid)
19408 {
19409 returnValue = context->queryMatrixx(mantissa, exponent);
19410 }
19411 else
19412 {
19413 returnValue = GetDefaultReturnValue<EntryPoint::QueryMatrixxOES, GLbitfield>();
19414 }
19415 ANGLE_CAPTURE(QueryMatrixxOES, isCallValid, context, mantissa, exponent, returnValue);
19416 }
19417 else
19418 {
19419 returnValue = GetDefaultReturnValue<EntryPoint::QueryMatrixxOES, GLbitfield>();
19420 }
19421 return returnValue;
19422 }
19423
ReadBufferContextANGLE(GLeglContext ctx,GLenum src)19424 void GL_APIENTRY ReadBufferContextANGLE(GLeglContext ctx, GLenum src)
19425 {
19426 Context *context = static_cast<gl::Context *>(ctx);
19427 EVENT("glReadBuffer", "context = %d, GLenum src = %s", CID(context),
19428 GLenumToString(GLenumGroup::ReadBufferMode, src));
19429
19430 if (context)
19431 {
19432 ASSERT(context == GetValidGlobalContext());
19433 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19434 bool isCallValid = (context->skipValidation() || ValidateReadBuffer(context, src));
19435 if (isCallValid)
19436 {
19437 context->readBuffer(src);
19438 }
19439 ANGLE_CAPTURE(ReadBuffer, isCallValid, context, src);
19440 }
19441 }
19442
ReadPixelsContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void * pixels)19443 void GL_APIENTRY ReadPixelsContextANGLE(GLeglContext ctx,
19444 GLint x,
19445 GLint y,
19446 GLsizei width,
19447 GLsizei height,
19448 GLenum format,
19449 GLenum type,
19450 void *pixels)
19451 {
19452 Context *context = static_cast<gl::Context *>(ctx);
19453 EVENT("glReadPixels",
19454 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
19455 "GLenum format = %s, GLenum type = %s, void *pixels = 0x%016" PRIxPTR "",
19456 CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
19457 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
19458
19459 if (context)
19460 {
19461 ASSERT(context == GetValidGlobalContext());
19462 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19463 bool isCallValid = (context->skipValidation() ||
19464 ValidateReadPixels(context, x, y, width, height, format, type, pixels));
19465 if (isCallValid)
19466 {
19467 context->readPixels(x, y, width, height, format, type, pixels);
19468 }
19469 ANGLE_CAPTURE(ReadPixels, isCallValid, context, x, y, width, height, format, type, pixels);
19470 }
19471 }
19472
ReadnPixelsContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)19473 void GL_APIENTRY ReadnPixelsContextANGLE(GLeglContext ctx,
19474 GLint x,
19475 GLint y,
19476 GLsizei width,
19477 GLsizei height,
19478 GLenum format,
19479 GLenum type,
19480 GLsizei bufSize,
19481 void *data)
19482 {
19483 Context *context = static_cast<gl::Context *>(ctx);
19484 EVENT("glReadnPixels",
19485 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
19486 "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, void *data = 0x%016" PRIxPTR
19487 "",
19488 CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
19489 GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data);
19490
19491 if (context)
19492 {
19493 ASSERT(context == GetValidGlobalContext());
19494 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19495 bool isCallValid =
19496 (context->skipValidation() ||
19497 ValidateReadnPixels(context, x, y, width, height, format, type, bufSize, data));
19498 if (isCallValid)
19499 {
19500 context->readnPixels(x, y, width, height, format, type, bufSize, data);
19501 }
19502 ANGLE_CAPTURE(ReadnPixels, isCallValid, context, x, y, width, height, format, type, bufSize,
19503 data);
19504 }
19505 }
19506
ReadnPixelsEXTContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)19507 void GL_APIENTRY ReadnPixelsEXTContextANGLE(GLeglContext ctx,
19508 GLint x,
19509 GLint y,
19510 GLsizei width,
19511 GLsizei height,
19512 GLenum format,
19513 GLenum type,
19514 GLsizei bufSize,
19515 void *data)
19516 {
19517 Context *context = static_cast<gl::Context *>(ctx);
19518 EVENT("glReadnPixelsEXT",
19519 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
19520 "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, void *data = 0x%016" PRIxPTR
19521 "",
19522 CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
19523 GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data);
19524
19525 if (context)
19526 {
19527 ASSERT(context == GetValidGlobalContext());
19528 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19529 bool isCallValid =
19530 (context->skipValidation() ||
19531 ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data));
19532 if (isCallValid)
19533 {
19534 context->readnPixels(x, y, width, height, format, type, bufSize, data);
19535 }
19536 ANGLE_CAPTURE(ReadnPixelsEXT, isCallValid, context, x, y, width, height, format, type,
19537 bufSize, data);
19538 }
19539 }
19540
ReleaseShaderCompilerContextANGLE(GLeglContext ctx)19541 void GL_APIENTRY ReleaseShaderCompilerContextANGLE(GLeglContext ctx)
19542 {
19543 Context *context = static_cast<gl::Context *>(ctx);
19544 EVENT("glReleaseShaderCompiler", "context = %d", CID(context));
19545
19546 if (context)
19547 {
19548 ASSERT(context == GetValidGlobalContext());
19549 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19550 bool isCallValid = (context->skipValidation() || ValidateReleaseShaderCompiler(context));
19551 if (isCallValid)
19552 {
19553 context->releaseShaderCompiler();
19554 }
19555 ANGLE_CAPTURE(ReleaseShaderCompiler, isCallValid, context);
19556 }
19557 }
19558
RenderbufferStorageContextANGLE(GLeglContext ctx,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)19559 void GL_APIENTRY RenderbufferStorageContextANGLE(GLeglContext ctx,
19560 GLenum target,
19561 GLenum internalformat,
19562 GLsizei width,
19563 GLsizei height)
19564 {
19565 Context *context = static_cast<gl::Context *>(ctx);
19566 EVENT("glRenderbufferStorage",
19567 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLsizei width = %d, "
19568 "GLsizei height = %d",
19569 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
19570 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
19571
19572 if (context)
19573 {
19574 ASSERT(context == GetValidGlobalContext());
19575 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19576 bool isCallValid =
19577 (context->skipValidation() ||
19578 ValidateRenderbufferStorage(context, target, internalformat, width, height));
19579 if (isCallValid)
19580 {
19581 context->renderbufferStorage(target, internalformat, width, height);
19582 }
19583 ANGLE_CAPTURE(RenderbufferStorage, isCallValid, context, target, internalformat, width,
19584 height);
19585 }
19586 }
19587
RenderbufferStorageMultisampleContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)19588 void GL_APIENTRY RenderbufferStorageMultisampleContextANGLE(GLeglContext ctx,
19589 GLenum target,
19590 GLsizei samples,
19591 GLenum internalformat,
19592 GLsizei width,
19593 GLsizei height)
19594 {
19595 Context *context = static_cast<gl::Context *>(ctx);
19596 EVENT("glRenderbufferStorageMultisample",
19597 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
19598 "GLsizei width = %d, GLsizei height = %d",
19599 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
19600 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
19601
19602 if (context)
19603 {
19604 ASSERT(context == GetValidGlobalContext());
19605 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19606 bool isCallValid = (context->skipValidation() ||
19607 ValidateRenderbufferStorageMultisample(context, target, samples,
19608 internalformat, width, height));
19609 if (isCallValid)
19610 {
19611 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
19612 }
19613 ANGLE_CAPTURE(RenderbufferStorageMultisample, isCallValid, context, target, samples,
19614 internalformat, width, height);
19615 }
19616 }
19617
RenderbufferStorageMultisampleANGLEContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)19618 void GL_APIENTRY RenderbufferStorageMultisampleANGLEContextANGLE(GLeglContext ctx,
19619 GLenum target,
19620 GLsizei samples,
19621 GLenum internalformat,
19622 GLsizei width,
19623 GLsizei height)
19624 {
19625 Context *context = static_cast<gl::Context *>(ctx);
19626 EVENT("glRenderbufferStorageMultisampleANGLE",
19627 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
19628 "GLsizei width = %d, GLsizei height = %d",
19629 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
19630 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
19631
19632 if (context)
19633 {
19634 ASSERT(context == GetValidGlobalContext());
19635 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19636 bool isCallValid = (context->skipValidation() ||
19637 ValidateRenderbufferStorageMultisampleANGLE(
19638 context, target, samples, internalformat, width, height));
19639 if (isCallValid)
19640 {
19641 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
19642 }
19643 ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples,
19644 internalformat, width, height);
19645 }
19646 }
19647
RenderbufferStorageMultisampleEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)19648 void GL_APIENTRY RenderbufferStorageMultisampleEXTContextANGLE(GLeglContext ctx,
19649 GLenum target,
19650 GLsizei samples,
19651 GLenum internalformat,
19652 GLsizei width,
19653 GLsizei height)
19654 {
19655 Context *context = static_cast<gl::Context *>(ctx);
19656 EVENT("glRenderbufferStorageMultisampleEXT",
19657 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
19658 "GLsizei width = %d, GLsizei height = %d",
19659 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
19660 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
19661
19662 if (context)
19663 {
19664 ASSERT(context == GetValidGlobalContext());
19665 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19666 bool isCallValid = (context->skipValidation() ||
19667 ValidateRenderbufferStorageMultisampleEXT(
19668 context, target, samples, internalformat, width, height));
19669 if (isCallValid)
19670 {
19671 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
19672 }
19673 ANGLE_CAPTURE(RenderbufferStorageMultisampleEXT, isCallValid, context, target, samples,
19674 internalformat, width, height);
19675 }
19676 }
19677
RenderbufferStorageOESContextANGLE(GLeglContext ctx,GLenum target,GLenum internalformat,GLsizei width,GLsizei height)19678 void GL_APIENTRY RenderbufferStorageOESContextANGLE(GLeglContext ctx,
19679 GLenum target,
19680 GLenum internalformat,
19681 GLsizei width,
19682 GLsizei height)
19683 {
19684 Context *context = static_cast<gl::Context *>(ctx);
19685 EVENT("glRenderbufferStorageOES",
19686 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLsizei width = %d, "
19687 "GLsizei height = %d",
19688 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
19689 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
19690
19691 if (context)
19692 {
19693 ASSERT(context == GetValidGlobalContext());
19694 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19695 bool isCallValid =
19696 (context->skipValidation() ||
19697 ValidateRenderbufferStorageOES(context, target, internalformat, width, height));
19698 if (isCallValid)
19699 {
19700 context->renderbufferStorage(target, internalformat, width, height);
19701 }
19702 ANGLE_CAPTURE(RenderbufferStorageOES, isCallValid, context, target, internalformat, width,
19703 height);
19704 }
19705 }
19706
ResumeTransformFeedbackContextANGLE(GLeglContext ctx)19707 void GL_APIENTRY ResumeTransformFeedbackContextANGLE(GLeglContext ctx)
19708 {
19709 Context *context = static_cast<gl::Context *>(ctx);
19710 EVENT("glResumeTransformFeedback", "context = %d", CID(context));
19711
19712 if (context)
19713 {
19714 ASSERT(context == GetValidGlobalContext());
19715 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19716 bool isCallValid = (context->skipValidation() || ValidateResumeTransformFeedback(context));
19717 if (isCallValid)
19718 {
19719 context->resumeTransformFeedback();
19720 }
19721 ANGLE_CAPTURE(ResumeTransformFeedback, isCallValid, context);
19722 }
19723 }
19724
19725 void GL_APIENTRY
RotatefContextANGLE(GLeglContext ctx,GLfloat angle,GLfloat x,GLfloat y,GLfloat z)19726 RotatefContextANGLE(GLeglContext ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
19727 {
19728 Context *context = static_cast<gl::Context *>(ctx);
19729 EVENT("glRotatef",
19730 "context = %d, GLfloat angle = %f, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f",
19731 CID(context), angle, x, y, z);
19732
19733 if (context)
19734 {
19735 ASSERT(context == GetValidGlobalContext());
19736 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19737 bool isCallValid = (context->skipValidation() || ValidateRotatef(context, angle, x, y, z));
19738 if (isCallValid)
19739 {
19740 context->rotatef(angle, x, y, z);
19741 }
19742 ANGLE_CAPTURE(Rotatef, isCallValid, context, angle, x, y, z);
19743 }
19744 }
19745
19746 void GL_APIENTRY
RotatexContextANGLE(GLeglContext ctx,GLfixed angle,GLfixed x,GLfixed y,GLfixed z)19747 RotatexContextANGLE(GLeglContext ctx, GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
19748 {
19749 Context *context = static_cast<gl::Context *>(ctx);
19750 EVENT(
19751 "glRotatex",
19752 "context = %d, GLfixed angle = 0x%X, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X",
19753 CID(context), angle, x, y, z);
19754
19755 if (context)
19756 {
19757 ASSERT(context == GetValidGlobalContext());
19758 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19759 bool isCallValid = (context->skipValidation() || ValidateRotatex(context, angle, x, y, z));
19760 if (isCallValid)
19761 {
19762 context->rotatex(angle, x, y, z);
19763 }
19764 ANGLE_CAPTURE(Rotatex, isCallValid, context, angle, x, y, z);
19765 }
19766 }
19767
SampleCoverageContextANGLE(GLeglContext ctx,GLfloat value,GLboolean invert)19768 void GL_APIENTRY SampleCoverageContextANGLE(GLeglContext ctx, GLfloat value, GLboolean invert)
19769 {
19770 Context *context = static_cast<gl::Context *>(ctx);
19771 EVENT("glSampleCoverage", "context = %d, GLfloat value = %f, GLboolean invert = %s",
19772 CID(context), value, GLbooleanToString(invert));
19773
19774 if (context)
19775 {
19776 ASSERT(context == GetValidGlobalContext());
19777 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19778 bool isCallValid =
19779 (context->skipValidation() || ValidateSampleCoverage(context, value, invert));
19780 if (isCallValid)
19781 {
19782 context->sampleCoverage(value, invert);
19783 }
19784 ANGLE_CAPTURE(SampleCoverage, isCallValid, context, value, invert);
19785 }
19786 }
19787
SampleCoveragexContextANGLE(GLeglContext ctx,GLclampx value,GLboolean invert)19788 void GL_APIENTRY SampleCoveragexContextANGLE(GLeglContext ctx, GLclampx value, GLboolean invert)
19789 {
19790 Context *context = static_cast<gl::Context *>(ctx);
19791 EVENT("glSampleCoveragex", "context = %d, GLclampx value = 0x%X, GLboolean invert = %s",
19792 CID(context), value, GLbooleanToString(invert));
19793
19794 if (context)
19795 {
19796 ASSERT(context == GetValidGlobalContext());
19797 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19798 bool isCallValid =
19799 (context->skipValidation() || ValidateSampleCoveragex(context, value, invert));
19800 if (isCallValid)
19801 {
19802 context->sampleCoveragex(value, invert);
19803 }
19804 ANGLE_CAPTURE(SampleCoveragex, isCallValid, context, value, invert);
19805 }
19806 }
19807
SampleMaskiContextANGLE(GLeglContext ctx,GLuint maskNumber,GLbitfield mask)19808 void GL_APIENTRY SampleMaskiContextANGLE(GLeglContext ctx, GLuint maskNumber, GLbitfield mask)
19809 {
19810 Context *context = static_cast<gl::Context *>(ctx);
19811 EVENT("glSampleMaski", "context = %d, GLuint maskNumber = %u, GLbitfield mask = %s",
19812 CID(context), maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
19813
19814 if (context)
19815 {
19816 ASSERT(context == GetValidGlobalContext());
19817 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19818 bool isCallValid =
19819 (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask));
19820 if (isCallValid)
19821 {
19822 context->sampleMaski(maskNumber, mask);
19823 }
19824 ANGLE_CAPTURE(SampleMaski, isCallValid, context, maskNumber, mask);
19825 }
19826 }
19827
SamplerParameterIivContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,const GLint * param)19828 void GL_APIENTRY SamplerParameterIivContextANGLE(GLeglContext ctx,
19829 GLuint sampler,
19830 GLenum pname,
19831 const GLint *param)
19832 {
19833 Context *context = static_cast<gl::Context *>(ctx);
19834 EVENT(
19835 "glSamplerParameterIiv",
19836 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
19837 "",
19838 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
19839 (uintptr_t)param);
19840
19841 if (context)
19842 {
19843 ASSERT(context == GetValidGlobalContext());
19844 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
19845 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19846 bool isCallValid = (context->skipValidation() ||
19847 ValidateSamplerParameterIiv(context, samplerPacked, pname, param));
19848 if (isCallValid)
19849 {
19850 context->samplerParameterIiv(samplerPacked, pname, param);
19851 }
19852 ANGLE_CAPTURE(SamplerParameterIiv, isCallValid, context, samplerPacked, pname, param);
19853 }
19854 }
19855
SamplerParameterIivOESContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,const GLint * param)19856 void GL_APIENTRY SamplerParameterIivOESContextANGLE(GLeglContext ctx,
19857 GLuint sampler,
19858 GLenum pname,
19859 const GLint *param)
19860 {
19861 Context *context = static_cast<gl::Context *>(ctx);
19862 EVENT(
19863 "glSamplerParameterIivOES",
19864 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
19865 "",
19866 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
19867 (uintptr_t)param);
19868
19869 if (context)
19870 {
19871 ASSERT(context == GetValidGlobalContext());
19872 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
19873 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19874 bool isCallValid = (context->skipValidation() ||
19875 ValidateSamplerParameterIivOES(context, samplerPacked, pname, param));
19876 if (isCallValid)
19877 {
19878 context->samplerParameterIiv(samplerPacked, pname, param);
19879 }
19880 ANGLE_CAPTURE(SamplerParameterIivOES, isCallValid, context, samplerPacked, pname, param);
19881 }
19882 }
19883
SamplerParameterIuivContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,const GLuint * param)19884 void GL_APIENTRY SamplerParameterIuivContextANGLE(GLeglContext ctx,
19885 GLuint sampler,
19886 GLenum pname,
19887 const GLuint *param)
19888 {
19889 Context *context = static_cast<gl::Context *>(ctx);
19890 EVENT(
19891 "glSamplerParameterIuiv",
19892 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLuint *param = 0x%016" PRIxPTR
19893 "",
19894 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
19895 (uintptr_t)param);
19896
19897 if (context)
19898 {
19899 ASSERT(context == GetValidGlobalContext());
19900 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
19901 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19902 bool isCallValid = (context->skipValidation() ||
19903 ValidateSamplerParameterIuiv(context, samplerPacked, pname, param));
19904 if (isCallValid)
19905 {
19906 context->samplerParameterIuiv(samplerPacked, pname, param);
19907 }
19908 ANGLE_CAPTURE(SamplerParameterIuiv, isCallValid, context, samplerPacked, pname, param);
19909 }
19910 }
19911
SamplerParameterIuivOESContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,const GLuint * param)19912 void GL_APIENTRY SamplerParameterIuivOESContextANGLE(GLeglContext ctx,
19913 GLuint sampler,
19914 GLenum pname,
19915 const GLuint *param)
19916 {
19917 Context *context = static_cast<gl::Context *>(ctx);
19918 EVENT(
19919 "glSamplerParameterIuivOES",
19920 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLuint *param = 0x%016" PRIxPTR
19921 "",
19922 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
19923 (uintptr_t)param);
19924
19925 if (context)
19926 {
19927 ASSERT(context == GetValidGlobalContext());
19928 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
19929 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19930 bool isCallValid = (context->skipValidation() ||
19931 ValidateSamplerParameterIuivOES(context, samplerPacked, pname, param));
19932 if (isCallValid)
19933 {
19934 context->samplerParameterIuiv(samplerPacked, pname, param);
19935 }
19936 ANGLE_CAPTURE(SamplerParameterIuivOES, isCallValid, context, samplerPacked, pname, param);
19937 }
19938 }
19939
SamplerParameterfContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLfloat param)19940 void GL_APIENTRY SamplerParameterfContextANGLE(GLeglContext ctx,
19941 GLuint sampler,
19942 GLenum pname,
19943 GLfloat param)
19944 {
19945 Context *context = static_cast<gl::Context *>(ctx);
19946 EVENT("glSamplerParameterf",
19947 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLfloat param = %f", CID(context),
19948 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param);
19949
19950 if (context)
19951 {
19952 ASSERT(context == GetValidGlobalContext());
19953 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
19954 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19955 bool isCallValid = (context->skipValidation() ||
19956 ValidateSamplerParameterf(context, samplerPacked, pname, param));
19957 if (isCallValid)
19958 {
19959 context->samplerParameterf(samplerPacked, pname, param);
19960 }
19961 ANGLE_CAPTURE(SamplerParameterf, isCallValid, context, samplerPacked, pname, param);
19962 }
19963 }
19964
SamplerParameterfvContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,const GLfloat * param)19965 void GL_APIENTRY SamplerParameterfvContextANGLE(GLeglContext ctx,
19966 GLuint sampler,
19967 GLenum pname,
19968 const GLfloat *param)
19969 {
19970 Context *context = static_cast<gl::Context *>(ctx);
19971 EVENT("glSamplerParameterfv",
19972 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLfloat *param = "
19973 "0x%016" PRIxPTR "",
19974 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
19975 (uintptr_t)param);
19976
19977 if (context)
19978 {
19979 ASSERT(context == GetValidGlobalContext());
19980 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
19981 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
19982 bool isCallValid = (context->skipValidation() ||
19983 ValidateSamplerParameterfv(context, samplerPacked, pname, param));
19984 if (isCallValid)
19985 {
19986 context->samplerParameterfv(samplerPacked, pname, param);
19987 }
19988 ANGLE_CAPTURE(SamplerParameterfv, isCallValid, context, samplerPacked, pname, param);
19989 }
19990 }
19991
SamplerParameteriContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLint param)19992 void GL_APIENTRY SamplerParameteriContextANGLE(GLeglContext ctx,
19993 GLuint sampler,
19994 GLenum pname,
19995 GLint param)
19996 {
19997 Context *context = static_cast<gl::Context *>(ctx);
19998 EVENT("glSamplerParameteri",
19999 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint param = %d", CID(context),
20000 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param);
20001
20002 if (context)
20003 {
20004 ASSERT(context == GetValidGlobalContext());
20005 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
20006 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20007 bool isCallValid = (context->skipValidation() ||
20008 ValidateSamplerParameteri(context, samplerPacked, pname, param));
20009 if (isCallValid)
20010 {
20011 context->samplerParameteri(samplerPacked, pname, param);
20012 }
20013 ANGLE_CAPTURE(SamplerParameteri, isCallValid, context, samplerPacked, pname, param);
20014 }
20015 }
20016
SamplerParameterivContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,const GLint * param)20017 void GL_APIENTRY SamplerParameterivContextANGLE(GLeglContext ctx,
20018 GLuint sampler,
20019 GLenum pname,
20020 const GLint *param)
20021 {
20022 Context *context = static_cast<gl::Context *>(ctx);
20023 EVENT(
20024 "glSamplerParameteriv",
20025 "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
20026 "",
20027 CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
20028 (uintptr_t)param);
20029
20030 if (context)
20031 {
20032 ASSERT(context == GetValidGlobalContext());
20033 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
20034 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20035 bool isCallValid = (context->skipValidation() ||
20036 ValidateSamplerParameteriv(context, samplerPacked, pname, param));
20037 if (isCallValid)
20038 {
20039 context->samplerParameteriv(samplerPacked, pname, param);
20040 }
20041 ANGLE_CAPTURE(SamplerParameteriv, isCallValid, context, samplerPacked, pname, param);
20042 }
20043 }
20044
ScalefContextANGLE(GLeglContext ctx,GLfloat x,GLfloat y,GLfloat z)20045 void GL_APIENTRY ScalefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
20046 {
20047 Context *context = static_cast<gl::Context *>(ctx);
20048 EVENT("glScalef", "context = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f", CID(context),
20049 x, y, z);
20050
20051 if (context)
20052 {
20053 ASSERT(context == GetValidGlobalContext());
20054 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20055 bool isCallValid = (context->skipValidation() || ValidateScalef(context, x, y, z));
20056 if (isCallValid)
20057 {
20058 context->scalef(x, y, z);
20059 }
20060 ANGLE_CAPTURE(Scalef, isCallValid, context, x, y, z);
20061 }
20062 }
20063
ScalexContextANGLE(GLeglContext ctx,GLfixed x,GLfixed y,GLfixed z)20064 void GL_APIENTRY ScalexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
20065 {
20066 Context *context = static_cast<gl::Context *>(ctx);
20067 EVENT("glScalex", "context = %d, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X",
20068 CID(context), x, y, z);
20069
20070 if (context)
20071 {
20072 ASSERT(context == GetValidGlobalContext());
20073 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20074 bool isCallValid = (context->skipValidation() || ValidateScalex(context, x, y, z));
20075 if (isCallValid)
20076 {
20077 context->scalex(x, y, z);
20078 }
20079 ANGLE_CAPTURE(Scalex, isCallValid, context, x, y, z);
20080 }
20081 }
20082
20083 void GL_APIENTRY
ScissorContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height)20084 ScissorContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
20085 {
20086 Context *context = static_cast<gl::Context *>(ctx);
20087 EVENT("glScissor",
20088 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d",
20089 CID(context), x, y, width, height);
20090
20091 if (context)
20092 {
20093 ASSERT(context == GetValidGlobalContext());
20094 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20095 bool isCallValid =
20096 (context->skipValidation() || ValidateScissor(context, x, y, width, height));
20097 if (isCallValid)
20098 {
20099 context->scissor(x, y, width, height);
20100 }
20101 ANGLE_CAPTURE(Scissor, isCallValid, context, x, y, width, height);
20102 }
20103 }
20104
SemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,GLuint semaphore,GLenum pname,const GLuint64 * params)20105 void GL_APIENTRY SemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
20106 GLuint semaphore,
20107 GLenum pname,
20108 const GLuint64 *params)
20109 {
20110 Context *context = static_cast<gl::Context *>(ctx);
20111 EVENT("glSemaphoreParameterui64vEXT",
20112 "context = %d, GLuint semaphore = %u, GLenum pname = %s, const GLuint64 *params = "
20113 "0x%016" PRIxPTR "",
20114 CID(context), semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname),
20115 (uintptr_t)params);
20116
20117 if (context)
20118 {
20119 ASSERT(context == GetValidGlobalContext());
20120 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
20121 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20122 bool isCallValid =
20123 (context->skipValidation() ||
20124 ValidateSemaphoreParameterui64vEXT(context, semaphorePacked, pname, params));
20125 if (isCallValid)
20126 {
20127 context->semaphoreParameterui64v(semaphorePacked, pname, params);
20128 }
20129 ANGLE_CAPTURE(SemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
20130 params);
20131 }
20132 }
20133
SetFenceNVContextANGLE(GLeglContext ctx,GLuint fence,GLenum condition)20134 void GL_APIENTRY SetFenceNVContextANGLE(GLeglContext ctx, GLuint fence, GLenum condition)
20135 {
20136 Context *context = static_cast<gl::Context *>(ctx);
20137 EVENT("glSetFenceNV", "context = %d, GLuint fence = %u, GLenum condition = %s", CID(context),
20138 fence, GLenumToString(GLenumGroup::DefaultGroup, condition));
20139
20140 if (context)
20141 {
20142 ASSERT(context == GetValidGlobalContext());
20143 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
20144 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20145 bool isCallValid =
20146 (context->skipValidation() || ValidateSetFenceNV(context, fencePacked, condition));
20147 if (isCallValid)
20148 {
20149 context->setFenceNV(fencePacked, condition);
20150 }
20151 ANGLE_CAPTURE(SetFenceNV, isCallValid, context, fencePacked, condition);
20152 }
20153 }
20154
ShadeModelContextANGLE(GLeglContext ctx,GLenum mode)20155 void GL_APIENTRY ShadeModelContextANGLE(GLeglContext ctx, GLenum mode)
20156 {
20157 Context *context = static_cast<gl::Context *>(ctx);
20158 EVENT("glShadeModel", "context = %d, GLenum mode = %s", CID(context),
20159 GLenumToString(GLenumGroup::ShadingModel, mode));
20160
20161 if (context)
20162 {
20163 ASSERT(context == GetValidGlobalContext());
20164 ShadingModel modePacked = FromGL<ShadingModel>(mode);
20165 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20166 bool isCallValid = (context->skipValidation() || ValidateShadeModel(context, modePacked));
20167 if (isCallValid)
20168 {
20169 context->shadeModel(modePacked);
20170 }
20171 ANGLE_CAPTURE(ShadeModel, isCallValid, context, modePacked);
20172 }
20173 }
20174
ShaderBinaryContextANGLE(GLeglContext ctx,GLsizei count,const GLuint * shaders,GLenum binaryformat,const void * binary,GLsizei length)20175 void GL_APIENTRY ShaderBinaryContextANGLE(GLeglContext ctx,
20176 GLsizei count,
20177 const GLuint *shaders,
20178 GLenum binaryformat,
20179 const void *binary,
20180 GLsizei length)
20181 {
20182 Context *context = static_cast<gl::Context *>(ctx);
20183 EVENT("glShaderBinary",
20184 "context = %d, GLsizei count = %d, const GLuint *shaders = 0x%016" PRIxPTR
20185 ", GLenum binaryformat = %s, const void *binary = 0x%016" PRIxPTR ", GLsizei length = %d",
20186 CID(context), count, (uintptr_t)shaders,
20187 GLenumToString(GLenumGroup::DefaultGroup, binaryformat), (uintptr_t)binary, length);
20188
20189 if (context)
20190 {
20191 ASSERT(context == GetValidGlobalContext());
20192 const ShaderProgramID *shadersPacked = FromGL<const ShaderProgramID *>(shaders);
20193 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20194 bool isCallValid =
20195 (context->skipValidation() ||
20196 ValidateShaderBinary(context, count, shadersPacked, binaryformat, binary, length));
20197 if (isCallValid)
20198 {
20199 context->shaderBinary(count, shadersPacked, binaryformat, binary, length);
20200 }
20201 ANGLE_CAPTURE(ShaderBinary, isCallValid, context, count, shadersPacked, binaryformat,
20202 binary, length);
20203 }
20204 }
20205
ShaderSourceContextANGLE(GLeglContext ctx,GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length)20206 void GL_APIENTRY ShaderSourceContextANGLE(GLeglContext ctx,
20207 GLuint shader,
20208 GLsizei count,
20209 const GLchar *const *string,
20210 const GLint *length)
20211 {
20212 Context *context = static_cast<gl::Context *>(ctx);
20213 EVENT("glShaderSource",
20214 "context = %d, GLuint shader = %u, GLsizei count = %d, const GLchar *const*string = "
20215 "0x%016" PRIxPTR ", const GLint *length = 0x%016" PRIxPTR "",
20216 CID(context), shader, count, (uintptr_t)string, (uintptr_t)length);
20217
20218 if (context)
20219 {
20220 ASSERT(context == GetValidGlobalContext());
20221 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
20222 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20223 bool isCallValid = (context->skipValidation() ||
20224 ValidateShaderSource(context, shaderPacked, count, string, length));
20225 if (isCallValid)
20226 {
20227 context->shaderSource(shaderPacked, count, string, length);
20228 }
20229 ANGLE_CAPTURE(ShaderSource, isCallValid, context, shaderPacked, count, string, length);
20230 }
20231 }
20232
SignalSemaphoreEXTContextANGLE(GLeglContext ctx,GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * dstLayouts)20233 void GL_APIENTRY SignalSemaphoreEXTContextANGLE(GLeglContext ctx,
20234 GLuint semaphore,
20235 GLuint numBufferBarriers,
20236 const GLuint *buffers,
20237 GLuint numTextureBarriers,
20238 const GLuint *textures,
20239 const GLenum *dstLayouts)
20240 {
20241 Context *context = static_cast<gl::Context *>(ctx);
20242 EVENT("glSignalSemaphoreEXT",
20243 "context = %d, GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint "
20244 "*buffers = 0x%016" PRIxPTR
20245 ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
20246 ", const GLenum *dstLayouts = 0x%016" PRIxPTR "",
20247 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
20248 (uintptr_t)textures, (uintptr_t)dstLayouts);
20249
20250 if (context)
20251 {
20252 ASSERT(context == GetValidGlobalContext());
20253 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
20254 const BufferID *buffersPacked = FromGL<const BufferID *>(buffers);
20255 const TextureID *texturesPacked = FromGL<const TextureID *>(textures);
20256 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20257 bool isCallValid =
20258 (context->skipValidation() ||
20259 ValidateSignalSemaphoreEXT(context, semaphorePacked, numBufferBarriers, buffersPacked,
20260 numTextureBarriers, texturesPacked, dstLayouts));
20261 if (isCallValid)
20262 {
20263 context->signalSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
20264 numTextureBarriers, texturesPacked, dstLayouts);
20265 }
20266 ANGLE_CAPTURE(SignalSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
20267 buffersPacked, numTextureBarriers, texturesPacked, dstLayouts);
20268 }
20269 }
20270
StencilFuncContextANGLE(GLeglContext ctx,GLenum func,GLint ref,GLuint mask)20271 void GL_APIENTRY StencilFuncContextANGLE(GLeglContext ctx, GLenum func, GLint ref, GLuint mask)
20272 {
20273 Context *context = static_cast<gl::Context *>(ctx);
20274 EVENT("glStencilFunc", "context = %d, GLenum func = %s, GLint ref = %d, GLuint mask = %u",
20275 CID(context), GLenumToString(GLenumGroup::StencilFunction, func), ref, mask);
20276
20277 if (context)
20278 {
20279 ASSERT(context == GetValidGlobalContext());
20280 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20281 bool isCallValid =
20282 (context->skipValidation() || ValidateStencilFunc(context, func, ref, mask));
20283 if (isCallValid)
20284 {
20285 context->stencilFunc(func, ref, mask);
20286 }
20287 ANGLE_CAPTURE(StencilFunc, isCallValid, context, func, ref, mask);
20288 }
20289 }
20290
20291 void GL_APIENTRY
StencilFuncSeparateContextANGLE(GLeglContext ctx,GLenum face,GLenum func,GLint ref,GLuint mask)20292 StencilFuncSeparateContextANGLE(GLeglContext ctx, GLenum face, GLenum func, GLint ref, GLuint mask)
20293 {
20294 Context *context = static_cast<gl::Context *>(ctx);
20295 EVENT("glStencilFuncSeparate",
20296 "context = %d, GLenum face = %s, GLenum func = %s, GLint ref = %d, GLuint mask = %u",
20297 CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face),
20298 GLenumToString(GLenumGroup::StencilFunction, func), ref, mask);
20299
20300 if (context)
20301 {
20302 ASSERT(context == GetValidGlobalContext());
20303 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20304 bool isCallValid = (context->skipValidation() ||
20305 ValidateStencilFuncSeparate(context, face, func, ref, mask));
20306 if (isCallValid)
20307 {
20308 context->stencilFuncSeparate(face, func, ref, mask);
20309 }
20310 ANGLE_CAPTURE(StencilFuncSeparate, isCallValid, context, face, func, ref, mask);
20311 }
20312 }
20313
StencilMaskContextANGLE(GLeglContext ctx,GLuint mask)20314 void GL_APIENTRY StencilMaskContextANGLE(GLeglContext ctx, GLuint mask)
20315 {
20316 Context *context = static_cast<gl::Context *>(ctx);
20317 EVENT("glStencilMask", "context = %d, GLuint mask = %u", CID(context), mask);
20318
20319 if (context)
20320 {
20321 ASSERT(context == GetValidGlobalContext());
20322 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20323 bool isCallValid = (context->skipValidation() || ValidateStencilMask(context, mask));
20324 if (isCallValid)
20325 {
20326 context->stencilMask(mask);
20327 }
20328 ANGLE_CAPTURE(StencilMask, isCallValid, context, mask);
20329 }
20330 }
20331
StencilMaskSeparateContextANGLE(GLeglContext ctx,GLenum face,GLuint mask)20332 void GL_APIENTRY StencilMaskSeparateContextANGLE(GLeglContext ctx, GLenum face, GLuint mask)
20333 {
20334 Context *context = static_cast<gl::Context *>(ctx);
20335 EVENT("glStencilMaskSeparate", "context = %d, GLenum face = %s, GLuint mask = %u", CID(context),
20336 GLenumToString(GLenumGroup::StencilFaceDirection, face), mask);
20337
20338 if (context)
20339 {
20340 ASSERT(context == GetValidGlobalContext());
20341 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20342 bool isCallValid =
20343 (context->skipValidation() || ValidateStencilMaskSeparate(context, face, mask));
20344 if (isCallValid)
20345 {
20346 context->stencilMaskSeparate(face, mask);
20347 }
20348 ANGLE_CAPTURE(StencilMaskSeparate, isCallValid, context, face, mask);
20349 }
20350 }
20351
StencilOpContextANGLE(GLeglContext ctx,GLenum fail,GLenum zfail,GLenum zpass)20352 void GL_APIENTRY StencilOpContextANGLE(GLeglContext ctx, GLenum fail, GLenum zfail, GLenum zpass)
20353 {
20354 Context *context = static_cast<gl::Context *>(ctx);
20355 EVENT("glStencilOp", "context = %d, GLenum fail = %s, GLenum zfail = %s, GLenum zpass = %s",
20356 CID(context), GLenumToString(GLenumGroup::StencilOp, fail),
20357 GLenumToString(GLenumGroup::StencilOp, zfail),
20358 GLenumToString(GLenumGroup::StencilOp, zpass));
20359
20360 if (context)
20361 {
20362 ASSERT(context == GetValidGlobalContext());
20363 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20364 bool isCallValid =
20365 (context->skipValidation() || ValidateStencilOp(context, fail, zfail, zpass));
20366 if (isCallValid)
20367 {
20368 context->stencilOp(fail, zfail, zpass);
20369 }
20370 ANGLE_CAPTURE(StencilOp, isCallValid, context, fail, zfail, zpass);
20371 }
20372 }
20373
StencilOpSeparateContextANGLE(GLeglContext ctx,GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass)20374 void GL_APIENTRY StencilOpSeparateContextANGLE(GLeglContext ctx,
20375 GLenum face,
20376 GLenum sfail,
20377 GLenum dpfail,
20378 GLenum dppass)
20379 {
20380 Context *context = static_cast<gl::Context *>(ctx);
20381 EVENT(
20382 "glStencilOpSeparate",
20383 "context = %d, GLenum face = %s, GLenum sfail = %s, GLenum dpfail = %s, GLenum dppass = %s",
20384 CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face),
20385 GLenumToString(GLenumGroup::StencilOp, sfail),
20386 GLenumToString(GLenumGroup::StencilOp, dpfail),
20387 GLenumToString(GLenumGroup::StencilOp, dppass));
20388
20389 if (context)
20390 {
20391 ASSERT(context == GetValidGlobalContext());
20392 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20393 bool isCallValid = (context->skipValidation() ||
20394 ValidateStencilOpSeparate(context, face, sfail, dpfail, dppass));
20395 if (isCallValid)
20396 {
20397 context->stencilOpSeparate(face, sfail, dpfail, dppass);
20398 }
20399 ANGLE_CAPTURE(StencilOpSeparate, isCallValid, context, face, sfail, dpfail, dppass);
20400 }
20401 }
20402
TestFenceNVContextANGLE(GLeglContext ctx,GLuint fence)20403 GLboolean GL_APIENTRY TestFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
20404 {
20405 Context *context = static_cast<gl::Context *>(ctx);
20406 EVENT("glTestFenceNV", "context = %d, GLuint fence = %u", CID(context), fence);
20407
20408 GLboolean returnValue;
20409 if (context)
20410 {
20411 ASSERT(context == GetValidGlobalContext());
20412 FenceNVID fencePacked = FromGL<FenceNVID>(fence);
20413 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20414 bool isCallValid = (context->skipValidation() || ValidateTestFenceNV(context, fencePacked));
20415 if (isCallValid)
20416 {
20417 returnValue = context->testFenceNV(fencePacked);
20418 }
20419 else
20420 {
20421 returnValue = GetDefaultReturnValue<EntryPoint::TestFenceNV, GLboolean>();
20422 }
20423 ANGLE_CAPTURE(TestFenceNV, isCallValid, context, fencePacked, returnValue);
20424 }
20425 else
20426 {
20427 returnValue = GetDefaultReturnValue<EntryPoint::TestFenceNV, GLboolean>();
20428 }
20429 return returnValue;
20430 }
20431
TexBufferContextANGLE(GLeglContext ctx,GLenum target,GLenum internalformat,GLuint buffer)20432 void GL_APIENTRY TexBufferContextANGLE(GLeglContext ctx,
20433 GLenum target,
20434 GLenum internalformat,
20435 GLuint buffer)
20436 {
20437 Context *context = static_cast<gl::Context *>(ctx);
20438 EVENT("glTexBuffer",
20439 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLuint buffer = %u",
20440 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
20441 GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer);
20442
20443 if (context)
20444 {
20445 ASSERT(context == GetValidGlobalContext());
20446 BufferID bufferPacked = FromGL<BufferID>(buffer);
20447 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20448 bool isCallValid = (context->skipValidation() ||
20449 ValidateTexBuffer(context, target, internalformat, bufferPacked));
20450 if (isCallValid)
20451 {
20452 context->texBuffer(target, internalformat, bufferPacked);
20453 }
20454 ANGLE_CAPTURE(TexBuffer, isCallValid, context, target, internalformat, bufferPacked);
20455 }
20456 }
20457
TexBufferRangeContextANGLE(GLeglContext ctx,GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)20458 void GL_APIENTRY TexBufferRangeContextANGLE(GLeglContext ctx,
20459 GLenum target,
20460 GLenum internalformat,
20461 GLuint buffer,
20462 GLintptr offset,
20463 GLsizeiptr size)
20464 {
20465 Context *context = static_cast<gl::Context *>(ctx);
20466 EVENT("glTexBufferRange",
20467 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLuint buffer = %u, "
20468 "GLintptr offset = %llu, GLsizeiptr size = %llu",
20469 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
20470 GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer,
20471 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
20472
20473 if (context)
20474 {
20475 ASSERT(context == GetValidGlobalContext());
20476 BufferID bufferPacked = FromGL<BufferID>(buffer);
20477 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20478 bool isCallValid =
20479 (context->skipValidation() ||
20480 ValidateTexBufferRange(context, target, internalformat, bufferPacked, offset, size));
20481 if (isCallValid)
20482 {
20483 context->texBufferRange(target, internalformat, bufferPacked, offset, size);
20484 }
20485 ANGLE_CAPTURE(TexBufferRange, isCallValid, context, target, internalformat, bufferPacked,
20486 offset, size);
20487 }
20488 }
20489
TexCoordPointerContextANGLE(GLeglContext ctx,GLint size,GLenum type,GLsizei stride,const void * pointer)20490 void GL_APIENTRY TexCoordPointerContextANGLE(GLeglContext ctx,
20491 GLint size,
20492 GLenum type,
20493 GLsizei stride,
20494 const void *pointer)
20495 {
20496 Context *context = static_cast<gl::Context *>(ctx);
20497 EVENT("glTexCoordPointer",
20498 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
20499 "*pointer = 0x%016" PRIxPTR "",
20500 CID(context), size, GLenumToString(GLenumGroup::TexCoordPointerType, type), stride,
20501 (uintptr_t)pointer);
20502
20503 if (context)
20504 {
20505 ASSERT(context == GetValidGlobalContext());
20506 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
20507 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20508 bool isCallValid = (context->skipValidation() ||
20509 ValidateTexCoordPointer(context, size, typePacked, stride, pointer));
20510 if (isCallValid)
20511 {
20512 context->texCoordPointer(size, typePacked, stride, pointer);
20513 }
20514 ANGLE_CAPTURE(TexCoordPointer, isCallValid, context, size, typePacked, stride, pointer);
20515 }
20516 }
20517
TexEnvfContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfloat param)20518 void GL_APIENTRY TexEnvfContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfloat param)
20519 {
20520 Context *context = static_cast<gl::Context *>(ctx);
20521 EVENT("glTexEnvf", "context = %d, GLenum target = %s, GLenum pname = %s, GLfloat param = %f",
20522 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
20523 GLenumToString(GLenumGroup::TextureEnvParameter, pname), param);
20524
20525 if (context)
20526 {
20527 ASSERT(context == GetValidGlobalContext());
20528 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
20529 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
20530 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20531 bool isCallValid = (context->skipValidation() ||
20532 ValidateTexEnvf(context, targetPacked, pnamePacked, param));
20533 if (isCallValid)
20534 {
20535 context->texEnvf(targetPacked, pnamePacked, param);
20536 }
20537 ANGLE_CAPTURE(TexEnvf, isCallValid, context, targetPacked, pnamePacked, param);
20538 }
20539 }
20540
TexEnvfvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLfloat * params)20541 void GL_APIENTRY TexEnvfvContextANGLE(GLeglContext ctx,
20542 GLenum target,
20543 GLenum pname,
20544 const GLfloat *params)
20545 {
20546 Context *context = static_cast<gl::Context *>(ctx);
20547 EVENT("glTexEnvfv",
20548 "context = %d, GLenum target = %s, GLenum pname = %s, const GLfloat *params = "
20549 "0x%016" PRIxPTR "",
20550 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
20551 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
20552
20553 if (context)
20554 {
20555 ASSERT(context == GetValidGlobalContext());
20556 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
20557 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
20558 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20559 bool isCallValid = (context->skipValidation() ||
20560 ValidateTexEnvfv(context, targetPacked, pnamePacked, params));
20561 if (isCallValid)
20562 {
20563 context->texEnvfv(targetPacked, pnamePacked, params);
20564 }
20565 ANGLE_CAPTURE(TexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
20566 }
20567 }
20568
TexEnviContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint param)20569 void GL_APIENTRY TexEnviContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLint param)
20570 {
20571 Context *context = static_cast<gl::Context *>(ctx);
20572 EVENT("glTexEnvi", "context = %d, GLenum target = %s, GLenum pname = %s, GLint param = %d",
20573 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
20574 GLenumToString(GLenumGroup::TextureEnvParameter, pname), param);
20575
20576 if (context)
20577 {
20578 ASSERT(context == GetValidGlobalContext());
20579 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
20580 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
20581 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20582 bool isCallValid = (context->skipValidation() ||
20583 ValidateTexEnvi(context, targetPacked, pnamePacked, param));
20584 if (isCallValid)
20585 {
20586 context->texEnvi(targetPacked, pnamePacked, param);
20587 }
20588 ANGLE_CAPTURE(TexEnvi, isCallValid, context, targetPacked, pnamePacked, param);
20589 }
20590 }
20591
TexEnvivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLint * params)20592 void GL_APIENTRY TexEnvivContextANGLE(GLeglContext ctx,
20593 GLenum target,
20594 GLenum pname,
20595 const GLint *params)
20596 {
20597 Context *context = static_cast<gl::Context *>(ctx);
20598 EVENT(
20599 "glTexEnviv",
20600 "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
20601 "",
20602 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
20603 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
20604
20605 if (context)
20606 {
20607 ASSERT(context == GetValidGlobalContext());
20608 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
20609 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
20610 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20611 bool isCallValid = (context->skipValidation() ||
20612 ValidateTexEnviv(context, targetPacked, pnamePacked, params));
20613 if (isCallValid)
20614 {
20615 context->texEnviv(targetPacked, pnamePacked, params);
20616 }
20617 ANGLE_CAPTURE(TexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
20618 }
20619 }
20620
TexEnvxContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfixed param)20621 void GL_APIENTRY TexEnvxContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfixed param)
20622 {
20623 Context *context = static_cast<gl::Context *>(ctx);
20624 EVENT("glTexEnvx", "context = %d, GLenum target = %s, GLenum pname = %s, GLfixed param = 0x%X",
20625 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
20626 GLenumToString(GLenumGroup::TextureEnvParameter, pname), param);
20627
20628 if (context)
20629 {
20630 ASSERT(context == GetValidGlobalContext());
20631 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
20632 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
20633 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20634 bool isCallValid = (context->skipValidation() ||
20635 ValidateTexEnvx(context, targetPacked, pnamePacked, param));
20636 if (isCallValid)
20637 {
20638 context->texEnvx(targetPacked, pnamePacked, param);
20639 }
20640 ANGLE_CAPTURE(TexEnvx, isCallValid, context, targetPacked, pnamePacked, param);
20641 }
20642 }
20643
TexEnvxvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLfixed * params)20644 void GL_APIENTRY TexEnvxvContextANGLE(GLeglContext ctx,
20645 GLenum target,
20646 GLenum pname,
20647 const GLfixed *params)
20648 {
20649 Context *context = static_cast<gl::Context *>(ctx);
20650 EVENT("glTexEnvxv",
20651 "context = %d, GLenum target = %s, GLenum pname = %s, const GLfixed *params = "
20652 "0x%016" PRIxPTR "",
20653 CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
20654 GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
20655
20656 if (context)
20657 {
20658 ASSERT(context == GetValidGlobalContext());
20659 TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
20660 TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
20661 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20662 bool isCallValid = (context->skipValidation() ||
20663 ValidateTexEnvxv(context, targetPacked, pnamePacked, params));
20664 if (isCallValid)
20665 {
20666 context->texEnvxv(targetPacked, pnamePacked, params);
20667 }
20668 ANGLE_CAPTURE(TexEnvxv, isCallValid, context, targetPacked, pnamePacked, params);
20669 }
20670 }
20671
TexGenfOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,GLfloat param)20672 void GL_APIENTRY TexGenfOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLfloat param)
20673 {
20674 Context *context = static_cast<gl::Context *>(ctx);
20675 EVENT("glTexGenfOES", "context = %d, GLenum coord = %s, GLenum pname = %s, GLfloat param = %f",
20676 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
20677 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
20678
20679 if (context)
20680 {
20681 ASSERT(context == GetValidGlobalContext());
20682 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20683 bool isCallValid =
20684 (context->skipValidation() || ValidateTexGenfOES(context, coord, pname, param));
20685 if (isCallValid)
20686 {
20687 context->texGenf(coord, pname, param);
20688 }
20689 ANGLE_CAPTURE(TexGenfOES, isCallValid, context, coord, pname, param);
20690 }
20691 }
20692
TexGenfvOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,const GLfloat * params)20693 void GL_APIENTRY TexGenfvOESContextANGLE(GLeglContext ctx,
20694 GLenum coord,
20695 GLenum pname,
20696 const GLfloat *params)
20697 {
20698 Context *context = static_cast<gl::Context *>(ctx);
20699 EVENT(
20700 "glTexGenfvOES",
20701 "context = %d, GLenum coord = %s, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR
20702 "",
20703 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
20704 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
20705
20706 if (context)
20707 {
20708 ASSERT(context == GetValidGlobalContext());
20709 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20710 bool isCallValid =
20711 (context->skipValidation() || ValidateTexGenfvOES(context, coord, pname, params));
20712 if (isCallValid)
20713 {
20714 context->texGenfv(coord, pname, params);
20715 }
20716 ANGLE_CAPTURE(TexGenfvOES, isCallValid, context, coord, pname, params);
20717 }
20718 }
20719
TexGeniOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,GLint param)20720 void GL_APIENTRY TexGeniOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLint param)
20721 {
20722 Context *context = static_cast<gl::Context *>(ctx);
20723 EVENT("glTexGeniOES", "context = %d, GLenum coord = %s, GLenum pname = %s, GLint param = %d",
20724 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
20725 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
20726
20727 if (context)
20728 {
20729 ASSERT(context == GetValidGlobalContext());
20730 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20731 bool isCallValid =
20732 (context->skipValidation() || ValidateTexGeniOES(context, coord, pname, param));
20733 if (isCallValid)
20734 {
20735 context->texGeni(coord, pname, param);
20736 }
20737 ANGLE_CAPTURE(TexGeniOES, isCallValid, context, coord, pname, param);
20738 }
20739 }
20740
TexGenivOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,const GLint * params)20741 void GL_APIENTRY TexGenivOESContextANGLE(GLeglContext ctx,
20742 GLenum coord,
20743 GLenum pname,
20744 const GLint *params)
20745 {
20746 Context *context = static_cast<gl::Context *>(ctx);
20747 EVENT("glTexGenivOES",
20748 "context = %d, GLenum coord = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
20749 "",
20750 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
20751 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
20752
20753 if (context)
20754 {
20755 ASSERT(context == GetValidGlobalContext());
20756 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20757 bool isCallValid =
20758 (context->skipValidation() || ValidateTexGenivOES(context, coord, pname, params));
20759 if (isCallValid)
20760 {
20761 context->texGeniv(coord, pname, params);
20762 }
20763 ANGLE_CAPTURE(TexGenivOES, isCallValid, context, coord, pname, params);
20764 }
20765 }
20766
TexGenxOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,GLfixed param)20767 void GL_APIENTRY TexGenxOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLfixed param)
20768 {
20769 Context *context = static_cast<gl::Context *>(ctx);
20770 EVENT("glTexGenxOES",
20771 "context = %d, GLenum coord = %s, GLenum pname = %s, GLfixed param = 0x%X", CID(context),
20772 GLenumToString(GLenumGroup::TextureCoordName, coord),
20773 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
20774
20775 if (context)
20776 {
20777 ASSERT(context == GetValidGlobalContext());
20778 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20779 bool isCallValid =
20780 (context->skipValidation() || ValidateTexGenxOES(context, coord, pname, param));
20781 if (isCallValid)
20782 {
20783 context->texGenx(coord, pname, param);
20784 }
20785 ANGLE_CAPTURE(TexGenxOES, isCallValid, context, coord, pname, param);
20786 }
20787 }
20788
TexGenxvOESContextANGLE(GLeglContext ctx,GLenum coord,GLenum pname,const GLfixed * params)20789 void GL_APIENTRY TexGenxvOESContextANGLE(GLeglContext ctx,
20790 GLenum coord,
20791 GLenum pname,
20792 const GLfixed *params)
20793 {
20794 Context *context = static_cast<gl::Context *>(ctx);
20795 EVENT(
20796 "glTexGenxvOES",
20797 "context = %d, GLenum coord = %s, GLenum pname = %s, const GLfixed *params = 0x%016" PRIxPTR
20798 "",
20799 CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
20800 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
20801
20802 if (context)
20803 {
20804 ASSERT(context == GetValidGlobalContext());
20805 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20806 bool isCallValid =
20807 (context->skipValidation() || ValidateTexGenxvOES(context, coord, pname, params));
20808 if (isCallValid)
20809 {
20810 context->texGenxv(coord, pname, params);
20811 }
20812 ANGLE_CAPTURE(TexGenxvOES, isCallValid, context, coord, pname, params);
20813 }
20814 }
20815
TexImage2DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void * pixels)20816 void GL_APIENTRY TexImage2DContextANGLE(GLeglContext ctx,
20817 GLenum target,
20818 GLint level,
20819 GLint internalformat,
20820 GLsizei width,
20821 GLsizei height,
20822 GLint border,
20823 GLenum format,
20824 GLenum type,
20825 const void *pixels)
20826 {
20827 Context *context = static_cast<gl::Context *>(ctx);
20828 EVENT("glTexImage2D",
20829 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
20830 "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = "
20831 "%s, const void *pixels = 0x%016" PRIxPTR "",
20832 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
20833 width, height, border, GLenumToString(GLenumGroup::PixelFormat, format),
20834 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
20835
20836 if (context)
20837 {
20838 ASSERT(context == GetValidGlobalContext());
20839 TextureTarget targetPacked = FromGL<TextureTarget>(target);
20840 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20841 bool isCallValid = (context->skipValidation() ||
20842 ValidateTexImage2D(context, targetPacked, level, internalformat, width,
20843 height, border, format, type, pixels));
20844 if (isCallValid)
20845 {
20846 context->texImage2D(targetPacked, level, internalformat, width, height, border, format,
20847 type, pixels);
20848 }
20849 ANGLE_CAPTURE(TexImage2D, isCallValid, context, targetPacked, level, internalformat, width,
20850 height, border, format, type, pixels);
20851 }
20852 }
20853
TexImage3DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)20854 void GL_APIENTRY TexImage3DContextANGLE(GLeglContext ctx,
20855 GLenum target,
20856 GLint level,
20857 GLint internalformat,
20858 GLsizei width,
20859 GLsizei height,
20860 GLsizei depth,
20861 GLint border,
20862 GLenum format,
20863 GLenum type,
20864 const void *pixels)
20865 {
20866 Context *context = static_cast<gl::Context *>(ctx);
20867 EVENT("glTexImage3D",
20868 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
20869 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = "
20870 "%s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
20871 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
20872 width, height, depth, border, GLenumToString(GLenumGroup::PixelFormat, format),
20873 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
20874
20875 if (context)
20876 {
20877 ASSERT(context == GetValidGlobalContext());
20878 TextureTarget targetPacked = FromGL<TextureTarget>(target);
20879 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20880 bool isCallValid = (context->skipValidation() ||
20881 ValidateTexImage3D(context, targetPacked, level, internalformat, width,
20882 height, depth, border, format, type, pixels));
20883 if (isCallValid)
20884 {
20885 context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
20886 format, type, pixels);
20887 }
20888 ANGLE_CAPTURE(TexImage3D, isCallValid, context, targetPacked, level, internalformat, width,
20889 height, depth, border, format, type, pixels);
20890 }
20891 }
20892
TexImage3DOESContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)20893 void GL_APIENTRY TexImage3DOESContextANGLE(GLeglContext ctx,
20894 GLenum target,
20895 GLint level,
20896 GLenum internalformat,
20897 GLsizei width,
20898 GLsizei height,
20899 GLsizei depth,
20900 GLint border,
20901 GLenum format,
20902 GLenum type,
20903 const void *pixels)
20904 {
20905 Context *context = static_cast<gl::Context *>(ctx);
20906 EVENT("glTexImage3DOES",
20907 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
20908 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = "
20909 "%s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
20910 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
20911 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
20912 GLenumToString(GLenumGroup::PixelFormat, format),
20913 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
20914
20915 if (context)
20916 {
20917 ASSERT(context == GetValidGlobalContext());
20918 TextureTarget targetPacked = FromGL<TextureTarget>(target);
20919 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20920 bool isCallValid =
20921 (context->skipValidation() ||
20922 ValidateTexImage3DOES(context, targetPacked, level, internalformat, width, height,
20923 depth, border, format, type, pixels));
20924 if (isCallValid)
20925 {
20926 context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
20927 format, type, pixels);
20928 }
20929 ANGLE_CAPTURE(TexImage3DOES, isCallValid, context, targetPacked, level, internalformat,
20930 width, height, depth, border, format, type, pixels);
20931 }
20932 }
20933
TexParameterIivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLint * params)20934 void GL_APIENTRY TexParameterIivContextANGLE(GLeglContext ctx,
20935 GLenum target,
20936 GLenum pname,
20937 const GLint *params)
20938 {
20939 Context *context = static_cast<gl::Context *>(ctx);
20940 EVENT(
20941 "glTexParameterIiv",
20942 "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
20943 "",
20944 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
20945 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
20946
20947 if (context)
20948 {
20949 ASSERT(context == GetValidGlobalContext());
20950 TextureType targetPacked = FromGL<TextureType>(target);
20951 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20952 bool isCallValid = (context->skipValidation() ||
20953 ValidateTexParameterIiv(context, targetPacked, pname, params));
20954 if (isCallValid)
20955 {
20956 context->texParameterIiv(targetPacked, pname, params);
20957 }
20958 ANGLE_CAPTURE(TexParameterIiv, isCallValid, context, targetPacked, pname, params);
20959 }
20960 }
20961
TexParameterIivOESContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLint * params)20962 void GL_APIENTRY TexParameterIivOESContextANGLE(GLeglContext ctx,
20963 GLenum target,
20964 GLenum pname,
20965 const GLint *params)
20966 {
20967 Context *context = static_cast<gl::Context *>(ctx);
20968 EVENT(
20969 "glTexParameterIivOES",
20970 "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
20971 "",
20972 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
20973 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
20974
20975 if (context)
20976 {
20977 ASSERT(context == GetValidGlobalContext());
20978 TextureType targetPacked = FromGL<TextureType>(target);
20979 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
20980 bool isCallValid = (context->skipValidation() ||
20981 ValidateTexParameterIivOES(context, targetPacked, pname, params));
20982 if (isCallValid)
20983 {
20984 context->texParameterIiv(targetPacked, pname, params);
20985 }
20986 ANGLE_CAPTURE(TexParameterIivOES, isCallValid, context, targetPacked, pname, params);
20987 }
20988 }
20989
TexParameterIuivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLuint * params)20990 void GL_APIENTRY TexParameterIuivContextANGLE(GLeglContext ctx,
20991 GLenum target,
20992 GLenum pname,
20993 const GLuint *params)
20994 {
20995 Context *context = static_cast<gl::Context *>(ctx);
20996 EVENT(
20997 "glTexParameterIuiv",
20998 "context = %d, GLenum target = %s, GLenum pname = %s, const GLuint *params = 0x%016" PRIxPTR
20999 "",
21000 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
21001 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
21002
21003 if (context)
21004 {
21005 ASSERT(context == GetValidGlobalContext());
21006 TextureType targetPacked = FromGL<TextureType>(target);
21007 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21008 bool isCallValid = (context->skipValidation() ||
21009 ValidateTexParameterIuiv(context, targetPacked, pname, params));
21010 if (isCallValid)
21011 {
21012 context->texParameterIuiv(targetPacked, pname, params);
21013 }
21014 ANGLE_CAPTURE(TexParameterIuiv, isCallValid, context, targetPacked, pname, params);
21015 }
21016 }
21017
TexParameterIuivOESContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLuint * params)21018 void GL_APIENTRY TexParameterIuivOESContextANGLE(GLeglContext ctx,
21019 GLenum target,
21020 GLenum pname,
21021 const GLuint *params)
21022 {
21023 Context *context = static_cast<gl::Context *>(ctx);
21024 EVENT(
21025 "glTexParameterIuivOES",
21026 "context = %d, GLenum target = %s, GLenum pname = %s, const GLuint *params = 0x%016" PRIxPTR
21027 "",
21028 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
21029 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
21030
21031 if (context)
21032 {
21033 ASSERT(context == GetValidGlobalContext());
21034 TextureType targetPacked = FromGL<TextureType>(target);
21035 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21036 bool isCallValid = (context->skipValidation() ||
21037 ValidateTexParameterIuivOES(context, targetPacked, pname, params));
21038 if (isCallValid)
21039 {
21040 context->texParameterIuiv(targetPacked, pname, params);
21041 }
21042 ANGLE_CAPTURE(TexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
21043 }
21044 }
21045
TexParameterfContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfloat param)21046 void GL_APIENTRY TexParameterfContextANGLE(GLeglContext ctx,
21047 GLenum target,
21048 GLenum pname,
21049 GLfloat param)
21050 {
21051 Context *context = static_cast<gl::Context *>(ctx);
21052 EVENT("glTexParameterf",
21053 "context = %d, GLenum target = %s, GLenum pname = %s, GLfloat param = %f", CID(context),
21054 GLenumToString(GLenumGroup::TextureTarget, target),
21055 GLenumToString(GLenumGroup::TextureParameterName, pname), param);
21056
21057 if (context)
21058 {
21059 ASSERT(context == GetValidGlobalContext());
21060 TextureType targetPacked = FromGL<TextureType>(target);
21061 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21062 bool isCallValid = (context->skipValidation() ||
21063 ValidateTexParameterf(context, targetPacked, pname, param));
21064 if (isCallValid)
21065 {
21066 context->texParameterf(targetPacked, pname, param);
21067 }
21068 ANGLE_CAPTURE(TexParameterf, isCallValid, context, targetPacked, pname, param);
21069 }
21070 }
21071
TexParameterfvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLfloat * params)21072 void GL_APIENTRY TexParameterfvContextANGLE(GLeglContext ctx,
21073 GLenum target,
21074 GLenum pname,
21075 const GLfloat *params)
21076 {
21077 Context *context = static_cast<gl::Context *>(ctx);
21078 EVENT("glTexParameterfv",
21079 "context = %d, GLenum target = %s, GLenum pname = %s, const GLfloat *params = "
21080 "0x%016" PRIxPTR "",
21081 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
21082 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
21083
21084 if (context)
21085 {
21086 ASSERT(context == GetValidGlobalContext());
21087 TextureType targetPacked = FromGL<TextureType>(target);
21088 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21089 bool isCallValid = (context->skipValidation() ||
21090 ValidateTexParameterfv(context, targetPacked, pname, params));
21091 if (isCallValid)
21092 {
21093 context->texParameterfv(targetPacked, pname, params);
21094 }
21095 ANGLE_CAPTURE(TexParameterfv, isCallValid, context, targetPacked, pname, params);
21096 }
21097 }
21098
TexParameteriContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLint param)21099 void GL_APIENTRY TexParameteriContextANGLE(GLeglContext ctx,
21100 GLenum target,
21101 GLenum pname,
21102 GLint param)
21103 {
21104 Context *context = static_cast<gl::Context *>(ctx);
21105 EVENT("glTexParameteri",
21106 "context = %d, GLenum target = %s, GLenum pname = %s, GLint param = %d", CID(context),
21107 GLenumToString(GLenumGroup::TextureTarget, target),
21108 GLenumToString(GLenumGroup::TextureParameterName, pname), param);
21109
21110 if (context)
21111 {
21112 ASSERT(context == GetValidGlobalContext());
21113 TextureType targetPacked = FromGL<TextureType>(target);
21114 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21115 bool isCallValid = (context->skipValidation() ||
21116 ValidateTexParameteri(context, targetPacked, pname, param));
21117 if (isCallValid)
21118 {
21119 context->texParameteri(targetPacked, pname, param);
21120 }
21121 ANGLE_CAPTURE(TexParameteri, isCallValid, context, targetPacked, pname, param);
21122 }
21123 }
21124
TexParameterivContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLint * params)21125 void GL_APIENTRY TexParameterivContextANGLE(GLeglContext ctx,
21126 GLenum target,
21127 GLenum pname,
21128 const GLint *params)
21129 {
21130 Context *context = static_cast<gl::Context *>(ctx);
21131 EVENT(
21132 "glTexParameteriv",
21133 "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
21134 "",
21135 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
21136 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
21137
21138 if (context)
21139 {
21140 ASSERT(context == GetValidGlobalContext());
21141 TextureType targetPacked = FromGL<TextureType>(target);
21142 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21143 bool isCallValid = (context->skipValidation() ||
21144 ValidateTexParameteriv(context, targetPacked, pname, params));
21145 if (isCallValid)
21146 {
21147 context->texParameteriv(targetPacked, pname, params);
21148 }
21149 ANGLE_CAPTURE(TexParameteriv, isCallValid, context, targetPacked, pname, params);
21150 }
21151 }
21152
TexParameterxContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLfixed param)21153 void GL_APIENTRY TexParameterxContextANGLE(GLeglContext ctx,
21154 GLenum target,
21155 GLenum pname,
21156 GLfixed param)
21157 {
21158 Context *context = static_cast<gl::Context *>(ctx);
21159 EVENT("glTexParameterx",
21160 "context = %d, GLenum target = %s, GLenum pname = %s, GLfixed param = 0x%X", CID(context),
21161 GLenumToString(GLenumGroup::TextureTarget, target),
21162 GLenumToString(GLenumGroup::GetTextureParameter, pname), param);
21163
21164 if (context)
21165 {
21166 ASSERT(context == GetValidGlobalContext());
21167 TextureType targetPacked = FromGL<TextureType>(target);
21168 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21169 bool isCallValid = (context->skipValidation() ||
21170 ValidateTexParameterx(context, targetPacked, pname, param));
21171 if (isCallValid)
21172 {
21173 context->texParameterx(targetPacked, pname, param);
21174 }
21175 ANGLE_CAPTURE(TexParameterx, isCallValid, context, targetPacked, pname, param);
21176 }
21177 }
21178
TexParameterxvContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,const GLfixed * params)21179 void GL_APIENTRY TexParameterxvContextANGLE(GLeglContext ctx,
21180 GLenum target,
21181 GLenum pname,
21182 const GLfixed *params)
21183 {
21184 Context *context = static_cast<gl::Context *>(ctx);
21185 EVENT("glTexParameterxv",
21186 "context = %d, GLenum target = %s, GLenum pname = %s, const GLfixed *params = "
21187 "0x%016" PRIxPTR "",
21188 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
21189 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
21190
21191 if (context)
21192 {
21193 ASSERT(context == GetValidGlobalContext());
21194 TextureType targetPacked = FromGL<TextureType>(target);
21195 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21196 bool isCallValid = (context->skipValidation() ||
21197 ValidateTexParameterxv(context, targetPacked, pname, params));
21198 if (isCallValid)
21199 {
21200 context->texParameterxv(targetPacked, pname, params);
21201 }
21202 ANGLE_CAPTURE(TexParameterxv, isCallValid, context, targetPacked, pname, params);
21203 }
21204 }
21205
TexStorage1DEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)21206 void GL_APIENTRY TexStorage1DEXTContextANGLE(GLeglContext ctx,
21207 GLenum target,
21208 GLsizei levels,
21209 GLenum internalformat,
21210 GLsizei width)
21211 {
21212 Context *context = static_cast<gl::Context *>(ctx);
21213 EVENT("glTexStorage1DEXT",
21214 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
21215 "GLsizei width = %d",
21216 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21217 GLenumToString(GLenumGroup::InternalFormat, internalformat), width);
21218
21219 if (context)
21220 {
21221 ASSERT(context == GetValidGlobalContext());
21222 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21223 bool isCallValid =
21224 (context->skipValidation() ||
21225 ValidateTexStorage1DEXT(context, target, levels, internalformat, width));
21226 if (isCallValid)
21227 {
21228 context->texStorage1D(target, levels, internalformat, width);
21229 }
21230 ANGLE_CAPTURE(TexStorage1DEXT, isCallValid, context, target, levels, internalformat, width);
21231 }
21232 }
21233
TexStorage2DContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)21234 void GL_APIENTRY TexStorage2DContextANGLE(GLeglContext ctx,
21235 GLenum target,
21236 GLsizei levels,
21237 GLenum internalformat,
21238 GLsizei width,
21239 GLsizei height)
21240 {
21241 Context *context = static_cast<gl::Context *>(ctx);
21242 EVENT("glTexStorage2D",
21243 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
21244 "GLsizei width = %d, GLsizei height = %d",
21245 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21246 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
21247
21248 if (context)
21249 {
21250 ASSERT(context == GetValidGlobalContext());
21251 TextureType targetPacked = FromGL<TextureType>(target);
21252 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21253 bool isCallValid =
21254 (context->skipValidation() ||
21255 ValidateTexStorage2D(context, targetPacked, levels, internalformat, width, height));
21256 if (isCallValid)
21257 {
21258 context->texStorage2D(targetPacked, levels, internalformat, width, height);
21259 }
21260 ANGLE_CAPTURE(TexStorage2D, isCallValid, context, targetPacked, levels, internalformat,
21261 width, height);
21262 }
21263 }
21264
TexStorage2DEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)21265 void GL_APIENTRY TexStorage2DEXTContextANGLE(GLeglContext ctx,
21266 GLenum target,
21267 GLsizei levels,
21268 GLenum internalformat,
21269 GLsizei width,
21270 GLsizei height)
21271 {
21272 Context *context = static_cast<gl::Context *>(ctx);
21273 EVENT("glTexStorage2DEXT",
21274 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
21275 "GLsizei width = %d, GLsizei height = %d",
21276 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21277 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
21278
21279 if (context)
21280 {
21281 ASSERT(context == GetValidGlobalContext());
21282 TextureType targetPacked = FromGL<TextureType>(target);
21283 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21284 bool isCallValid =
21285 (context->skipValidation() ||
21286 ValidateTexStorage2DEXT(context, targetPacked, levels, internalformat, width, height));
21287 if (isCallValid)
21288 {
21289 context->texStorage2D(targetPacked, levels, internalformat, width, height);
21290 }
21291 ANGLE_CAPTURE(TexStorage2DEXT, isCallValid, context, targetPacked, levels, internalformat,
21292 width, height);
21293 }
21294 }
21295
TexStorage2DMultisampleContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)21296 void GL_APIENTRY TexStorage2DMultisampleContextANGLE(GLeglContext ctx,
21297 GLenum target,
21298 GLsizei samples,
21299 GLenum internalformat,
21300 GLsizei width,
21301 GLsizei height,
21302 GLboolean fixedsamplelocations)
21303 {
21304 Context *context = static_cast<gl::Context *>(ctx);
21305 EVENT("glTexStorage2DMultisample",
21306 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
21307 "GLsizei width = %d, GLsizei height = %d, GLboolean fixedsamplelocations = %s",
21308 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
21309 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height,
21310 GLbooleanToString(fixedsamplelocations));
21311
21312 if (context)
21313 {
21314 ASSERT(context == GetValidGlobalContext());
21315 TextureType targetPacked = FromGL<TextureType>(target);
21316 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21317 bool isCallValid =
21318 (context->skipValidation() ||
21319 ValidateTexStorage2DMultisample(context, targetPacked, samples, internalformat, width,
21320 height, fixedsamplelocations));
21321 if (isCallValid)
21322 {
21323 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
21324 fixedsamplelocations);
21325 }
21326 ANGLE_CAPTURE(TexStorage2DMultisample, isCallValid, context, targetPacked, samples,
21327 internalformat, width, height, fixedsamplelocations);
21328 }
21329 }
21330
TexStorage3DContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)21331 void GL_APIENTRY TexStorage3DContextANGLE(GLeglContext ctx,
21332 GLenum target,
21333 GLsizei levels,
21334 GLenum internalformat,
21335 GLsizei width,
21336 GLsizei height,
21337 GLsizei depth)
21338 {
21339 Context *context = static_cast<gl::Context *>(ctx);
21340 EVENT("glTexStorage3D",
21341 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
21342 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d",
21343 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21344 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth);
21345
21346 if (context)
21347 {
21348 ASSERT(context == GetValidGlobalContext());
21349 TextureType targetPacked = FromGL<TextureType>(target);
21350 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21351 bool isCallValid = (context->skipValidation() ||
21352 ValidateTexStorage3D(context, targetPacked, levels, internalformat,
21353 width, height, depth));
21354 if (isCallValid)
21355 {
21356 context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
21357 }
21358 ANGLE_CAPTURE(TexStorage3D, isCallValid, context, targetPacked, levels, internalformat,
21359 width, height, depth);
21360 }
21361 }
21362
TexStorage3DEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)21363 void GL_APIENTRY TexStorage3DEXTContextANGLE(GLeglContext ctx,
21364 GLenum target,
21365 GLsizei levels,
21366 GLenum internalformat,
21367 GLsizei width,
21368 GLsizei height,
21369 GLsizei depth)
21370 {
21371 Context *context = static_cast<gl::Context *>(ctx);
21372 EVENT("glTexStorage3DEXT",
21373 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalformat = %s, "
21374 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d",
21375 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21376 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth);
21377
21378 if (context)
21379 {
21380 ASSERT(context == GetValidGlobalContext());
21381 TextureType targetPacked = FromGL<TextureType>(target);
21382 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21383 bool isCallValid = (context->skipValidation() ||
21384 ValidateTexStorage3DEXT(context, targetPacked, levels, internalformat,
21385 width, height, depth));
21386 if (isCallValid)
21387 {
21388 context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
21389 }
21390 ANGLE_CAPTURE(TexStorage3DEXT, isCallValid, context, targetPacked, levels, internalformat,
21391 width, height, depth);
21392 }
21393 }
21394
TexStorage3DMultisampleContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)21395 void GL_APIENTRY TexStorage3DMultisampleContextANGLE(GLeglContext ctx,
21396 GLenum target,
21397 GLsizei samples,
21398 GLenum internalformat,
21399 GLsizei width,
21400 GLsizei height,
21401 GLsizei depth,
21402 GLboolean fixedsamplelocations)
21403 {
21404 Context *context = static_cast<gl::Context *>(ctx);
21405 EVENT("glTexStorage3DMultisample",
21406 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
21407 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLboolean "
21408 "fixedsamplelocations = %s",
21409 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
21410 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth,
21411 GLbooleanToString(fixedsamplelocations));
21412
21413 if (context)
21414 {
21415 ASSERT(context == GetValidGlobalContext());
21416 TextureType targetPacked = FromGL<TextureType>(target);
21417 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21418 bool isCallValid =
21419 (context->skipValidation() ||
21420 ValidateTexStorage3DMultisample(context, targetPacked, samples, internalformat, width,
21421 height, depth, fixedsamplelocations));
21422 if (isCallValid)
21423 {
21424 context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
21425 depth, fixedsamplelocations);
21426 }
21427 ANGLE_CAPTURE(TexStorage3DMultisample, isCallValid, context, targetPacked, samples,
21428 internalformat, width, height, depth, fixedsamplelocations);
21429 }
21430 }
21431
TexStorage3DMultisampleOESContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)21432 void GL_APIENTRY TexStorage3DMultisampleOESContextANGLE(GLeglContext ctx,
21433 GLenum target,
21434 GLsizei samples,
21435 GLenum internalformat,
21436 GLsizei width,
21437 GLsizei height,
21438 GLsizei depth,
21439 GLboolean fixedsamplelocations)
21440 {
21441 Context *context = static_cast<gl::Context *>(ctx);
21442 EVENT("glTexStorage3DMultisampleOES",
21443 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
21444 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLboolean "
21445 "fixedsamplelocations = %s",
21446 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
21447 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth,
21448 GLbooleanToString(fixedsamplelocations));
21449
21450 if (context)
21451 {
21452 ASSERT(context == GetValidGlobalContext());
21453 TextureType targetPacked = FromGL<TextureType>(target);
21454 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21455 bool isCallValid =
21456 (context->skipValidation() ||
21457 ValidateTexStorage3DMultisampleOES(context, targetPacked, samples, internalformat,
21458 width, height, depth, fixedsamplelocations));
21459 if (isCallValid)
21460 {
21461 context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
21462 depth, fixedsamplelocations);
21463 }
21464 ANGLE_CAPTURE(TexStorage3DMultisampleOES, isCallValid, context, targetPacked, samples,
21465 internalformat, width, height, depth, fixedsamplelocations);
21466 }
21467 }
21468
TexStorageMem2DEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset)21469 void GL_APIENTRY TexStorageMem2DEXTContextANGLE(GLeglContext ctx,
21470 GLenum target,
21471 GLsizei levels,
21472 GLenum internalFormat,
21473 GLsizei width,
21474 GLsizei height,
21475 GLuint memory,
21476 GLuint64 offset)
21477 {
21478 Context *context = static_cast<gl::Context *>(ctx);
21479 EVENT("glTexStorageMem2DEXT",
21480 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalFormat = %s, "
21481 "GLsizei width = %d, GLsizei height = %d, GLuint memory = %u, GLuint64 offset = %llu",
21482 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21483 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory,
21484 static_cast<unsigned long long>(offset));
21485
21486 if (context)
21487 {
21488 ASSERT(context == GetValidGlobalContext());
21489 TextureType targetPacked = FromGL<TextureType>(target);
21490 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
21491 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21492 bool isCallValid =
21493 (context->skipValidation() ||
21494 ValidateTexStorageMem2DEXT(context, targetPacked, levels, internalFormat, width,
21495 height, memoryPacked, offset));
21496 if (isCallValid)
21497 {
21498 context->texStorageMem2D(targetPacked, levels, internalFormat, width, height,
21499 memoryPacked, offset);
21500 }
21501 ANGLE_CAPTURE(TexStorageMem2DEXT, isCallValid, context, targetPacked, levels,
21502 internalFormat, width, height, memoryPacked, offset);
21503 }
21504 }
21505
TexStorageMem2DMultisampleEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)21506 void GL_APIENTRY TexStorageMem2DMultisampleEXTContextANGLE(GLeglContext ctx,
21507 GLenum target,
21508 GLsizei samples,
21509 GLenum internalFormat,
21510 GLsizei width,
21511 GLsizei height,
21512 GLboolean fixedSampleLocations,
21513 GLuint memory,
21514 GLuint64 offset)
21515 {
21516 Context *context = static_cast<gl::Context *>(ctx);
21517 EVENT("glTexStorageMem2DMultisampleEXT",
21518 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalFormat = %s, "
21519 "GLsizei width = %d, GLsizei height = %d, GLboolean fixedSampleLocations = %s, GLuint "
21520 "memory = %u, GLuint64 offset = %llu",
21521 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
21522 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height,
21523 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
21524
21525 if (context)
21526 {
21527 ASSERT(context == GetValidGlobalContext());
21528 TextureType targetPacked = FromGL<TextureType>(target);
21529 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
21530 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21531 bool isCallValid =
21532 (context->skipValidation() || ValidateTexStorageMem2DMultisampleEXT(
21533 context, targetPacked, samples, internalFormat, width,
21534 height, fixedSampleLocations, memoryPacked, offset));
21535 if (isCallValid)
21536 {
21537 context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
21538 height, fixedSampleLocations, memoryPacked, offset);
21539 }
21540 ANGLE_CAPTURE(TexStorageMem2DMultisampleEXT, isCallValid, context, targetPacked, samples,
21541 internalFormat, width, height, fixedSampleLocations, memoryPacked, offset);
21542 }
21543 }
21544
TexStorageMem3DEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset)21545 void GL_APIENTRY TexStorageMem3DEXTContextANGLE(GLeglContext ctx,
21546 GLenum target,
21547 GLsizei levels,
21548 GLenum internalFormat,
21549 GLsizei width,
21550 GLsizei height,
21551 GLsizei depth,
21552 GLuint memory,
21553 GLuint64 offset)
21554 {
21555 Context *context = static_cast<gl::Context *>(ctx);
21556 EVENT("glTexStorageMem3DEXT",
21557 "context = %d, GLenum target = %s, GLsizei levels = %d, GLenum internalFormat = %s, "
21558 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLuint memory = %u, "
21559 "GLuint64 offset = %llu",
21560 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
21561 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory,
21562 static_cast<unsigned long long>(offset));
21563
21564 if (context)
21565 {
21566 ASSERT(context == GetValidGlobalContext());
21567 TextureType targetPacked = FromGL<TextureType>(target);
21568 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
21569 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21570 bool isCallValid =
21571 (context->skipValidation() ||
21572 ValidateTexStorageMem3DEXT(context, targetPacked, levels, internalFormat, width,
21573 height, depth, memoryPacked, offset));
21574 if (isCallValid)
21575 {
21576 context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
21577 memoryPacked, offset);
21578 }
21579 ANGLE_CAPTURE(TexStorageMem3DEXT, isCallValid, context, targetPacked, levels,
21580 internalFormat, width, height, depth, memoryPacked, offset);
21581 }
21582 }
21583
TexStorageMem3DMultisampleEXTContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)21584 void GL_APIENTRY TexStorageMem3DMultisampleEXTContextANGLE(GLeglContext ctx,
21585 GLenum target,
21586 GLsizei samples,
21587 GLenum internalFormat,
21588 GLsizei width,
21589 GLsizei height,
21590 GLsizei depth,
21591 GLboolean fixedSampleLocations,
21592 GLuint memory,
21593 GLuint64 offset)
21594 {
21595 Context *context = static_cast<gl::Context *>(ctx);
21596 EVENT("glTexStorageMem3DMultisampleEXT",
21597 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalFormat = %s, "
21598 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLboolean "
21599 "fixedSampleLocations = %s, GLuint memory = %u, GLuint64 offset = %llu",
21600 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
21601 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth,
21602 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
21603
21604 if (context)
21605 {
21606 ASSERT(context == GetValidGlobalContext());
21607 TextureType targetPacked = FromGL<TextureType>(target);
21608 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
21609 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21610 bool isCallValid = (context->skipValidation() ||
21611 ValidateTexStorageMem3DMultisampleEXT(
21612 context, targetPacked, samples, internalFormat, width, height,
21613 depth, fixedSampleLocations, memoryPacked, offset));
21614 if (isCallValid)
21615 {
21616 context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
21617 height, depth, fixedSampleLocations, memoryPacked,
21618 offset);
21619 }
21620 ANGLE_CAPTURE(TexStorageMem3DMultisampleEXT, isCallValid, context, targetPacked, samples,
21621 internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
21622 offset);
21623 }
21624 }
21625
TexSubImage2DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)21626 void GL_APIENTRY TexSubImage2DContextANGLE(GLeglContext ctx,
21627 GLenum target,
21628 GLint level,
21629 GLint xoffset,
21630 GLint yoffset,
21631 GLsizei width,
21632 GLsizei height,
21633 GLenum format,
21634 GLenum type,
21635 const void *pixels)
21636 {
21637 Context *context = static_cast<gl::Context *>(ctx);
21638 EVENT("glTexSubImage2D",
21639 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
21640 "%d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLenum type = %s, "
21641 "const void *pixels = 0x%016" PRIxPTR "",
21642 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
21643 width, height, GLenumToString(GLenumGroup::PixelFormat, format),
21644 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
21645
21646 if (context)
21647 {
21648 ASSERT(context == GetValidGlobalContext());
21649 TextureTarget targetPacked = FromGL<TextureTarget>(target);
21650 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21651 bool isCallValid = (context->skipValidation() ||
21652 ValidateTexSubImage2D(context, targetPacked, level, xoffset, yoffset,
21653 width, height, format, type, pixels));
21654 if (isCallValid)
21655 {
21656 context->texSubImage2D(targetPacked, level, xoffset, yoffset, width, height, format,
21657 type, pixels);
21658 }
21659 ANGLE_CAPTURE(TexSubImage2D, isCallValid, context, targetPacked, level, xoffset, yoffset,
21660 width, height, format, type, pixels);
21661 }
21662 }
21663
TexSubImage3DContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)21664 void GL_APIENTRY TexSubImage3DContextANGLE(GLeglContext ctx,
21665 GLenum target,
21666 GLint level,
21667 GLint xoffset,
21668 GLint yoffset,
21669 GLint zoffset,
21670 GLsizei width,
21671 GLsizei height,
21672 GLsizei depth,
21673 GLenum format,
21674 GLenum type,
21675 const void *pixels)
21676 {
21677 Context *context = static_cast<gl::Context *>(ctx);
21678 EVENT("glTexSubImage3D",
21679 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
21680 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
21681 "GLenum format = %s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
21682 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
21683 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
21684 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
21685
21686 if (context)
21687 {
21688 ASSERT(context == GetValidGlobalContext());
21689 TextureTarget targetPacked = FromGL<TextureTarget>(target);
21690 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21691 bool isCallValid =
21692 (context->skipValidation() ||
21693 ValidateTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset, width,
21694 height, depth, format, type, pixels));
21695 if (isCallValid)
21696 {
21697 context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
21698 depth, format, type, pixels);
21699 }
21700 ANGLE_CAPTURE(TexSubImage3D, isCallValid, context, targetPacked, level, xoffset, yoffset,
21701 zoffset, width, height, depth, format, type, pixels);
21702 }
21703 }
21704
TexSubImage3DOESContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)21705 void GL_APIENTRY TexSubImage3DOESContextANGLE(GLeglContext ctx,
21706 GLenum target,
21707 GLint level,
21708 GLint xoffset,
21709 GLint yoffset,
21710 GLint zoffset,
21711 GLsizei width,
21712 GLsizei height,
21713 GLsizei depth,
21714 GLenum format,
21715 GLenum type,
21716 const void *pixels)
21717 {
21718 Context *context = static_cast<gl::Context *>(ctx);
21719 EVENT("glTexSubImage3DOES",
21720 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
21721 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
21722 "GLenum format = %s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
21723 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
21724 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
21725 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
21726
21727 if (context)
21728 {
21729 ASSERT(context == GetValidGlobalContext());
21730 TextureTarget targetPacked = FromGL<TextureTarget>(target);
21731 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21732 bool isCallValid =
21733 (context->skipValidation() ||
21734 ValidateTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset,
21735 width, height, depth, format, type, pixels));
21736 if (isCallValid)
21737 {
21738 context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
21739 depth, format, type, pixels);
21740 }
21741 ANGLE_CAPTURE(TexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset, yoffset,
21742 zoffset, width, height, depth, format, type, pixels);
21743 }
21744 }
21745
TransformFeedbackVaryingsContextANGLE(GLeglContext ctx,GLuint program,GLsizei count,const GLchar * const * varyings,GLenum bufferMode)21746 void GL_APIENTRY TransformFeedbackVaryingsContextANGLE(GLeglContext ctx,
21747 GLuint program,
21748 GLsizei count,
21749 const GLchar *const *varyings,
21750 GLenum bufferMode)
21751 {
21752 Context *context = static_cast<gl::Context *>(ctx);
21753 EVENT("glTransformFeedbackVaryings",
21754 "context = %d, GLuint program = %u, GLsizei count = %d, const GLchar *const*varyings = "
21755 "0x%016" PRIxPTR ", GLenum bufferMode = %s",
21756 CID(context), program, count, (uintptr_t)varyings,
21757 GLenumToString(GLenumGroup::DefaultGroup, bufferMode));
21758
21759 if (context)
21760 {
21761 ASSERT(context == GetValidGlobalContext());
21762 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
21763 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21764 bool isCallValid =
21765 (context->skipValidation() || ValidateTransformFeedbackVaryings(
21766 context, programPacked, count, varyings, bufferMode));
21767 if (isCallValid)
21768 {
21769 context->transformFeedbackVaryings(programPacked, count, varyings, bufferMode);
21770 }
21771 ANGLE_CAPTURE(TransformFeedbackVaryings, isCallValid, context, programPacked, count,
21772 varyings, bufferMode);
21773 }
21774 }
21775
TranslatefContextANGLE(GLeglContext ctx,GLfloat x,GLfloat y,GLfloat z)21776 void GL_APIENTRY TranslatefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
21777 {
21778 Context *context = static_cast<gl::Context *>(ctx);
21779 EVENT("glTranslatef", "context = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f",
21780 CID(context), x, y, z);
21781
21782 if (context)
21783 {
21784 ASSERT(context == GetValidGlobalContext());
21785 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21786 bool isCallValid = (context->skipValidation() || ValidateTranslatef(context, x, y, z));
21787 if (isCallValid)
21788 {
21789 context->translatef(x, y, z);
21790 }
21791 ANGLE_CAPTURE(Translatef, isCallValid, context, x, y, z);
21792 }
21793 }
21794
TranslatexContextANGLE(GLeglContext ctx,GLfixed x,GLfixed y,GLfixed z)21795 void GL_APIENTRY TranslatexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
21796 {
21797 Context *context = static_cast<gl::Context *>(ctx);
21798 EVENT("glTranslatex", "context = %d, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X",
21799 CID(context), x, y, z);
21800
21801 if (context)
21802 {
21803 ASSERT(context == GetValidGlobalContext());
21804 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21805 bool isCallValid = (context->skipValidation() || ValidateTranslatex(context, x, y, z));
21806 if (isCallValid)
21807 {
21808 context->translatex(x, y, z);
21809 }
21810 ANGLE_CAPTURE(Translatex, isCallValid, context, x, y, z);
21811 }
21812 }
21813
Uniform1fContextANGLE(GLeglContext ctx,GLint location,GLfloat v0)21814 void GL_APIENTRY Uniform1fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0)
21815 {
21816 Context *context = static_cast<gl::Context *>(ctx);
21817 EVENT("glUniform1f", "context = %d, GLint location = %d, GLfloat v0 = %f", CID(context),
21818 location, v0);
21819
21820 if (context)
21821 {
21822 ASSERT(context == GetValidGlobalContext());
21823 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21824 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21825 bool isCallValid =
21826 (context->skipValidation() || ValidateUniform1f(context, locationPacked, v0));
21827 if (isCallValid)
21828 {
21829 context->uniform1f(locationPacked, v0);
21830 }
21831 ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
21832 }
21833 }
21834
Uniform1fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLfloat * value)21835 void GL_APIENTRY Uniform1fvContextANGLE(GLeglContext ctx,
21836 GLint location,
21837 GLsizei count,
21838 const GLfloat *value)
21839 {
21840 Context *context = static_cast<gl::Context *>(ctx);
21841 EVENT("glUniform1fv",
21842 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
21843 "0x%016" PRIxPTR "",
21844 CID(context), location, count, (uintptr_t)value);
21845
21846 if (context)
21847 {
21848 ASSERT(context == GetValidGlobalContext());
21849 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21850 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21851 bool isCallValid = (context->skipValidation() ||
21852 ValidateUniform1fv(context, locationPacked, count, value));
21853 if (isCallValid)
21854 {
21855 context->uniform1fv(locationPacked, count, value);
21856 }
21857 ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
21858 }
21859 }
21860
Uniform1iContextANGLE(GLeglContext ctx,GLint location,GLint v0)21861 void GL_APIENTRY Uniform1iContextANGLE(GLeglContext ctx, GLint location, GLint v0)
21862 {
21863 Context *context = static_cast<gl::Context *>(ctx);
21864 EVENT("glUniform1i", "context = %d, GLint location = %d, GLint v0 = %d", CID(context), location,
21865 v0);
21866
21867 if (context)
21868 {
21869 ASSERT(context == GetValidGlobalContext());
21870 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21871 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21872 bool isCallValid =
21873 (context->skipValidation() || ValidateUniform1i(context, locationPacked, v0));
21874 if (isCallValid)
21875 {
21876 context->uniform1i(locationPacked, v0);
21877 }
21878 ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
21879 }
21880 }
21881
Uniform1ivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLint * value)21882 void GL_APIENTRY Uniform1ivContextANGLE(GLeglContext ctx,
21883 GLint location,
21884 GLsizei count,
21885 const GLint *value)
21886 {
21887 Context *context = static_cast<gl::Context *>(ctx);
21888 EVENT(
21889 "glUniform1iv",
21890 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
21891 "",
21892 CID(context), location, count, (uintptr_t)value);
21893
21894 if (context)
21895 {
21896 ASSERT(context == GetValidGlobalContext());
21897 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21898 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21899 bool isCallValid = (context->skipValidation() ||
21900 ValidateUniform1iv(context, locationPacked, count, value));
21901 if (isCallValid)
21902 {
21903 context->uniform1iv(locationPacked, count, value);
21904 }
21905 ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
21906 }
21907 }
21908
Uniform1uiContextANGLE(GLeglContext ctx,GLint location,GLuint v0)21909 void GL_APIENTRY Uniform1uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0)
21910 {
21911 Context *context = static_cast<gl::Context *>(ctx);
21912 EVENT("glUniform1ui", "context = %d, GLint location = %d, GLuint v0 = %u", CID(context),
21913 location, v0);
21914
21915 if (context)
21916 {
21917 ASSERT(context == GetValidGlobalContext());
21918 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21919 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21920 bool isCallValid =
21921 (context->skipValidation() || ValidateUniform1ui(context, locationPacked, v0));
21922 if (isCallValid)
21923 {
21924 context->uniform1ui(locationPacked, v0);
21925 }
21926 ANGLE_CAPTURE(Uniform1ui, isCallValid, context, locationPacked, v0);
21927 }
21928 }
21929
Uniform1uivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLuint * value)21930 void GL_APIENTRY Uniform1uivContextANGLE(GLeglContext ctx,
21931 GLint location,
21932 GLsizei count,
21933 const GLuint *value)
21934 {
21935 Context *context = static_cast<gl::Context *>(ctx);
21936 EVENT("glUniform1uiv",
21937 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
21938 "0x%016" PRIxPTR "",
21939 CID(context), location, count, (uintptr_t)value);
21940
21941 if (context)
21942 {
21943 ASSERT(context == GetValidGlobalContext());
21944 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21945 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21946 bool isCallValid = (context->skipValidation() ||
21947 ValidateUniform1uiv(context, locationPacked, count, value));
21948 if (isCallValid)
21949 {
21950 context->uniform1uiv(locationPacked, count, value);
21951 }
21952 ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, locationPacked, count, value);
21953 }
21954 }
21955
Uniform2fContextANGLE(GLeglContext ctx,GLint location,GLfloat v0,GLfloat v1)21956 void GL_APIENTRY Uniform2fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1)
21957 {
21958 Context *context = static_cast<gl::Context *>(ctx);
21959 EVENT("glUniform2f", "context = %d, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f",
21960 CID(context), location, v0, v1);
21961
21962 if (context)
21963 {
21964 ASSERT(context == GetValidGlobalContext());
21965 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21966 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21967 bool isCallValid =
21968 (context->skipValidation() || ValidateUniform2f(context, locationPacked, v0, v1));
21969 if (isCallValid)
21970 {
21971 context->uniform2f(locationPacked, v0, v1);
21972 }
21973 ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
21974 }
21975 }
21976
Uniform2fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLfloat * value)21977 void GL_APIENTRY Uniform2fvContextANGLE(GLeglContext ctx,
21978 GLint location,
21979 GLsizei count,
21980 const GLfloat *value)
21981 {
21982 Context *context = static_cast<gl::Context *>(ctx);
21983 EVENT("glUniform2fv",
21984 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
21985 "0x%016" PRIxPTR "",
21986 CID(context), location, count, (uintptr_t)value);
21987
21988 if (context)
21989 {
21990 ASSERT(context == GetValidGlobalContext());
21991 UniformLocation locationPacked = FromGL<UniformLocation>(location);
21992 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
21993 bool isCallValid = (context->skipValidation() ||
21994 ValidateUniform2fv(context, locationPacked, count, value));
21995 if (isCallValid)
21996 {
21997 context->uniform2fv(locationPacked, count, value);
21998 }
21999 ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
22000 }
22001 }
22002
Uniform2iContextANGLE(GLeglContext ctx,GLint location,GLint v0,GLint v1)22003 void GL_APIENTRY Uniform2iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1)
22004 {
22005 Context *context = static_cast<gl::Context *>(ctx);
22006 EVENT("glUniform2i", "context = %d, GLint location = %d, GLint v0 = %d, GLint v1 = %d",
22007 CID(context), location, v0, v1);
22008
22009 if (context)
22010 {
22011 ASSERT(context == GetValidGlobalContext());
22012 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22013 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22014 bool isCallValid =
22015 (context->skipValidation() || ValidateUniform2i(context, locationPacked, v0, v1));
22016 if (isCallValid)
22017 {
22018 context->uniform2i(locationPacked, v0, v1);
22019 }
22020 ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
22021 }
22022 }
22023
Uniform2ivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLint * value)22024 void GL_APIENTRY Uniform2ivContextANGLE(GLeglContext ctx,
22025 GLint location,
22026 GLsizei count,
22027 const GLint *value)
22028 {
22029 Context *context = static_cast<gl::Context *>(ctx);
22030 EVENT(
22031 "glUniform2iv",
22032 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
22033 "",
22034 CID(context), location, count, (uintptr_t)value);
22035
22036 if (context)
22037 {
22038 ASSERT(context == GetValidGlobalContext());
22039 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22040 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22041 bool isCallValid = (context->skipValidation() ||
22042 ValidateUniform2iv(context, locationPacked, count, value));
22043 if (isCallValid)
22044 {
22045 context->uniform2iv(locationPacked, count, value);
22046 }
22047 ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
22048 }
22049 }
22050
Uniform2uiContextANGLE(GLeglContext ctx,GLint location,GLuint v0,GLuint v1)22051 void GL_APIENTRY Uniform2uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1)
22052 {
22053 Context *context = static_cast<gl::Context *>(ctx);
22054 EVENT("glUniform2ui", "context = %d, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u",
22055 CID(context), location, v0, v1);
22056
22057 if (context)
22058 {
22059 ASSERT(context == GetValidGlobalContext());
22060 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22061 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22062 bool isCallValid =
22063 (context->skipValidation() || ValidateUniform2ui(context, locationPacked, v0, v1));
22064 if (isCallValid)
22065 {
22066 context->uniform2ui(locationPacked, v0, v1);
22067 }
22068 ANGLE_CAPTURE(Uniform2ui, isCallValid, context, locationPacked, v0, v1);
22069 }
22070 }
22071
Uniform2uivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLuint * value)22072 void GL_APIENTRY Uniform2uivContextANGLE(GLeglContext ctx,
22073 GLint location,
22074 GLsizei count,
22075 const GLuint *value)
22076 {
22077 Context *context = static_cast<gl::Context *>(ctx);
22078 EVENT("glUniform2uiv",
22079 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
22080 "0x%016" PRIxPTR "",
22081 CID(context), location, count, (uintptr_t)value);
22082
22083 if (context)
22084 {
22085 ASSERT(context == GetValidGlobalContext());
22086 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22087 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22088 bool isCallValid = (context->skipValidation() ||
22089 ValidateUniform2uiv(context, locationPacked, count, value));
22090 if (isCallValid)
22091 {
22092 context->uniform2uiv(locationPacked, count, value);
22093 }
22094 ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, locationPacked, count, value);
22095 }
22096 }
22097
22098 void GL_APIENTRY
Uniform3fContextANGLE(GLeglContext ctx,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)22099 Uniform3fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
22100 {
22101 Context *context = static_cast<gl::Context *>(ctx);
22102 EVENT("glUniform3f",
22103 "context = %d, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f",
22104 CID(context), location, v0, v1, v2);
22105
22106 if (context)
22107 {
22108 ASSERT(context == GetValidGlobalContext());
22109 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22110 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22111 bool isCallValid =
22112 (context->skipValidation() || ValidateUniform3f(context, locationPacked, v0, v1, v2));
22113 if (isCallValid)
22114 {
22115 context->uniform3f(locationPacked, v0, v1, v2);
22116 }
22117 ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
22118 }
22119 }
22120
Uniform3fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLfloat * value)22121 void GL_APIENTRY Uniform3fvContextANGLE(GLeglContext ctx,
22122 GLint location,
22123 GLsizei count,
22124 const GLfloat *value)
22125 {
22126 Context *context = static_cast<gl::Context *>(ctx);
22127 EVENT("glUniform3fv",
22128 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
22129 "0x%016" PRIxPTR "",
22130 CID(context), location, count, (uintptr_t)value);
22131
22132 if (context)
22133 {
22134 ASSERT(context == GetValidGlobalContext());
22135 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22136 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22137 bool isCallValid = (context->skipValidation() ||
22138 ValidateUniform3fv(context, locationPacked, count, value));
22139 if (isCallValid)
22140 {
22141 context->uniform3fv(locationPacked, count, value);
22142 }
22143 ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
22144 }
22145 }
22146
22147 void GL_APIENTRY
Uniform3iContextANGLE(GLeglContext ctx,GLint location,GLint v0,GLint v1,GLint v2)22148 Uniform3iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2)
22149 {
22150 Context *context = static_cast<gl::Context *>(ctx);
22151 EVENT("glUniform3i",
22152 "context = %d, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d",
22153 CID(context), location, v0, v1, v2);
22154
22155 if (context)
22156 {
22157 ASSERT(context == GetValidGlobalContext());
22158 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22159 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22160 bool isCallValid =
22161 (context->skipValidation() || ValidateUniform3i(context, locationPacked, v0, v1, v2));
22162 if (isCallValid)
22163 {
22164 context->uniform3i(locationPacked, v0, v1, v2);
22165 }
22166 ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
22167 }
22168 }
22169
Uniform3ivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLint * value)22170 void GL_APIENTRY Uniform3ivContextANGLE(GLeglContext ctx,
22171 GLint location,
22172 GLsizei count,
22173 const GLint *value)
22174 {
22175 Context *context = static_cast<gl::Context *>(ctx);
22176 EVENT(
22177 "glUniform3iv",
22178 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
22179 "",
22180 CID(context), location, count, (uintptr_t)value);
22181
22182 if (context)
22183 {
22184 ASSERT(context == GetValidGlobalContext());
22185 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22186 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22187 bool isCallValid = (context->skipValidation() ||
22188 ValidateUniform3iv(context, locationPacked, count, value));
22189 if (isCallValid)
22190 {
22191 context->uniform3iv(locationPacked, count, value);
22192 }
22193 ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
22194 }
22195 }
22196
22197 void GL_APIENTRY
Uniform3uiContextANGLE(GLeglContext ctx,GLint location,GLuint v0,GLuint v1,GLuint v2)22198 Uniform3uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2)
22199 {
22200 Context *context = static_cast<gl::Context *>(ctx);
22201 EVENT("glUniform3ui",
22202 "context = %d, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u",
22203 CID(context), location, v0, v1, v2);
22204
22205 if (context)
22206 {
22207 ASSERT(context == GetValidGlobalContext());
22208 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22209 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22210 bool isCallValid =
22211 (context->skipValidation() || ValidateUniform3ui(context, locationPacked, v0, v1, v2));
22212 if (isCallValid)
22213 {
22214 context->uniform3ui(locationPacked, v0, v1, v2);
22215 }
22216 ANGLE_CAPTURE(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2);
22217 }
22218 }
22219
Uniform3uivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLuint * value)22220 void GL_APIENTRY Uniform3uivContextANGLE(GLeglContext ctx,
22221 GLint location,
22222 GLsizei count,
22223 const GLuint *value)
22224 {
22225 Context *context = static_cast<gl::Context *>(ctx);
22226 EVENT("glUniform3uiv",
22227 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
22228 "0x%016" PRIxPTR "",
22229 CID(context), location, count, (uintptr_t)value);
22230
22231 if (context)
22232 {
22233 ASSERT(context == GetValidGlobalContext());
22234 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22235 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22236 bool isCallValid = (context->skipValidation() ||
22237 ValidateUniform3uiv(context, locationPacked, count, value));
22238 if (isCallValid)
22239 {
22240 context->uniform3uiv(locationPacked, count, value);
22241 }
22242 ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, locationPacked, count, value);
22243 }
22244 }
22245
Uniform4fContextANGLE(GLeglContext ctx,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)22246 void GL_APIENTRY Uniform4fContextANGLE(GLeglContext ctx,
22247 GLint location,
22248 GLfloat v0,
22249 GLfloat v1,
22250 GLfloat v2,
22251 GLfloat v3)
22252 {
22253 Context *context = static_cast<gl::Context *>(ctx);
22254 EVENT("glUniform4f",
22255 "context = %d, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f, "
22256 "GLfloat v3 = %f",
22257 CID(context), location, v0, v1, v2, v3);
22258
22259 if (context)
22260 {
22261 ASSERT(context == GetValidGlobalContext());
22262 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22263 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22264 bool isCallValid = (context->skipValidation() ||
22265 ValidateUniform4f(context, locationPacked, v0, v1, v2, v3));
22266 if (isCallValid)
22267 {
22268 context->uniform4f(locationPacked, v0, v1, v2, v3);
22269 }
22270 ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
22271 }
22272 }
22273
Uniform4fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLfloat * value)22274 void GL_APIENTRY Uniform4fvContextANGLE(GLeglContext ctx,
22275 GLint location,
22276 GLsizei count,
22277 const GLfloat *value)
22278 {
22279 Context *context = static_cast<gl::Context *>(ctx);
22280 EVENT("glUniform4fv",
22281 "context = %d, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
22282 "0x%016" PRIxPTR "",
22283 CID(context), location, count, (uintptr_t)value);
22284
22285 if (context)
22286 {
22287 ASSERT(context == GetValidGlobalContext());
22288 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22289 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22290 bool isCallValid = (context->skipValidation() ||
22291 ValidateUniform4fv(context, locationPacked, count, value));
22292 if (isCallValid)
22293 {
22294 context->uniform4fv(locationPacked, count, value);
22295 }
22296 ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
22297 }
22298 }
22299
22300 void GL_APIENTRY
Uniform4iContextANGLE(GLeglContext ctx,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)22301 Uniform4iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
22302 {
22303 Context *context = static_cast<gl::Context *>(ctx);
22304 EVENT("glUniform4i",
22305 "context = %d, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, GLint "
22306 "v3 = %d",
22307 CID(context), location, v0, v1, v2, v3);
22308
22309 if (context)
22310 {
22311 ASSERT(context == GetValidGlobalContext());
22312 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22313 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22314 bool isCallValid = (context->skipValidation() ||
22315 ValidateUniform4i(context, locationPacked, v0, v1, v2, v3));
22316 if (isCallValid)
22317 {
22318 context->uniform4i(locationPacked, v0, v1, v2, v3);
22319 }
22320 ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
22321 }
22322 }
22323
Uniform4ivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLint * value)22324 void GL_APIENTRY Uniform4ivContextANGLE(GLeglContext ctx,
22325 GLint location,
22326 GLsizei count,
22327 const GLint *value)
22328 {
22329 Context *context = static_cast<gl::Context *>(ctx);
22330 EVENT(
22331 "glUniform4iv",
22332 "context = %d, GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR
22333 "",
22334 CID(context), location, count, (uintptr_t)value);
22335
22336 if (context)
22337 {
22338 ASSERT(context == GetValidGlobalContext());
22339 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22340 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22341 bool isCallValid = (context->skipValidation() ||
22342 ValidateUniform4iv(context, locationPacked, count, value));
22343 if (isCallValid)
22344 {
22345 context->uniform4iv(locationPacked, count, value);
22346 }
22347 ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
22348 }
22349 }
22350
22351 void GL_APIENTRY
Uniform4uiContextANGLE(GLeglContext ctx,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)22352 Uniform4uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
22353 {
22354 Context *context = static_cast<gl::Context *>(ctx);
22355 EVENT("glUniform4ui",
22356 "context = %d, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u, "
22357 "GLuint v3 = %u",
22358 CID(context), location, v0, v1, v2, v3);
22359
22360 if (context)
22361 {
22362 ASSERT(context == GetValidGlobalContext());
22363 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22364 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22365 bool isCallValid = (context->skipValidation() ||
22366 ValidateUniform4ui(context, locationPacked, v0, v1, v2, v3));
22367 if (isCallValid)
22368 {
22369 context->uniform4ui(locationPacked, v0, v1, v2, v3);
22370 }
22371 ANGLE_CAPTURE(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3);
22372 }
22373 }
22374
Uniform4uivContextANGLE(GLeglContext ctx,GLint location,GLsizei count,const GLuint * value)22375 void GL_APIENTRY Uniform4uivContextANGLE(GLeglContext ctx,
22376 GLint location,
22377 GLsizei count,
22378 const GLuint *value)
22379 {
22380 Context *context = static_cast<gl::Context *>(ctx);
22381 EVENT("glUniform4uiv",
22382 "context = %d, GLint location = %d, GLsizei count = %d, const GLuint *value = "
22383 "0x%016" PRIxPTR "",
22384 CID(context), location, count, (uintptr_t)value);
22385
22386 if (context)
22387 {
22388 ASSERT(context == GetValidGlobalContext());
22389 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22390 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22391 bool isCallValid = (context->skipValidation() ||
22392 ValidateUniform4uiv(context, locationPacked, count, value));
22393 if (isCallValid)
22394 {
22395 context->uniform4uiv(locationPacked, count, value);
22396 }
22397 ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, locationPacked, count, value);
22398 }
22399 }
22400
UniformBlockBindingContextANGLE(GLeglContext ctx,GLuint program,GLuint uniformBlockIndex,GLuint uniformBlockBinding)22401 void GL_APIENTRY UniformBlockBindingContextANGLE(GLeglContext ctx,
22402 GLuint program,
22403 GLuint uniformBlockIndex,
22404 GLuint uniformBlockBinding)
22405 {
22406 Context *context = static_cast<gl::Context *>(ctx);
22407 EVENT("glUniformBlockBinding",
22408 "context = %d, GLuint program = %u, GLuint uniformBlockIndex = %u, GLuint "
22409 "uniformBlockBinding = %u",
22410 CID(context), program, uniformBlockIndex, uniformBlockBinding);
22411
22412 if (context)
22413 {
22414 ASSERT(context == GetValidGlobalContext());
22415 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
22416 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22417 bool isCallValid = (context->skipValidation() ||
22418 ValidateUniformBlockBinding(context, programPacked, uniformBlockIndex,
22419 uniformBlockBinding));
22420 if (isCallValid)
22421 {
22422 context->uniformBlockBinding(programPacked, uniformBlockIndex, uniformBlockBinding);
22423 }
22424 ANGLE_CAPTURE(UniformBlockBinding, isCallValid, context, programPacked, uniformBlockIndex,
22425 uniformBlockBinding);
22426 }
22427 }
22428
UniformMatrix2fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22429 void GL_APIENTRY UniformMatrix2fvContextANGLE(GLeglContext ctx,
22430 GLint location,
22431 GLsizei count,
22432 GLboolean transpose,
22433 const GLfloat *value)
22434 {
22435 Context *context = static_cast<gl::Context *>(ctx);
22436 EVENT("glUniformMatrix2fv",
22437 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22438 "GLfloat *value = 0x%016" PRIxPTR "",
22439 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22440
22441 if (context)
22442 {
22443 ASSERT(context == GetValidGlobalContext());
22444 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22445 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22446 bool isCallValid =
22447 (context->skipValidation() ||
22448 ValidateUniformMatrix2fv(context, locationPacked, count, transpose, value));
22449 if (isCallValid)
22450 {
22451 context->uniformMatrix2fv(locationPacked, count, transpose, value);
22452 }
22453 ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
22454 value);
22455 }
22456 }
22457
UniformMatrix2x3fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22458 void GL_APIENTRY UniformMatrix2x3fvContextANGLE(GLeglContext ctx,
22459 GLint location,
22460 GLsizei count,
22461 GLboolean transpose,
22462 const GLfloat *value)
22463 {
22464 Context *context = static_cast<gl::Context *>(ctx);
22465 EVENT("glUniformMatrix2x3fv",
22466 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22467 "GLfloat *value = 0x%016" PRIxPTR "",
22468 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22469
22470 if (context)
22471 {
22472 ASSERT(context == GetValidGlobalContext());
22473 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22474 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22475 bool isCallValid =
22476 (context->skipValidation() ||
22477 ValidateUniformMatrix2x3fv(context, locationPacked, count, transpose, value));
22478 if (isCallValid)
22479 {
22480 context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
22481 }
22482 ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
22483 value);
22484 }
22485 }
22486
UniformMatrix2x4fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22487 void GL_APIENTRY UniformMatrix2x4fvContextANGLE(GLeglContext ctx,
22488 GLint location,
22489 GLsizei count,
22490 GLboolean transpose,
22491 const GLfloat *value)
22492 {
22493 Context *context = static_cast<gl::Context *>(ctx);
22494 EVENT("glUniformMatrix2x4fv",
22495 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22496 "GLfloat *value = 0x%016" PRIxPTR "",
22497 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22498
22499 if (context)
22500 {
22501 ASSERT(context == GetValidGlobalContext());
22502 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22503 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22504 bool isCallValid =
22505 (context->skipValidation() ||
22506 ValidateUniformMatrix2x4fv(context, locationPacked, count, transpose, value));
22507 if (isCallValid)
22508 {
22509 context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
22510 }
22511 ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
22512 value);
22513 }
22514 }
22515
UniformMatrix3fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22516 void GL_APIENTRY UniformMatrix3fvContextANGLE(GLeglContext ctx,
22517 GLint location,
22518 GLsizei count,
22519 GLboolean transpose,
22520 const GLfloat *value)
22521 {
22522 Context *context = static_cast<gl::Context *>(ctx);
22523 EVENT("glUniformMatrix3fv",
22524 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22525 "GLfloat *value = 0x%016" PRIxPTR "",
22526 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22527
22528 if (context)
22529 {
22530 ASSERT(context == GetValidGlobalContext());
22531 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22532 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22533 bool isCallValid =
22534 (context->skipValidation() ||
22535 ValidateUniformMatrix3fv(context, locationPacked, count, transpose, value));
22536 if (isCallValid)
22537 {
22538 context->uniformMatrix3fv(locationPacked, count, transpose, value);
22539 }
22540 ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
22541 value);
22542 }
22543 }
22544
UniformMatrix3x2fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22545 void GL_APIENTRY UniformMatrix3x2fvContextANGLE(GLeglContext ctx,
22546 GLint location,
22547 GLsizei count,
22548 GLboolean transpose,
22549 const GLfloat *value)
22550 {
22551 Context *context = static_cast<gl::Context *>(ctx);
22552 EVENT("glUniformMatrix3x2fv",
22553 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22554 "GLfloat *value = 0x%016" PRIxPTR "",
22555 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22556
22557 if (context)
22558 {
22559 ASSERT(context == GetValidGlobalContext());
22560 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22561 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22562 bool isCallValid =
22563 (context->skipValidation() ||
22564 ValidateUniformMatrix3x2fv(context, locationPacked, count, transpose, value));
22565 if (isCallValid)
22566 {
22567 context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
22568 }
22569 ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
22570 value);
22571 }
22572 }
22573
UniformMatrix3x4fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22574 void GL_APIENTRY UniformMatrix3x4fvContextANGLE(GLeglContext ctx,
22575 GLint location,
22576 GLsizei count,
22577 GLboolean transpose,
22578 const GLfloat *value)
22579 {
22580 Context *context = static_cast<gl::Context *>(ctx);
22581 EVENT("glUniformMatrix3x4fv",
22582 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22583 "GLfloat *value = 0x%016" PRIxPTR "",
22584 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22585
22586 if (context)
22587 {
22588 ASSERT(context == GetValidGlobalContext());
22589 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22590 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22591 bool isCallValid =
22592 (context->skipValidation() ||
22593 ValidateUniformMatrix3x4fv(context, locationPacked, count, transpose, value));
22594 if (isCallValid)
22595 {
22596 context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
22597 }
22598 ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
22599 value);
22600 }
22601 }
22602
UniformMatrix4fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22603 void GL_APIENTRY UniformMatrix4fvContextANGLE(GLeglContext ctx,
22604 GLint location,
22605 GLsizei count,
22606 GLboolean transpose,
22607 const GLfloat *value)
22608 {
22609 Context *context = static_cast<gl::Context *>(ctx);
22610 EVENT("glUniformMatrix4fv",
22611 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22612 "GLfloat *value = 0x%016" PRIxPTR "",
22613 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22614
22615 if (context)
22616 {
22617 ASSERT(context == GetValidGlobalContext());
22618 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22619 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22620 bool isCallValid =
22621 (context->skipValidation() ||
22622 ValidateUniformMatrix4fv(context, locationPacked, count, transpose, value));
22623 if (isCallValid)
22624 {
22625 context->uniformMatrix4fv(locationPacked, count, transpose, value);
22626 }
22627 ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
22628 value);
22629 }
22630 }
22631
UniformMatrix4x2fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22632 void GL_APIENTRY UniformMatrix4x2fvContextANGLE(GLeglContext ctx,
22633 GLint location,
22634 GLsizei count,
22635 GLboolean transpose,
22636 const GLfloat *value)
22637 {
22638 Context *context = static_cast<gl::Context *>(ctx);
22639 EVENT("glUniformMatrix4x2fv",
22640 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22641 "GLfloat *value = 0x%016" PRIxPTR "",
22642 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22643
22644 if (context)
22645 {
22646 ASSERT(context == GetValidGlobalContext());
22647 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22648 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22649 bool isCallValid =
22650 (context->skipValidation() ||
22651 ValidateUniformMatrix4x2fv(context, locationPacked, count, transpose, value));
22652 if (isCallValid)
22653 {
22654 context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
22655 }
22656 ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
22657 value);
22658 }
22659 }
22660
UniformMatrix4x3fvContextANGLE(GLeglContext ctx,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)22661 void GL_APIENTRY UniformMatrix4x3fvContextANGLE(GLeglContext ctx,
22662 GLint location,
22663 GLsizei count,
22664 GLboolean transpose,
22665 const GLfloat *value)
22666 {
22667 Context *context = static_cast<gl::Context *>(ctx);
22668 EVENT("glUniformMatrix4x3fv",
22669 "context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
22670 "GLfloat *value = 0x%016" PRIxPTR "",
22671 CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
22672
22673 if (context)
22674 {
22675 ASSERT(context == GetValidGlobalContext());
22676 UniformLocation locationPacked = FromGL<UniformLocation>(location);
22677 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22678 bool isCallValid =
22679 (context->skipValidation() ||
22680 ValidateUniformMatrix4x3fv(context, locationPacked, count, transpose, value));
22681 if (isCallValid)
22682 {
22683 context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
22684 }
22685 ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
22686 value);
22687 }
22688 }
22689
UnmapBufferContextANGLE(GLeglContext ctx,GLenum target)22690 GLboolean GL_APIENTRY UnmapBufferContextANGLE(GLeglContext ctx, GLenum target)
22691 {
22692 Context *context = static_cast<gl::Context *>(ctx);
22693 EVENT("glUnmapBuffer", "context = %d, GLenum target = %s", CID(context),
22694 GLenumToString(GLenumGroup::BufferTargetARB, target));
22695
22696 GLboolean returnValue;
22697 if (context)
22698 {
22699 ASSERT(context == GetValidGlobalContext());
22700 BufferBinding targetPacked = FromGL<BufferBinding>(target);
22701 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22702 bool isCallValid =
22703 (context->skipValidation() || ValidateUnmapBuffer(context, targetPacked));
22704 if (isCallValid)
22705 {
22706 returnValue = context->unmapBuffer(targetPacked);
22707 }
22708 else
22709 {
22710 returnValue = GetDefaultReturnValue<EntryPoint::UnmapBuffer, GLboolean>();
22711 }
22712 ANGLE_CAPTURE(UnmapBuffer, isCallValid, context, targetPacked, returnValue);
22713 }
22714 else
22715 {
22716 returnValue = GetDefaultReturnValue<EntryPoint::UnmapBuffer, GLboolean>();
22717 }
22718 return returnValue;
22719 }
22720
UnmapBufferOESContextANGLE(GLeglContext ctx,GLenum target)22721 GLboolean GL_APIENTRY UnmapBufferOESContextANGLE(GLeglContext ctx, GLenum target)
22722 {
22723 Context *context = static_cast<gl::Context *>(ctx);
22724 EVENT("glUnmapBufferOES", "context = %d, GLenum target = %s", CID(context),
22725 GLenumToString(GLenumGroup::DefaultGroup, target));
22726
22727 GLboolean returnValue;
22728 if (context)
22729 {
22730 ASSERT(context == GetValidGlobalContext());
22731 BufferBinding targetPacked = FromGL<BufferBinding>(target);
22732 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22733 bool isCallValid =
22734 (context->skipValidation() || ValidateUnmapBufferOES(context, targetPacked));
22735 if (isCallValid)
22736 {
22737 returnValue = context->unmapBuffer(targetPacked);
22738 }
22739 else
22740 {
22741 returnValue = GetDefaultReturnValue<EntryPoint::UnmapBufferOES, GLboolean>();
22742 }
22743 ANGLE_CAPTURE(UnmapBufferOES, isCallValid, context, targetPacked, returnValue);
22744 }
22745 else
22746 {
22747 returnValue = GetDefaultReturnValue<EntryPoint::UnmapBufferOES, GLboolean>();
22748 }
22749 return returnValue;
22750 }
22751
UseProgramContextANGLE(GLeglContext ctx,GLuint program)22752 void GL_APIENTRY UseProgramContextANGLE(GLeglContext ctx, GLuint program)
22753 {
22754 Context *context = static_cast<gl::Context *>(ctx);
22755 EVENT("glUseProgram", "context = %d, GLuint program = %u", CID(context), program);
22756
22757 if (context)
22758 {
22759 ASSERT(context == GetValidGlobalContext());
22760 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
22761 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22762 bool isCallValid =
22763 (context->skipValidation() || ValidateUseProgram(context, programPacked));
22764 if (isCallValid)
22765 {
22766 context->useProgram(programPacked);
22767 }
22768 ANGLE_CAPTURE(UseProgram, isCallValid, context, programPacked);
22769 }
22770 }
22771
UseProgramStagesContextANGLE(GLeglContext ctx,GLuint pipeline,GLbitfield stages,GLuint program)22772 void GL_APIENTRY UseProgramStagesContextANGLE(GLeglContext ctx,
22773 GLuint pipeline,
22774 GLbitfield stages,
22775 GLuint program)
22776 {
22777 Context *context = static_cast<gl::Context *>(ctx);
22778 EVENT("glUseProgramStages",
22779 "context = %d, GLuint pipeline = %u, GLbitfield stages = %s, GLuint program = %u",
22780 CID(context), pipeline,
22781 GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program);
22782
22783 if (context)
22784 {
22785 ASSERT(context == GetValidGlobalContext());
22786 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
22787 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
22788 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22789 bool isCallValid =
22790 (context->skipValidation() ||
22791 ValidateUseProgramStages(context, pipelinePacked, stages, programPacked));
22792 if (isCallValid)
22793 {
22794 context->useProgramStages(pipelinePacked, stages, programPacked);
22795 }
22796 ANGLE_CAPTURE(UseProgramStages, isCallValid, context, pipelinePacked, stages,
22797 programPacked);
22798 }
22799 }
22800
ValidateProgramContextANGLE(GLeglContext ctx,GLuint program)22801 void GL_APIENTRY ValidateProgramContextANGLE(GLeglContext ctx, GLuint program)
22802 {
22803 Context *context = static_cast<gl::Context *>(ctx);
22804 EVENT("glValidateProgram", "context = %d, GLuint program = %u", CID(context), program);
22805
22806 if (context)
22807 {
22808 ASSERT(context == GetValidGlobalContext());
22809 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
22810 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22811 bool isCallValid =
22812 (context->skipValidation() || ValidateValidateProgram(context, programPacked));
22813 if (isCallValid)
22814 {
22815 context->validateProgram(programPacked);
22816 }
22817 ANGLE_CAPTURE(ValidateProgram, isCallValid, context, programPacked);
22818 }
22819 }
22820
ValidateProgramPipelineContextANGLE(GLeglContext ctx,GLuint pipeline)22821 void GL_APIENTRY ValidateProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
22822 {
22823 Context *context = static_cast<gl::Context *>(ctx);
22824 EVENT("glValidateProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context),
22825 pipeline);
22826
22827 if (context)
22828 {
22829 ASSERT(context == GetValidGlobalContext());
22830 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
22831 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22832 bool isCallValid =
22833 (context->skipValidation() || ValidateValidateProgramPipeline(context, pipelinePacked));
22834 if (isCallValid)
22835 {
22836 context->validateProgramPipeline(pipelinePacked);
22837 }
22838 ANGLE_CAPTURE(ValidateProgramPipeline, isCallValid, context, pipelinePacked);
22839 }
22840 }
22841
VertexAttrib1fContextANGLE(GLeglContext ctx,GLuint index,GLfloat x)22842 void GL_APIENTRY VertexAttrib1fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x)
22843 {
22844 Context *context = static_cast<gl::Context *>(ctx);
22845 EVENT("glVertexAttrib1f", "context = %d, GLuint index = %u, GLfloat x = %f", CID(context),
22846 index, x);
22847
22848 if (context)
22849 {
22850 ASSERT(context == GetValidGlobalContext());
22851 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22852 bool isCallValid = (context->skipValidation() || ValidateVertexAttrib1f(context, index, x));
22853 if (isCallValid)
22854 {
22855 context->vertexAttrib1f(index, x);
22856 }
22857 ANGLE_CAPTURE(VertexAttrib1f, isCallValid, context, index, x);
22858 }
22859 }
22860
VertexAttrib1fvContextANGLE(GLeglContext ctx,GLuint index,const GLfloat * v)22861 void GL_APIENTRY VertexAttrib1fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
22862 {
22863 Context *context = static_cast<gl::Context *>(ctx);
22864 EVENT("glVertexAttrib1fv",
22865 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
22866 index, (uintptr_t)v);
22867
22868 if (context)
22869 {
22870 ASSERT(context == GetValidGlobalContext());
22871 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22872 bool isCallValid =
22873 (context->skipValidation() || ValidateVertexAttrib1fv(context, index, v));
22874 if (isCallValid)
22875 {
22876 context->vertexAttrib1fv(index, v);
22877 }
22878 ANGLE_CAPTURE(VertexAttrib1fv, isCallValid, context, index, v);
22879 }
22880 }
22881
VertexAttrib2fContextANGLE(GLeglContext ctx,GLuint index,GLfloat x,GLfloat y)22882 void GL_APIENTRY VertexAttrib2fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y)
22883 {
22884 Context *context = static_cast<gl::Context *>(ctx);
22885 EVENT("glVertexAttrib2f", "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f",
22886 CID(context), index, x, y);
22887
22888 if (context)
22889 {
22890 ASSERT(context == GetValidGlobalContext());
22891 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22892 bool isCallValid =
22893 (context->skipValidation() || ValidateVertexAttrib2f(context, index, x, y));
22894 if (isCallValid)
22895 {
22896 context->vertexAttrib2f(index, x, y);
22897 }
22898 ANGLE_CAPTURE(VertexAttrib2f, isCallValid, context, index, x, y);
22899 }
22900 }
22901
VertexAttrib2fvContextANGLE(GLeglContext ctx,GLuint index,const GLfloat * v)22902 void GL_APIENTRY VertexAttrib2fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
22903 {
22904 Context *context = static_cast<gl::Context *>(ctx);
22905 EVENT("glVertexAttrib2fv",
22906 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
22907 index, (uintptr_t)v);
22908
22909 if (context)
22910 {
22911 ASSERT(context == GetValidGlobalContext());
22912 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22913 bool isCallValid =
22914 (context->skipValidation() || ValidateVertexAttrib2fv(context, index, v));
22915 if (isCallValid)
22916 {
22917 context->vertexAttrib2fv(index, v);
22918 }
22919 ANGLE_CAPTURE(VertexAttrib2fv, isCallValid, context, index, v);
22920 }
22921 }
22922
22923 void GL_APIENTRY
VertexAttrib3fContextANGLE(GLeglContext ctx,GLuint index,GLfloat x,GLfloat y,GLfloat z)22924 VertexAttrib3fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z)
22925 {
22926 Context *context = static_cast<gl::Context *>(ctx);
22927 EVENT("glVertexAttrib3f",
22928 "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f",
22929 CID(context), index, x, y, z);
22930
22931 if (context)
22932 {
22933 ASSERT(context == GetValidGlobalContext());
22934 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22935 bool isCallValid =
22936 (context->skipValidation() || ValidateVertexAttrib3f(context, index, x, y, z));
22937 if (isCallValid)
22938 {
22939 context->vertexAttrib3f(index, x, y, z);
22940 }
22941 ANGLE_CAPTURE(VertexAttrib3f, isCallValid, context, index, x, y, z);
22942 }
22943 }
22944
VertexAttrib3fvContextANGLE(GLeglContext ctx,GLuint index,const GLfloat * v)22945 void GL_APIENTRY VertexAttrib3fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
22946 {
22947 Context *context = static_cast<gl::Context *>(ctx);
22948 EVENT("glVertexAttrib3fv",
22949 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
22950 index, (uintptr_t)v);
22951
22952 if (context)
22953 {
22954 ASSERT(context == GetValidGlobalContext());
22955 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22956 bool isCallValid =
22957 (context->skipValidation() || ValidateVertexAttrib3fv(context, index, v));
22958 if (isCallValid)
22959 {
22960 context->vertexAttrib3fv(index, v);
22961 }
22962 ANGLE_CAPTURE(VertexAttrib3fv, isCallValid, context, index, v);
22963 }
22964 }
22965
VertexAttrib4fContextANGLE(GLeglContext ctx,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)22966 void GL_APIENTRY VertexAttrib4fContextANGLE(GLeglContext ctx,
22967 GLuint index,
22968 GLfloat x,
22969 GLfloat y,
22970 GLfloat z,
22971 GLfloat w)
22972 {
22973 Context *context = static_cast<gl::Context *>(ctx);
22974 EVENT("glVertexAttrib4f",
22975 "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, "
22976 "GLfloat w = %f",
22977 CID(context), index, x, y, z, w);
22978
22979 if (context)
22980 {
22981 ASSERT(context == GetValidGlobalContext());
22982 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
22983 bool isCallValid =
22984 (context->skipValidation() || ValidateVertexAttrib4f(context, index, x, y, z, w));
22985 if (isCallValid)
22986 {
22987 context->vertexAttrib4f(index, x, y, z, w);
22988 }
22989 ANGLE_CAPTURE(VertexAttrib4f, isCallValid, context, index, x, y, z, w);
22990 }
22991 }
22992
VertexAttrib4fvContextANGLE(GLeglContext ctx,GLuint index,const GLfloat * v)22993 void GL_APIENTRY VertexAttrib4fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
22994 {
22995 Context *context = static_cast<gl::Context *>(ctx);
22996 EVENT("glVertexAttrib4fv",
22997 "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
22998 index, (uintptr_t)v);
22999
23000 if (context)
23001 {
23002 ASSERT(context == GetValidGlobalContext());
23003 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23004 bool isCallValid =
23005 (context->skipValidation() || ValidateVertexAttrib4fv(context, index, v));
23006 if (isCallValid)
23007 {
23008 context->vertexAttrib4fv(index, v);
23009 }
23010 ANGLE_CAPTURE(VertexAttrib4fv, isCallValid, context, index, v);
23011 }
23012 }
23013
VertexAttribBindingContextANGLE(GLeglContext ctx,GLuint attribindex,GLuint bindingindex)23014 void GL_APIENTRY VertexAttribBindingContextANGLE(GLeglContext ctx,
23015 GLuint attribindex,
23016 GLuint bindingindex)
23017 {
23018 Context *context = static_cast<gl::Context *>(ctx);
23019 EVENT("glVertexAttribBinding",
23020 "context = %d, GLuint attribindex = %u, GLuint bindingindex = %u", CID(context),
23021 attribindex, bindingindex);
23022
23023 if (context)
23024 {
23025 ASSERT(context == GetValidGlobalContext());
23026 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23027 bool isCallValid = (context->skipValidation() ||
23028 ValidateVertexAttribBinding(context, attribindex, bindingindex));
23029 if (isCallValid)
23030 {
23031 context->vertexAttribBinding(attribindex, bindingindex);
23032 }
23033 ANGLE_CAPTURE(VertexAttribBinding, isCallValid, context, attribindex, bindingindex);
23034 }
23035 }
23036
VertexAttribDivisorContextANGLE(GLeglContext ctx,GLuint index,GLuint divisor)23037 void GL_APIENTRY VertexAttribDivisorContextANGLE(GLeglContext ctx, GLuint index, GLuint divisor)
23038 {
23039 Context *context = static_cast<gl::Context *>(ctx);
23040 EVENT("glVertexAttribDivisor", "context = %d, GLuint index = %u, GLuint divisor = %u",
23041 CID(context), index, divisor);
23042
23043 if (context)
23044 {
23045 ASSERT(context == GetValidGlobalContext());
23046 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23047 bool isCallValid =
23048 (context->skipValidation() || ValidateVertexAttribDivisor(context, index, divisor));
23049 if (isCallValid)
23050 {
23051 context->vertexAttribDivisor(index, divisor);
23052 }
23053 ANGLE_CAPTURE(VertexAttribDivisor, isCallValid, context, index, divisor);
23054 }
23055 }
23056
VertexAttribDivisorANGLEContextANGLE(GLeglContext ctx,GLuint index,GLuint divisor)23057 void GL_APIENTRY VertexAttribDivisorANGLEContextANGLE(GLeglContext ctx,
23058 GLuint index,
23059 GLuint divisor)
23060 {
23061 Context *context = static_cast<gl::Context *>(ctx);
23062 EVENT("glVertexAttribDivisorANGLE", "context = %d, GLuint index = %u, GLuint divisor = %u",
23063 CID(context), index, divisor);
23064
23065 if (context)
23066 {
23067 ASSERT(context == GetValidGlobalContext());
23068 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23069 bool isCallValid = (context->skipValidation() ||
23070 ValidateVertexAttribDivisorANGLE(context, index, divisor));
23071 if (isCallValid)
23072 {
23073 context->vertexAttribDivisor(index, divisor);
23074 }
23075 ANGLE_CAPTURE(VertexAttribDivisorANGLE, isCallValid, context, index, divisor);
23076 }
23077 }
23078
VertexAttribDivisorEXTContextANGLE(GLeglContext ctx,GLuint index,GLuint divisor)23079 void GL_APIENTRY VertexAttribDivisorEXTContextANGLE(GLeglContext ctx, GLuint index, GLuint divisor)
23080 {
23081 Context *context = static_cast<gl::Context *>(ctx);
23082 EVENT("glVertexAttribDivisorEXT", "context = %d, GLuint index = %u, GLuint divisor = %u",
23083 CID(context), index, divisor);
23084
23085 if (context)
23086 {
23087 ASSERT(context == GetValidGlobalContext());
23088 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23089 bool isCallValid =
23090 (context->skipValidation() || ValidateVertexAttribDivisorEXT(context, index, divisor));
23091 if (isCallValid)
23092 {
23093 context->vertexAttribDivisor(index, divisor);
23094 }
23095 ANGLE_CAPTURE(VertexAttribDivisorEXT, isCallValid, context, index, divisor);
23096 }
23097 }
23098
VertexAttribFormatContextANGLE(GLeglContext ctx,GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset)23099 void GL_APIENTRY VertexAttribFormatContextANGLE(GLeglContext ctx,
23100 GLuint attribindex,
23101 GLint size,
23102 GLenum type,
23103 GLboolean normalized,
23104 GLuint relativeoffset)
23105 {
23106 Context *context = static_cast<gl::Context *>(ctx);
23107 EVENT("glVertexAttribFormat",
23108 "context = %d, GLuint attribindex = %u, GLint size = %d, GLenum type = %s, GLboolean "
23109 "normalized = %s, GLuint relativeoffset = %u",
23110 CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type),
23111 GLbooleanToString(normalized), relativeoffset);
23112
23113 if (context)
23114 {
23115 ASSERT(context == GetValidGlobalContext());
23116 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
23117 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23118 bool isCallValid = (context->skipValidation() ||
23119 ValidateVertexAttribFormat(context, attribindex, size, typePacked,
23120 normalized, relativeoffset));
23121 if (isCallValid)
23122 {
23123 context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset);
23124 }
23125 ANGLE_CAPTURE(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked,
23126 normalized, relativeoffset);
23127 }
23128 }
23129
23130 void GL_APIENTRY
VertexAttribI4iContextANGLE(GLeglContext ctx,GLuint index,GLint x,GLint y,GLint z,GLint w)23131 VertexAttribI4iContextANGLE(GLeglContext ctx, GLuint index, GLint x, GLint y, GLint z, GLint w)
23132 {
23133 Context *context = static_cast<gl::Context *>(ctx);
23134 EVENT("glVertexAttribI4i",
23135 "context = %d, GLuint index = %u, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d",
23136 CID(context), index, x, y, z, w);
23137
23138 if (context)
23139 {
23140 ASSERT(context == GetValidGlobalContext());
23141 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23142 bool isCallValid =
23143 (context->skipValidation() || ValidateVertexAttribI4i(context, index, x, y, z, w));
23144 if (isCallValid)
23145 {
23146 context->vertexAttribI4i(index, x, y, z, w);
23147 }
23148 ANGLE_CAPTURE(VertexAttribI4i, isCallValid, context, index, x, y, z, w);
23149 }
23150 }
23151
VertexAttribI4ivContextANGLE(GLeglContext ctx,GLuint index,const GLint * v)23152 void GL_APIENTRY VertexAttribI4ivContextANGLE(GLeglContext ctx, GLuint index, const GLint *v)
23153 {
23154 Context *context = static_cast<gl::Context *>(ctx);
23155 EVENT("glVertexAttribI4iv",
23156 "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context),
23157 index, (uintptr_t)v);
23158
23159 if (context)
23160 {
23161 ASSERT(context == GetValidGlobalContext());
23162 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23163 bool isCallValid =
23164 (context->skipValidation() || ValidateVertexAttribI4iv(context, index, v));
23165 if (isCallValid)
23166 {
23167 context->vertexAttribI4iv(index, v);
23168 }
23169 ANGLE_CAPTURE(VertexAttribI4iv, isCallValid, context, index, v);
23170 }
23171 }
23172
23173 void GL_APIENTRY
VertexAttribI4uiContextANGLE(GLeglContext ctx,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)23174 VertexAttribI4uiContextANGLE(GLeglContext ctx, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
23175 {
23176 Context *context = static_cast<gl::Context *>(ctx);
23177 EVENT("glVertexAttribI4ui",
23178 "context = %d, GLuint index = %u, GLuint x = %u, GLuint y = %u, GLuint z = %u, GLuint w "
23179 "= %u",
23180 CID(context), index, x, y, z, w);
23181
23182 if (context)
23183 {
23184 ASSERT(context == GetValidGlobalContext());
23185 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23186 bool isCallValid =
23187 (context->skipValidation() || ValidateVertexAttribI4ui(context, index, x, y, z, w));
23188 if (isCallValid)
23189 {
23190 context->vertexAttribI4ui(index, x, y, z, w);
23191 }
23192 ANGLE_CAPTURE(VertexAttribI4ui, isCallValid, context, index, x, y, z, w);
23193 }
23194 }
23195
VertexAttribI4uivContextANGLE(GLeglContext ctx,GLuint index,const GLuint * v)23196 void GL_APIENTRY VertexAttribI4uivContextANGLE(GLeglContext ctx, GLuint index, const GLuint *v)
23197 {
23198 Context *context = static_cast<gl::Context *>(ctx);
23199 EVENT("glVertexAttribI4uiv",
23200 "context = %d, GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
23201 index, (uintptr_t)v);
23202
23203 if (context)
23204 {
23205 ASSERT(context == GetValidGlobalContext());
23206 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23207 bool isCallValid =
23208 (context->skipValidation() || ValidateVertexAttribI4uiv(context, index, v));
23209 if (isCallValid)
23210 {
23211 context->vertexAttribI4uiv(index, v);
23212 }
23213 ANGLE_CAPTURE(VertexAttribI4uiv, isCallValid, context, index, v);
23214 }
23215 }
23216
VertexAttribIFormatContextANGLE(GLeglContext ctx,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)23217 void GL_APIENTRY VertexAttribIFormatContextANGLE(GLeglContext ctx,
23218 GLuint attribindex,
23219 GLint size,
23220 GLenum type,
23221 GLuint relativeoffset)
23222 {
23223 Context *context = static_cast<gl::Context *>(ctx);
23224 EVENT("glVertexAttribIFormat",
23225 "context = %d, GLuint attribindex = %u, GLint size = %d, GLenum type = %s, GLuint "
23226 "relativeoffset = %u",
23227 CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type),
23228 relativeoffset);
23229
23230 if (context)
23231 {
23232 ASSERT(context == GetValidGlobalContext());
23233 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
23234 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23235 bool isCallValid =
23236 (context->skipValidation() ||
23237 ValidateVertexAttribIFormat(context, attribindex, size, typePacked, relativeoffset));
23238 if (isCallValid)
23239 {
23240 context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset);
23241 }
23242 ANGLE_CAPTURE(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked,
23243 relativeoffset);
23244 }
23245 }
23246
VertexAttribIPointerContextANGLE(GLeglContext ctx,GLuint index,GLint size,GLenum type,GLsizei stride,const void * pointer)23247 void GL_APIENTRY VertexAttribIPointerContextANGLE(GLeglContext ctx,
23248 GLuint index,
23249 GLint size,
23250 GLenum type,
23251 GLsizei stride,
23252 const void *pointer)
23253 {
23254 Context *context = static_cast<gl::Context *>(ctx);
23255 EVENT("glVertexAttribIPointer",
23256 "context = %d, GLuint index = %u, GLint size = %d, GLenum type = %s, GLsizei stride = "
23257 "%d, const void *pointer = 0x%016" PRIxPTR "",
23258 CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
23259 stride, (uintptr_t)pointer);
23260
23261 if (context)
23262 {
23263 ASSERT(context == GetValidGlobalContext());
23264 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
23265 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23266 bool isCallValid =
23267 (context->skipValidation() ||
23268 ValidateVertexAttribIPointer(context, index, size, typePacked, stride, pointer));
23269 if (isCallValid)
23270 {
23271 context->vertexAttribIPointer(index, size, typePacked, stride, pointer);
23272 }
23273 ANGLE_CAPTURE(VertexAttribIPointer, isCallValid, context, index, size, typePacked, stride,
23274 pointer);
23275 }
23276 }
23277
VertexAttribPointerContextANGLE(GLeglContext ctx,GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void * pointer)23278 void GL_APIENTRY VertexAttribPointerContextANGLE(GLeglContext ctx,
23279 GLuint index,
23280 GLint size,
23281 GLenum type,
23282 GLboolean normalized,
23283 GLsizei stride,
23284 const void *pointer)
23285 {
23286 Context *context = static_cast<gl::Context *>(ctx);
23287 EVENT("glVertexAttribPointer",
23288 "context = %d, GLuint index = %u, GLint size = %d, GLenum type = %s, GLboolean "
23289 "normalized = %s, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR "",
23290 CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type),
23291 GLbooleanToString(normalized), stride, (uintptr_t)pointer);
23292
23293 if (context)
23294 {
23295 ASSERT(context == GetValidGlobalContext());
23296 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
23297 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23298 bool isCallValid = (context->skipValidation() ||
23299 ValidateVertexAttribPointer(context, index, size, typePacked,
23300 normalized, stride, pointer));
23301 if (isCallValid)
23302 {
23303 context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
23304 }
23305 ANGLE_CAPTURE(VertexAttribPointer, isCallValid, context, index, size, typePacked,
23306 normalized, stride, pointer);
23307 }
23308 }
23309
VertexBindingDivisorContextANGLE(GLeglContext ctx,GLuint bindingindex,GLuint divisor)23310 void GL_APIENTRY VertexBindingDivisorContextANGLE(GLeglContext ctx,
23311 GLuint bindingindex,
23312 GLuint divisor)
23313 {
23314 Context *context = static_cast<gl::Context *>(ctx);
23315 EVENT("glVertexBindingDivisor", "context = %d, GLuint bindingindex = %u, GLuint divisor = %u",
23316 CID(context), bindingindex, divisor);
23317
23318 if (context)
23319 {
23320 ASSERT(context == GetValidGlobalContext());
23321 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23322 bool isCallValid = (context->skipValidation() ||
23323 ValidateVertexBindingDivisor(context, bindingindex, divisor));
23324 if (isCallValid)
23325 {
23326 context->vertexBindingDivisor(bindingindex, divisor);
23327 }
23328 ANGLE_CAPTURE(VertexBindingDivisor, isCallValid, context, bindingindex, divisor);
23329 }
23330 }
23331
VertexPointerContextANGLE(GLeglContext ctx,GLint size,GLenum type,GLsizei stride,const void * pointer)23332 void GL_APIENTRY VertexPointerContextANGLE(GLeglContext ctx,
23333 GLint size,
23334 GLenum type,
23335 GLsizei stride,
23336 const void *pointer)
23337 {
23338 Context *context = static_cast<gl::Context *>(ctx);
23339 EVENT("glVertexPointer",
23340 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
23341 "*pointer = 0x%016" PRIxPTR "",
23342 CID(context), size, GLenumToString(GLenumGroup::VertexPointerType, type), stride,
23343 (uintptr_t)pointer);
23344
23345 if (context)
23346 {
23347 ASSERT(context == GetValidGlobalContext());
23348 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
23349 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23350 bool isCallValid = (context->skipValidation() ||
23351 ValidateVertexPointer(context, size, typePacked, stride, pointer));
23352 if (isCallValid)
23353 {
23354 context->vertexPointer(size, typePacked, stride, pointer);
23355 }
23356 ANGLE_CAPTURE(VertexPointer, isCallValid, context, size, typePacked, stride, pointer);
23357 }
23358 }
23359
23360 void GL_APIENTRY
ViewportContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height)23361 ViewportContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
23362 {
23363 Context *context = static_cast<gl::Context *>(ctx);
23364 EVENT("glViewport",
23365 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d",
23366 CID(context), x, y, width, height);
23367
23368 if (context)
23369 {
23370 ASSERT(context == GetValidGlobalContext());
23371 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23372 bool isCallValid =
23373 (context->skipValidation() || ValidateViewport(context, x, y, width, height));
23374 if (isCallValid)
23375 {
23376 context->viewport(x, y, width, height);
23377 }
23378 ANGLE_CAPTURE(Viewport, isCallValid, context, x, y, width, height);
23379 }
23380 }
23381
WaitSemaphoreEXTContextANGLE(GLeglContext ctx,GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * srcLayouts)23382 void GL_APIENTRY WaitSemaphoreEXTContextANGLE(GLeglContext ctx,
23383 GLuint semaphore,
23384 GLuint numBufferBarriers,
23385 const GLuint *buffers,
23386 GLuint numTextureBarriers,
23387 const GLuint *textures,
23388 const GLenum *srcLayouts)
23389 {
23390 Context *context = static_cast<gl::Context *>(ctx);
23391 EVENT("glWaitSemaphoreEXT",
23392 "context = %d, GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint "
23393 "*buffers = 0x%016" PRIxPTR
23394 ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
23395 ", const GLenum *srcLayouts = 0x%016" PRIxPTR "",
23396 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
23397 (uintptr_t)textures, (uintptr_t)srcLayouts);
23398
23399 if (context)
23400 {
23401 ASSERT(context == GetValidGlobalContext());
23402 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
23403 const BufferID *buffersPacked = FromGL<const BufferID *>(buffers);
23404 const TextureID *texturesPacked = FromGL<const TextureID *>(textures);
23405 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23406 bool isCallValid =
23407 (context->skipValidation() ||
23408 ValidateWaitSemaphoreEXT(context, semaphorePacked, numBufferBarriers, buffersPacked,
23409 numTextureBarriers, texturesPacked, srcLayouts));
23410 if (isCallValid)
23411 {
23412 context->waitSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
23413 numTextureBarriers, texturesPacked, srcLayouts);
23414 }
23415 ANGLE_CAPTURE(WaitSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
23416 buffersPacked, numTextureBarriers, texturesPacked, srcLayouts);
23417 }
23418 }
23419
WaitSyncContextANGLE(GLeglContext ctx,GLsync sync,GLbitfield flags,GLuint64 timeout)23420 void GL_APIENTRY WaitSyncContextANGLE(GLeglContext ctx,
23421 GLsync sync,
23422 GLbitfield flags,
23423 GLuint64 timeout)
23424 {
23425 Context *context = static_cast<gl::Context *>(ctx);
23426 EVENT("glWaitSync",
23427 "context = %d, GLsync sync = 0x%016" PRIxPTR
23428 ", GLbitfield flags = %s, GLuint64 timeout = %llu",
23429 CID(context), (uintptr_t)sync,
23430 GLbitfieldToString(GLenumGroup::DefaultGroup, flags).c_str(),
23431 static_cast<unsigned long long>(timeout));
23432
23433 if (context)
23434 {
23435 ASSERT(context == GetValidGlobalContext());
23436 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23437 bool isCallValid =
23438 (context->skipValidation() || ValidateWaitSync(context, sync, flags, timeout));
23439 if (isCallValid)
23440 {
23441 context->waitSync(sync, flags, timeout);
23442 }
23443 ANGLE_CAPTURE(WaitSync, isCallValid, context, sync, flags, timeout);
23444 }
23445 }
23446
WeightPointerOESContextANGLE(GLeglContext ctx,GLint size,GLenum type,GLsizei stride,const void * pointer)23447 void GL_APIENTRY WeightPointerOESContextANGLE(GLeglContext ctx,
23448 GLint size,
23449 GLenum type,
23450 GLsizei stride,
23451 const void *pointer)
23452 {
23453 Context *context = static_cast<gl::Context *>(ctx);
23454 EVENT("glWeightPointerOES",
23455 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
23456 "*pointer = 0x%016" PRIxPTR "",
23457 CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
23458 (uintptr_t)pointer);
23459
23460 if (context)
23461 {
23462 ASSERT(context == GetValidGlobalContext());
23463 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23464 bool isCallValid = (context->skipValidation() ||
23465 ValidateWeightPointerOES(context, size, type, stride, pointer));
23466 if (isCallValid)
23467 {
23468 context->weightPointer(size, type, stride, pointer);
23469 }
23470 ANGLE_CAPTURE(WeightPointerOES, isCallValid, context, size, type, stride, pointer);
23471 }
23472 }
23473
BindUniformLocationCHROMIUMContextANGLE(GLeglContext ctx,GLuint program,GLint location,const GLchar * name)23474 void GL_APIENTRY BindUniformLocationCHROMIUMContextANGLE(GLeglContext ctx,
23475 GLuint program,
23476 GLint location,
23477 const GLchar *name)
23478 {
23479 Context *context = static_cast<gl::Context *>(ctx);
23480 EVENT("glBindUniformLocationCHROMIUM",
23481 "context = %d, GLuint program = %u, GLint location = %d, const GLchar* name = "
23482 "0x%016" PRIxPTR "",
23483 CID(context), program, location, (uintptr_t)name);
23484
23485 if (context)
23486 {
23487 ASSERT(context == GetValidGlobalContext());
23488 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
23489 UniformLocation locationPacked = FromGL<UniformLocation>(location);
23490 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23491 bool isCallValid =
23492 (context->skipValidation() ||
23493 ValidateBindUniformLocationCHROMIUM(context, programPacked, locationPacked, name));
23494 if (isCallValid)
23495 {
23496 context->bindUniformLocation(programPacked, locationPacked, name);
23497 }
23498 ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
23499 locationPacked, name);
23500 }
23501 }
23502
CoverageModulationCHROMIUMContextANGLE(GLeglContext ctx,GLenum components)23503 void GL_APIENTRY CoverageModulationCHROMIUMContextANGLE(GLeglContext ctx, GLenum components)
23504 {
23505 Context *context = static_cast<gl::Context *>(ctx);
23506 EVENT("glCoverageModulationCHROMIUM", "context = %d, GLenum components = %s", CID(context),
23507 GLenumToString(GLenumGroup::DefaultGroup, components));
23508
23509 if (context)
23510 {
23511 ASSERT(context == GetValidGlobalContext());
23512 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23513 bool isCallValid =
23514 (context->skipValidation() || ValidateCoverageModulationCHROMIUM(context, components));
23515 if (isCallValid)
23516 {
23517 context->coverageModulation(components);
23518 }
23519 ANGLE_CAPTURE(CoverageModulationCHROMIUM, isCallValid, context, components);
23520 }
23521 }
23522
CopyTextureCHROMIUMContextANGLE(GLeglContext ctx,GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)23523 void GL_APIENTRY CopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
23524 GLuint sourceId,
23525 GLint sourceLevel,
23526 GLenum destTarget,
23527 GLuint destId,
23528 GLint destLevel,
23529 GLint internalFormat,
23530 GLenum destType,
23531 GLboolean unpackFlipY,
23532 GLboolean unpackPremultiplyAlpha,
23533 GLboolean unpackUnmultiplyAlpha)
23534 {
23535 Context *context = static_cast<gl::Context *>(ctx);
23536 EVENT("glCopyTextureCHROMIUM",
23537 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
23538 "GLuint destId = %u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = "
23539 "%s, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = %s, GLboolean "
23540 "unpackUnmultiplyAlpha = %s",
23541 CID(context), sourceId, sourceLevel,
23542 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
23543 GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
23544 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
23545
23546 if (context)
23547 {
23548 ASSERT(context == GetValidGlobalContext());
23549 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
23550 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
23551 TextureID destIdPacked = FromGL<TextureID>(destId);
23552 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23553 bool isCallValid = (context->skipValidation() ||
23554 ValidateCopyTextureCHROMIUM(
23555 context, sourceIdPacked, sourceLevel, destTargetPacked,
23556 destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
23557 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
23558 if (isCallValid)
23559 {
23560 context->copyTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
23561 destLevel, internalFormat, destType, unpackFlipY,
23562 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
23563 }
23564 ANGLE_CAPTURE(CopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
23565 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
23566 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
23567 }
23568 }
23569
CopySubTextureCHROMIUMContextANGLE(GLeglContext ctx,GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint xoffset,GLint yoffset,GLint x,GLint y,GLint width,GLint height,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)23570 void GL_APIENTRY CopySubTextureCHROMIUMContextANGLE(GLeglContext ctx,
23571 GLuint sourceId,
23572 GLint sourceLevel,
23573 GLenum destTarget,
23574 GLuint destId,
23575 GLint destLevel,
23576 GLint xoffset,
23577 GLint yoffset,
23578 GLint x,
23579 GLint y,
23580 GLint width,
23581 GLint height,
23582 GLboolean unpackFlipY,
23583 GLboolean unpackPremultiplyAlpha,
23584 GLboolean unpackUnmultiplyAlpha)
23585 {
23586 Context *context = static_cast<gl::Context *>(ctx);
23587 EVENT("glCopySubTextureCHROMIUM",
23588 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
23589 "GLuint destId = %u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
23590 "x = %d, GLint y = %d, GLint width = %d, GLint height = %d, GLboolean unpackFlipY = %s, "
23591 "GLboolean unpackPremultiplyAlpha = %s, GLboolean unpackUnmultiplyAlpha = %s",
23592 CID(context), sourceId, sourceLevel,
23593 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
23594 yoffset, x, y, width, height, GLbooleanToString(unpackFlipY),
23595 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
23596
23597 if (context)
23598 {
23599 ASSERT(context == GetValidGlobalContext());
23600 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
23601 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
23602 TextureID destIdPacked = FromGL<TextureID>(destId);
23603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23604 bool isCallValid = (context->skipValidation() ||
23605 ValidateCopySubTextureCHROMIUM(
23606 context, sourceIdPacked, sourceLevel, destTargetPacked,
23607 destIdPacked, destLevel, xoffset, yoffset, x, y, width, height,
23608 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
23609 if (isCallValid)
23610 {
23611 context->copySubTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
23612 destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
23613 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
23614 }
23615 ANGLE_CAPTURE(CopySubTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
23616 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width,
23617 height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
23618 }
23619 }
23620
CompressedCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,GLuint sourceId,GLuint destId)23621 void GL_APIENTRY CompressedCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
23622 GLuint sourceId,
23623 GLuint destId)
23624 {
23625 Context *context = static_cast<gl::Context *>(ctx);
23626 EVENT("glCompressedCopyTextureCHROMIUM",
23627 "context = %d, GLuint sourceId = %u, GLuint destId = %u", CID(context), sourceId, destId);
23628
23629 if (context)
23630 {
23631 ASSERT(context == GetValidGlobalContext());
23632 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
23633 TextureID destIdPacked = FromGL<TextureID>(destId);
23634 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23635 bool isCallValid =
23636 (context->skipValidation() ||
23637 ValidateCompressedCopyTextureCHROMIUM(context, sourceIdPacked, destIdPacked));
23638 if (isCallValid)
23639 {
23640 context->compressedCopyTexture(sourceIdPacked, destIdPacked);
23641 }
23642 ANGLE_CAPTURE(CompressedCopyTextureCHROMIUM, isCallValid, context, sourceIdPacked,
23643 destIdPacked);
23644 }
23645 }
23646
RequestExtensionANGLEContextANGLE(GLeglContext ctx,const GLchar * name)23647 void GL_APIENTRY RequestExtensionANGLEContextANGLE(GLeglContext ctx, const GLchar *name)
23648 {
23649 Context *context = static_cast<gl::Context *>(ctx);
23650 EVENT("glRequestExtensionANGLE", "context = %d, const GLchar * name = 0x%016" PRIxPTR "",
23651 CID(context), (uintptr_t)name);
23652
23653 if (context)
23654 {
23655 ASSERT(context == GetValidGlobalContext());
23656 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23657 bool isCallValid =
23658 (context->skipValidation() || ValidateRequestExtensionANGLE(context, name));
23659 if (isCallValid)
23660 {
23661 context->requestExtension(name);
23662 }
23663 ANGLE_CAPTURE(RequestExtensionANGLE, isCallValid, context, name);
23664 }
23665 }
23666
DisableExtensionANGLEContextANGLE(GLeglContext ctx,const GLchar * name)23667 void GL_APIENTRY DisableExtensionANGLEContextANGLE(GLeglContext ctx, const GLchar *name)
23668 {
23669 Context *context = static_cast<gl::Context *>(ctx);
23670 EVENT("glDisableExtensionANGLE", "context = %d, const GLchar * name = 0x%016" PRIxPTR "",
23671 CID(context), (uintptr_t)name);
23672
23673 if (context)
23674 {
23675 ASSERT(context == GetValidGlobalContext());
23676 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23677 bool isCallValid =
23678 (context->skipValidation() || ValidateDisableExtensionANGLE(context, name));
23679 if (isCallValid)
23680 {
23681 context->disableExtension(name);
23682 }
23683 ANGLE_CAPTURE(DisableExtensionANGLE, isCallValid, context, name);
23684 }
23685 }
23686
GetBooleanvRobustANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)23687 void GL_APIENTRY GetBooleanvRobustANGLEContextANGLE(GLeglContext ctx,
23688 GLenum pname,
23689 GLsizei bufSize,
23690 GLsizei *length,
23691 GLboolean *params)
23692 {
23693 Context *context = static_cast<gl::Context *>(ctx);
23694 EVENT("glGetBooleanvRobustANGLE",
23695 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
23696 ", GLboolean * params = 0x%016" PRIxPTR "",
23697 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
23698 (uintptr_t)length, (uintptr_t)params);
23699
23700 if (context)
23701 {
23702 ASSERT(context == GetValidGlobalContext());
23703 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23704 bool isCallValid =
23705 (context->skipValidation() ||
23706 ValidateGetBooleanvRobustANGLE(context, pname, bufSize, length, params));
23707 if (isCallValid)
23708 {
23709 context->getBooleanvRobust(pname, bufSize, length, params);
23710 }
23711 ANGLE_CAPTURE(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
23712 }
23713 }
23714
GetBufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)23715 void GL_APIENTRY GetBufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
23716 GLenum target,
23717 GLenum pname,
23718 GLsizei bufSize,
23719 GLsizei *length,
23720 GLint *params)
23721 {
23722 Context *context = static_cast<gl::Context *>(ctx);
23723 EVENT("glGetBufferParameterivRobustANGLE",
23724 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
23725 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
23726 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
23727 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
23728 (uintptr_t)params);
23729
23730 if (context)
23731 {
23732 ASSERT(context == GetValidGlobalContext());
23733 BufferBinding targetPacked = FromGL<BufferBinding>(target);
23734 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23735 bool isCallValid = (context->skipValidation() ||
23736 ValidateGetBufferParameterivRobustANGLE(context, targetPacked, pname,
23737 bufSize, length, params));
23738 if (isCallValid)
23739 {
23740 context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
23741 }
23742 ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
23743 bufSize, length, params);
23744 }
23745 }
23746
GetFloatvRobustANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)23747 void GL_APIENTRY GetFloatvRobustANGLEContextANGLE(GLeglContext ctx,
23748 GLenum pname,
23749 GLsizei bufSize,
23750 GLsizei *length,
23751 GLfloat *params)
23752 {
23753 Context *context = static_cast<gl::Context *>(ctx);
23754 EVENT("glGetFloatvRobustANGLE",
23755 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
23756 ", GLfloat * params = 0x%016" PRIxPTR "",
23757 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
23758 (uintptr_t)length, (uintptr_t)params);
23759
23760 if (context)
23761 {
23762 ASSERT(context == GetValidGlobalContext());
23763 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23764 bool isCallValid = (context->skipValidation() ||
23765 ValidateGetFloatvRobustANGLE(context, pname, bufSize, length, params));
23766 if (isCallValid)
23767 {
23768 context->getFloatvRobust(pname, bufSize, length, params);
23769 }
23770 ANGLE_CAPTURE(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
23771 }
23772 }
23773
GetFramebufferAttachmentParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)23774 void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLEContextANGLE(GLeglContext ctx,
23775 GLenum target,
23776 GLenum attachment,
23777 GLenum pname,
23778 GLsizei bufSize,
23779 GLsizei *length,
23780 GLint *params)
23781 {
23782 Context *context = static_cast<gl::Context *>(ctx);
23783 EVENT("glGetFramebufferAttachmentParameterivRobustANGLE",
23784 "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLsizei "
23785 "bufSize = %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
23786 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
23787 GLenumToString(GLenumGroup::DefaultGroup, attachment),
23788 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
23789 (uintptr_t)params);
23790
23791 if (context)
23792 {
23793 ASSERT(context == GetValidGlobalContext());
23794 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23795 bool isCallValid = (context->skipValidation() ||
23796 ValidateGetFramebufferAttachmentParameterivRobustANGLE(
23797 context, target, attachment, pname, bufSize, length, params));
23798 if (isCallValid)
23799 {
23800 context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
23801 length, params);
23802 }
23803 ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context, target,
23804 attachment, pname, bufSize, length, params);
23805 }
23806 }
23807
GetIntegervRobustANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)23808 void GL_APIENTRY GetIntegervRobustANGLEContextANGLE(GLeglContext ctx,
23809 GLenum pname,
23810 GLsizei bufSize,
23811 GLsizei *length,
23812 GLint *data)
23813 {
23814 Context *context = static_cast<gl::Context *>(ctx);
23815 EVENT("glGetIntegervRobustANGLE",
23816 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
23817 ", GLint * data = 0x%016" PRIxPTR "",
23818 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
23819 (uintptr_t)length, (uintptr_t)data);
23820
23821 if (context)
23822 {
23823 ASSERT(context == GetValidGlobalContext());
23824 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23825 bool isCallValid = (context->skipValidation() ||
23826 ValidateGetIntegervRobustANGLE(context, pname, bufSize, length, data));
23827 if (isCallValid)
23828 {
23829 context->getIntegervRobust(pname, bufSize, length, data);
23830 }
23831 ANGLE_CAPTURE(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length, data);
23832 }
23833 }
23834
GetProgramivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)23835 void GL_APIENTRY GetProgramivRobustANGLEContextANGLE(GLeglContext ctx,
23836 GLuint program,
23837 GLenum pname,
23838 GLsizei bufSize,
23839 GLsizei *length,
23840 GLint *params)
23841 {
23842 Context *context = static_cast<gl::Context *>(ctx);
23843 EVENT("glGetProgramivRobustANGLE",
23844 "context = %d, GLuint program = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
23845 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
23846 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
23847 (uintptr_t)length, (uintptr_t)params);
23848
23849 if (context)
23850 {
23851 ASSERT(context == GetValidGlobalContext());
23852 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
23853 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23854 bool isCallValid = (context->skipValidation() ||
23855 ValidateGetProgramivRobustANGLE(context, programPacked, pname, bufSize,
23856 length, params));
23857 if (isCallValid)
23858 {
23859 context->getProgramivRobust(programPacked, pname, bufSize, length, params);
23860 }
23861 ANGLE_CAPTURE(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname, bufSize,
23862 length, params);
23863 }
23864 }
23865
GetRenderbufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)23866 void GL_APIENTRY GetRenderbufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
23867 GLenum target,
23868 GLenum pname,
23869 GLsizei bufSize,
23870 GLsizei *length,
23871 GLint *params)
23872 {
23873 Context *context = static_cast<gl::Context *>(ctx);
23874 EVENT("glGetRenderbufferParameterivRobustANGLE",
23875 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
23876 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
23877 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
23878 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
23879 (uintptr_t)params);
23880
23881 if (context)
23882 {
23883 ASSERT(context == GetValidGlobalContext());
23884 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23885 bool isCallValid =
23886 (context->skipValidation() || ValidateGetRenderbufferParameterivRobustANGLE(
23887 context, target, pname, bufSize, length, params));
23888 if (isCallValid)
23889 {
23890 context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
23891 }
23892 ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname,
23893 bufSize, length, params);
23894 }
23895 }
23896
GetShaderivRobustANGLEContextANGLE(GLeglContext ctx,GLuint shader,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)23897 void GL_APIENTRY GetShaderivRobustANGLEContextANGLE(GLeglContext ctx,
23898 GLuint shader,
23899 GLenum pname,
23900 GLsizei bufSize,
23901 GLsizei *length,
23902 GLint *params)
23903 {
23904 Context *context = static_cast<gl::Context *>(ctx);
23905 EVENT("glGetShaderivRobustANGLE",
23906 "context = %d, GLuint shader = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
23907 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
23908 CID(context), shader, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
23909 (uintptr_t)length, (uintptr_t)params);
23910
23911 if (context)
23912 {
23913 ASSERT(context == GetValidGlobalContext());
23914 ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader);
23915 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23916 bool isCallValid =
23917 (context->skipValidation() ||
23918 ValidateGetShaderivRobustANGLE(context, shaderPacked, pname, bufSize, length, params));
23919 if (isCallValid)
23920 {
23921 context->getShaderivRobust(shaderPacked, pname, bufSize, length, params);
23922 }
23923 ANGLE_CAPTURE(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize,
23924 length, params);
23925 }
23926 }
23927
GetTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)23928 void GL_APIENTRY GetTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
23929 GLenum target,
23930 GLenum pname,
23931 GLsizei bufSize,
23932 GLsizei *length,
23933 GLfloat *params)
23934 {
23935 Context *context = static_cast<gl::Context *>(ctx);
23936 EVENT("glGetTexParameterfvRobustANGLE",
23937 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
23938 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
23939 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
23940 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
23941 (uintptr_t)params);
23942
23943 if (context)
23944 {
23945 ASSERT(context == GetValidGlobalContext());
23946 TextureType targetPacked = FromGL<TextureType>(target);
23947 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23948 bool isCallValid = (context->skipValidation() ||
23949 ValidateGetTexParameterfvRobustANGLE(context, targetPacked, pname,
23950 bufSize, length, params));
23951 if (isCallValid)
23952 {
23953 context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
23954 }
23955 ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname,
23956 bufSize, length, params);
23957 }
23958 }
23959
GetTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)23960 void GL_APIENTRY GetTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
23961 GLenum target,
23962 GLenum pname,
23963 GLsizei bufSize,
23964 GLsizei *length,
23965 GLint *params)
23966 {
23967 Context *context = static_cast<gl::Context *>(ctx);
23968 EVENT("glGetTexParameterivRobustANGLE",
23969 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
23970 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
23971 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
23972 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
23973 (uintptr_t)params);
23974
23975 if (context)
23976 {
23977 ASSERT(context == GetValidGlobalContext());
23978 TextureType targetPacked = FromGL<TextureType>(target);
23979 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
23980 bool isCallValid = (context->skipValidation() ||
23981 ValidateGetTexParameterivRobustANGLE(context, targetPacked, pname,
23982 bufSize, length, params));
23983 if (isCallValid)
23984 {
23985 context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
23986 }
23987 ANGLE_CAPTURE(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
23988 bufSize, length, params);
23989 }
23990 }
23991
GetUniformfvRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)23992 void GL_APIENTRY GetUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
23993 GLuint program,
23994 GLint location,
23995 GLsizei bufSize,
23996 GLsizei *length,
23997 GLfloat *params)
23998 {
23999 Context *context = static_cast<gl::Context *>(ctx);
24000 EVENT("glGetUniformfvRobustANGLE",
24001 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
24002 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
24003 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
24004
24005 if (context)
24006 {
24007 ASSERT(context == GetValidGlobalContext());
24008 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
24009 UniformLocation locationPacked = FromGL<UniformLocation>(location);
24010 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24011 bool isCallValid = (context->skipValidation() ||
24012 ValidateGetUniformfvRobustANGLE(context, programPacked, locationPacked,
24013 bufSize, length, params));
24014 if (isCallValid)
24015 {
24016 context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
24017 }
24018 ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
24019 bufSize, length, params);
24020 }
24021 }
24022
GetUniformivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)24023 void GL_APIENTRY GetUniformivRobustANGLEContextANGLE(GLeglContext ctx,
24024 GLuint program,
24025 GLint location,
24026 GLsizei bufSize,
24027 GLsizei *length,
24028 GLint *params)
24029 {
24030 Context *context = static_cast<gl::Context *>(ctx);
24031 EVENT("glGetUniformivRobustANGLE",
24032 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
24033 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
24034 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
24035
24036 if (context)
24037 {
24038 ASSERT(context == GetValidGlobalContext());
24039 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
24040 UniformLocation locationPacked = FromGL<UniformLocation>(location);
24041 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24042 bool isCallValid = (context->skipValidation() ||
24043 ValidateGetUniformivRobustANGLE(context, programPacked, locationPacked,
24044 bufSize, length, params));
24045 if (isCallValid)
24046 {
24047 context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
24048 }
24049 ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
24050 bufSize, length, params);
24051 }
24052 }
24053
GetVertexAttribfvRobustANGLEContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)24054 void GL_APIENTRY GetVertexAttribfvRobustANGLEContextANGLE(GLeglContext ctx,
24055 GLuint index,
24056 GLenum pname,
24057 GLsizei bufSize,
24058 GLsizei *length,
24059 GLfloat *params)
24060 {
24061 Context *context = static_cast<gl::Context *>(ctx);
24062 EVENT("glGetVertexAttribfvRobustANGLE",
24063 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24064 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
24065 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24066 (uintptr_t)length, (uintptr_t)params);
24067
24068 if (context)
24069 {
24070 ASSERT(context == GetValidGlobalContext());
24071 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24072 bool isCallValid =
24073 (context->skipValidation() ||
24074 ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, length, params));
24075 if (isCallValid)
24076 {
24077 context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
24078 }
24079 ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize,
24080 length, params);
24081 }
24082 }
24083
GetVertexAttribivRobustANGLEContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)24084 void GL_APIENTRY GetVertexAttribivRobustANGLEContextANGLE(GLeglContext ctx,
24085 GLuint index,
24086 GLenum pname,
24087 GLsizei bufSize,
24088 GLsizei *length,
24089 GLint *params)
24090 {
24091 Context *context = static_cast<gl::Context *>(ctx);
24092 EVENT("glGetVertexAttribivRobustANGLE",
24093 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24094 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
24095 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24096 (uintptr_t)length, (uintptr_t)params);
24097
24098 if (context)
24099 {
24100 ASSERT(context == GetValidGlobalContext());
24101 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24102 bool isCallValid =
24103 (context->skipValidation() ||
24104 ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, length, params));
24105 if (isCallValid)
24106 {
24107 context->getVertexAttribivRobust(index, pname, bufSize, length, params);
24108 }
24109 ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize,
24110 length, params);
24111 }
24112 }
24113
GetVertexAttribPointervRobustANGLEContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)24114 void GL_APIENTRY GetVertexAttribPointervRobustANGLEContextANGLE(GLeglContext ctx,
24115 GLuint index,
24116 GLenum pname,
24117 GLsizei bufSize,
24118 GLsizei *length,
24119 void **pointer)
24120 {
24121 Context *context = static_cast<gl::Context *>(ctx);
24122 EVENT("glGetVertexAttribPointervRobustANGLE",
24123 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24124 "length = 0x%016" PRIxPTR ", void ** pointer = 0x%016" PRIxPTR "",
24125 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24126 (uintptr_t)length, (uintptr_t)pointer);
24127
24128 if (context)
24129 {
24130 ASSERT(context == GetValidGlobalContext());
24131 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24132 bool isCallValid =
24133 (context->skipValidation() || ValidateGetVertexAttribPointervRobustANGLE(
24134 context, index, pname, bufSize, length, pointer));
24135 if (isCallValid)
24136 {
24137 context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
24138 }
24139 ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname,
24140 bufSize, length, pointer);
24141 }
24142 }
24143
ReadPixelsRobustANGLEContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * pixels)24144 void GL_APIENTRY ReadPixelsRobustANGLEContextANGLE(GLeglContext ctx,
24145 GLint x,
24146 GLint y,
24147 GLsizei width,
24148 GLsizei height,
24149 GLenum format,
24150 GLenum type,
24151 GLsizei bufSize,
24152 GLsizei *length,
24153 GLsizei *columns,
24154 GLsizei *rows,
24155 void *pixels)
24156 {
24157 Context *context = static_cast<gl::Context *>(ctx);
24158 EVENT(
24159 "glReadPixelsRobustANGLE",
24160 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum "
24161 "format = %s, GLenum type = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
24162 ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
24163 ", void * pixels = 0x%016" PRIxPTR "",
24164 CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
24165 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
24166 (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)pixels);
24167
24168 if (context)
24169 {
24170 ASSERT(context == GetValidGlobalContext());
24171 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24172 bool isCallValid =
24173 (context->skipValidation() ||
24174 ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
24175 length, columns, rows, pixels));
24176 if (isCallValid)
24177 {
24178 context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
24179 rows, pixels);
24180 }
24181 ANGLE_CAPTURE(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
24182 type, bufSize, length, columns, rows, pixels);
24183 }
24184 }
24185
TexImage2DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)24186 void GL_APIENTRY TexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
24187 GLenum target,
24188 GLint level,
24189 GLint internalformat,
24190 GLsizei width,
24191 GLsizei height,
24192 GLint border,
24193 GLenum format,
24194 GLenum type,
24195 GLsizei bufSize,
24196 const void *pixels)
24197 {
24198 Context *context = static_cast<gl::Context *>(ctx);
24199 EVENT("glTexImage2DRobustANGLE",
24200 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
24201 "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = "
24202 "%s, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR "",
24203 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
24204 width, height, border, GLenumToString(GLenumGroup::DefaultGroup, format),
24205 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
24206
24207 if (context)
24208 {
24209 ASSERT(context == GetValidGlobalContext());
24210 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24211 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24212 bool isCallValid =
24213 (context->skipValidation() ||
24214 ValidateTexImage2DRobustANGLE(context, targetPacked, level, internalformat, width,
24215 height, border, format, type, bufSize, pixels));
24216 if (isCallValid)
24217 {
24218 context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
24219 format, type, bufSize, pixels);
24220 }
24221 ANGLE_CAPTURE(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
24222 internalformat, width, height, border, format, type, bufSize, pixels);
24223 }
24224 }
24225
TexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,const GLfloat * params)24226 void GL_APIENTRY TexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
24227 GLenum target,
24228 GLenum pname,
24229 GLsizei bufSize,
24230 const GLfloat *params)
24231 {
24232 Context *context = static_cast<gl::Context *>(ctx);
24233 EVENT("glTexParameterfvRobustANGLE",
24234 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const "
24235 "GLfloat * params = 0x%016" PRIxPTR "",
24236 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
24237 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
24238
24239 if (context)
24240 {
24241 ASSERT(context == GetValidGlobalContext());
24242 TextureType targetPacked = FromGL<TextureType>(target);
24243 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24244 bool isCallValid =
24245 (context->skipValidation() ||
24246 ValidateTexParameterfvRobustANGLE(context, targetPacked, pname, bufSize, params));
24247 if (isCallValid)
24248 {
24249 context->texParameterfvRobust(targetPacked, pname, bufSize, params);
24250 }
24251 ANGLE_CAPTURE(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
24252 params);
24253 }
24254 }
24255
TexParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)24256 void GL_APIENTRY TexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
24257 GLenum target,
24258 GLenum pname,
24259 GLsizei bufSize,
24260 const GLint *params)
24261 {
24262 Context *context = static_cast<gl::Context *>(ctx);
24263 EVENT("glTexParameterivRobustANGLE",
24264 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLint "
24265 "* params = 0x%016" PRIxPTR "",
24266 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
24267 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
24268
24269 if (context)
24270 {
24271 ASSERT(context == GetValidGlobalContext());
24272 TextureType targetPacked = FromGL<TextureType>(target);
24273 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24274 bool isCallValid =
24275 (context->skipValidation() ||
24276 ValidateTexParameterivRobustANGLE(context, targetPacked, pname, bufSize, params));
24277 if (isCallValid)
24278 {
24279 context->texParameterivRobust(targetPacked, pname, bufSize, params);
24280 }
24281 ANGLE_CAPTURE(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
24282 params);
24283 }
24284 }
24285
TexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)24286 void GL_APIENTRY TexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
24287 GLenum target,
24288 GLint level,
24289 GLint xoffset,
24290 GLint yoffset,
24291 GLsizei width,
24292 GLsizei height,
24293 GLenum format,
24294 GLenum type,
24295 GLsizei bufSize,
24296 const void *pixels)
24297 {
24298 Context *context = static_cast<gl::Context *>(ctx);
24299 EVENT("glTexSubImage2DRobustANGLE",
24300 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
24301 "%d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLenum type = %s, "
24302 "GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR "",
24303 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
24304 width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
24305 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
24306
24307 if (context)
24308 {
24309 ASSERT(context == GetValidGlobalContext());
24310 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24311 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24312 bool isCallValid =
24313 (context->skipValidation() ||
24314 ValidateTexSubImage2DRobustANGLE(context, targetPacked, level, xoffset, yoffset, width,
24315 height, format, type, bufSize, pixels));
24316 if (isCallValid)
24317 {
24318 context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
24319 format, type, bufSize, pixels);
24320 }
24321 ANGLE_CAPTURE(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
24322 yoffset, width, height, format, type, bufSize, pixels);
24323 }
24324 }
24325
TexImage3DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)24326 void GL_APIENTRY TexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
24327 GLenum target,
24328 GLint level,
24329 GLint internalformat,
24330 GLsizei width,
24331 GLsizei height,
24332 GLsizei depth,
24333 GLint border,
24334 GLenum format,
24335 GLenum type,
24336 GLsizei bufSize,
24337 const void *pixels)
24338 {
24339 Context *context = static_cast<gl::Context *>(ctx);
24340 EVENT("glTexImage3DRobustANGLE",
24341 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
24342 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = "
24343 "%s, GLenum type = %s, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR "",
24344 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
24345 width, height, depth, border, GLenumToString(GLenumGroup::DefaultGroup, format),
24346 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
24347
24348 if (context)
24349 {
24350 ASSERT(context == GetValidGlobalContext());
24351 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24352 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24353 bool isCallValid =
24354 (context->skipValidation() ||
24355 ValidateTexImage3DRobustANGLE(context, targetPacked, level, internalformat, width,
24356 height, depth, border, format, type, bufSize, pixels));
24357 if (isCallValid)
24358 {
24359 context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
24360 border, format, type, bufSize, pixels);
24361 }
24362 ANGLE_CAPTURE(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
24363 internalformat, width, height, depth, border, format, type, bufSize, pixels);
24364 }
24365 }
24366
TexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)24367 void GL_APIENTRY TexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
24368 GLenum target,
24369 GLint level,
24370 GLint xoffset,
24371 GLint yoffset,
24372 GLint zoffset,
24373 GLsizei width,
24374 GLsizei height,
24375 GLsizei depth,
24376 GLenum format,
24377 GLenum type,
24378 GLsizei bufSize,
24379 const void *pixels)
24380 {
24381 Context *context = static_cast<gl::Context *>(ctx);
24382 EVENT("glTexSubImage3DRobustANGLE",
24383 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
24384 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
24385 "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, const void * pixels = "
24386 "0x%016" PRIxPTR "",
24387 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
24388 zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
24389 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
24390
24391 if (context)
24392 {
24393 ASSERT(context == GetValidGlobalContext());
24394 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24395 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24396 bool isCallValid = (context->skipValidation() ||
24397 ValidateTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset,
24398 yoffset, zoffset, width, height, depth,
24399 format, type, bufSize, pixels));
24400 if (isCallValid)
24401 {
24402 context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
24403 height, depth, format, type, bufSize, pixels);
24404 }
24405 ANGLE_CAPTURE(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
24406 yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
24407 }
24408 }
24409
CompressedTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)24410 void GL_APIENTRY CompressedTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
24411 GLenum target,
24412 GLint level,
24413 GLenum internalformat,
24414 GLsizei width,
24415 GLsizei height,
24416 GLint border,
24417 GLsizei imageSize,
24418 GLsizei dataSize,
24419 const GLvoid *data)
24420 {
24421 Context *context = static_cast<gl::Context *>(ctx);
24422 EVENT("glCompressedTexImage2DRobustANGLE",
24423 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
24424 "width = %d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, GLsizei "
24425 "dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "",
24426 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
24427 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, border,
24428 imageSize, dataSize, (uintptr_t)data);
24429
24430 if (context)
24431 {
24432 ASSERT(context == GetValidGlobalContext());
24433 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24434 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24435 bool isCallValid =
24436 (context->skipValidation() || ValidateCompressedTexImage2DRobustANGLE(
24437 context, targetPacked, level, internalformat, width,
24438 height, border, imageSize, dataSize, data));
24439 if (isCallValid)
24440 {
24441 context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
24442 border, imageSize, dataSize, data);
24443 }
24444 ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
24445 internalformat, width, height, border, imageSize, dataSize, data);
24446 }
24447 }
24448
CompressedTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLsizei xoffset,GLsizei yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)24449 void GL_APIENTRY CompressedTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
24450 GLenum target,
24451 GLint level,
24452 GLsizei xoffset,
24453 GLsizei yoffset,
24454 GLsizei width,
24455 GLsizei height,
24456 GLenum format,
24457 GLsizei imageSize,
24458 GLsizei dataSize,
24459 const GLvoid *data)
24460 {
24461 Context *context = static_cast<gl::Context *>(ctx);
24462 EVENT("glCompressedTexSubImage2DRobustANGLE",
24463 "context = %d, GLenum target = %s, GLint level = %d, GLsizei xoffset = %d, GLsizei "
24464 "yoffset = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLsizei "
24465 "imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "",
24466 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
24467 width, height, GLenumToString(GLenumGroup::DefaultGroup, format), imageSize, dataSize,
24468 (uintptr_t)data);
24469
24470 if (context)
24471 {
24472 ASSERT(context == GetValidGlobalContext());
24473 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24474 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24475 bool isCallValid =
24476 (context->skipValidation() || ValidateCompressedTexSubImage2DRobustANGLE(
24477 context, targetPacked, level, xoffset, yoffset, width,
24478 height, format, imageSize, dataSize, data));
24479 if (isCallValid)
24480 {
24481 context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
24482 height, format, imageSize, dataSize, data);
24483 }
24484 ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level,
24485 xoffset, yoffset, width, height, format, imageSize, dataSize, data);
24486 }
24487 }
24488
CompressedTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)24489 void GL_APIENTRY CompressedTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
24490 GLenum target,
24491 GLint level,
24492 GLenum internalformat,
24493 GLsizei width,
24494 GLsizei height,
24495 GLsizei depth,
24496 GLint border,
24497 GLsizei imageSize,
24498 GLsizei dataSize,
24499 const GLvoid *data)
24500 {
24501 Context *context = static_cast<gl::Context *>(ctx);
24502 EVENT("glCompressedTexImage3DRobustANGLE",
24503 "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei "
24504 "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei "
24505 "imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "",
24506 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
24507 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, depth, border,
24508 imageSize, dataSize, (uintptr_t)data);
24509
24510 if (context)
24511 {
24512 ASSERT(context == GetValidGlobalContext());
24513 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24514 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24515 bool isCallValid =
24516 (context->skipValidation() || ValidateCompressedTexImage3DRobustANGLE(
24517 context, targetPacked, level, internalformat, width,
24518 height, depth, border, imageSize, dataSize, data));
24519 if (isCallValid)
24520 {
24521 context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
24522 depth, border, imageSize, dataSize, data);
24523 }
24524 ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
24525 internalformat, width, height, depth, border, imageSize, dataSize, data);
24526 }
24527 }
24528
CompressedTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)24529 void GL_APIENTRY CompressedTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
24530 GLenum target,
24531 GLint level,
24532 GLint xoffset,
24533 GLint yoffset,
24534 GLint zoffset,
24535 GLsizei width,
24536 GLsizei height,
24537 GLsizei depth,
24538 GLenum format,
24539 GLsizei imageSize,
24540 GLsizei dataSize,
24541 const GLvoid *data)
24542 {
24543 Context *context = static_cast<gl::Context *>(ctx);
24544 EVENT("glCompressedTexSubImage3DRobustANGLE",
24545 "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
24546 "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
24547 "GLenum format = %s, GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid * data "
24548 "= 0x%016" PRIxPTR "",
24549 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
24550 zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
24551 imageSize, dataSize, (uintptr_t)data);
24552
24553 if (context)
24554 {
24555 ASSERT(context == GetValidGlobalContext());
24556 TextureTarget targetPacked = FromGL<TextureTarget>(target);
24557 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24558 bool isCallValid = (context->skipValidation() ||
24559 ValidateCompressedTexSubImage3DRobustANGLE(
24560 context, targetPacked, level, xoffset, yoffset, zoffset, width,
24561 height, depth, format, imageSize, dataSize, data));
24562 if (isCallValid)
24563 {
24564 context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
24565 width, height, depth, format, imageSize,
24566 dataSize, data);
24567 }
24568 ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level,
24569 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
24570 data);
24571 }
24572 }
24573
GetQueryivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)24574 void GL_APIENTRY GetQueryivRobustANGLEContextANGLE(GLeglContext ctx,
24575 GLenum target,
24576 GLenum pname,
24577 GLsizei bufSize,
24578 GLsizei *length,
24579 GLint *params)
24580 {
24581 Context *context = static_cast<gl::Context *>(ctx);
24582 EVENT("glGetQueryivRobustANGLE",
24583 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24584 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
24585 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
24586 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
24587 (uintptr_t)params);
24588
24589 if (context)
24590 {
24591 ASSERT(context == GetValidGlobalContext());
24592 QueryType targetPacked = FromGL<QueryType>(target);
24593 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24594 bool isCallValid =
24595 (context->skipValidation() ||
24596 ValidateGetQueryivRobustANGLE(context, targetPacked, pname, bufSize, length, params));
24597 if (isCallValid)
24598 {
24599 context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
24600 }
24601 ANGLE_CAPTURE(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
24602 length, params);
24603 }
24604 }
24605
GetQueryObjectuivRobustANGLEContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)24606 void GL_APIENTRY GetQueryObjectuivRobustANGLEContextANGLE(GLeglContext ctx,
24607 GLuint id,
24608 GLenum pname,
24609 GLsizei bufSize,
24610 GLsizei *length,
24611 GLuint *params)
24612 {
24613 Context *context = static_cast<gl::Context *>(ctx);
24614 EVENT("glGetQueryObjectuivRobustANGLE",
24615 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
24616 "= 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
24617 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24618 (uintptr_t)length, (uintptr_t)params);
24619
24620 if (context)
24621 {
24622 ASSERT(context == GetValidGlobalContext());
24623 QueryID idPacked = FromGL<QueryID>(id);
24624 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24625 bool isCallValid =
24626 (context->skipValidation() || ValidateGetQueryObjectuivRobustANGLE(
24627 context, idPacked, pname, bufSize, length, params));
24628 if (isCallValid)
24629 {
24630 context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params);
24631 }
24632 ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
24633 length, params);
24634 }
24635 }
24636
GetBufferPointervRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)24637 void GL_APIENTRY GetBufferPointervRobustANGLEContextANGLE(GLeglContext ctx,
24638 GLenum target,
24639 GLenum pname,
24640 GLsizei bufSize,
24641 GLsizei *length,
24642 void **params)
24643 {
24644 Context *context = static_cast<gl::Context *>(ctx);
24645 EVENT("glGetBufferPointervRobustANGLE",
24646 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24647 "length = 0x%016" PRIxPTR ", void ** params = 0x%016" PRIxPTR "",
24648 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
24649 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
24650 (uintptr_t)params);
24651
24652 if (context)
24653 {
24654 ASSERT(context == GetValidGlobalContext());
24655 BufferBinding targetPacked = FromGL<BufferBinding>(target);
24656 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24657 bool isCallValid = (context->skipValidation() ||
24658 ValidateGetBufferPointervRobustANGLE(context, targetPacked, pname,
24659 bufSize, length, params));
24660 if (isCallValid)
24661 {
24662 context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
24663 }
24664 ANGLE_CAPTURE(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname,
24665 bufSize, length, params);
24666 }
24667 }
24668
GetIntegeri_vRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)24669 void GL_APIENTRY GetIntegeri_vRobustANGLEContextANGLE(GLeglContext ctx,
24670 GLenum target,
24671 GLuint index,
24672 GLsizei bufSize,
24673 GLsizei *length,
24674 GLint *data)
24675 {
24676 Context *context = static_cast<gl::Context *>(ctx);
24677 EVENT("glGetIntegeri_vRobustANGLE",
24678 "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
24679 "length = 0x%016" PRIxPTR ", GLint * data = 0x%016" PRIxPTR "",
24680 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
24681 (uintptr_t)length, (uintptr_t)data);
24682
24683 if (context)
24684 {
24685 ASSERT(context == GetValidGlobalContext());
24686 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24687 bool isCallValid =
24688 (context->skipValidation() ||
24689 ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, length, data));
24690 if (isCallValid)
24691 {
24692 context->getIntegeri_vRobust(target, index, bufSize, length, data);
24693 }
24694 ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize,
24695 length, data);
24696 }
24697 }
24698
GetInternalformativRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)24699 void GL_APIENTRY GetInternalformativRobustANGLEContextANGLE(GLeglContext ctx,
24700 GLenum target,
24701 GLenum internalformat,
24702 GLenum pname,
24703 GLsizei bufSize,
24704 GLsizei *length,
24705 GLint *params)
24706 {
24707 Context *context = static_cast<gl::Context *>(ctx);
24708 EVENT("glGetInternalformativRobustANGLE",
24709 "context = %d, GLenum target = %s, GLenum internalformat = %s, GLenum pname = %s, "
24710 "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
24711 ", GLint * params = 0x%016" PRIxPTR "",
24712 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
24713 GLenumToString(GLenumGroup::DefaultGroup, internalformat),
24714 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
24715 (uintptr_t)params);
24716
24717 if (context)
24718 {
24719 ASSERT(context == GetValidGlobalContext());
24720 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24721 bool isCallValid = (context->skipValidation() ||
24722 ValidateGetInternalformativRobustANGLE(context, target, internalformat,
24723 pname, bufSize, length, params));
24724 if (isCallValid)
24725 {
24726 context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
24727 params);
24728 }
24729 ANGLE_CAPTURE(GetInternalformativRobustANGLE, isCallValid, context, target, internalformat,
24730 pname, bufSize, length, params);
24731 }
24732 }
24733
GetVertexAttribIivRobustANGLEContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)24734 void GL_APIENTRY GetVertexAttribIivRobustANGLEContextANGLE(GLeglContext ctx,
24735 GLuint index,
24736 GLenum pname,
24737 GLsizei bufSize,
24738 GLsizei *length,
24739 GLint *params)
24740 {
24741 Context *context = static_cast<gl::Context *>(ctx);
24742 EVENT("glGetVertexAttribIivRobustANGLE",
24743 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24744 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
24745 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24746 (uintptr_t)length, (uintptr_t)params);
24747
24748 if (context)
24749 {
24750 ASSERT(context == GetValidGlobalContext());
24751 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24752 bool isCallValid =
24753 (context->skipValidation() ||
24754 ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, length, params));
24755 if (isCallValid)
24756 {
24757 context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
24758 }
24759 ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize,
24760 length, params);
24761 }
24762 }
24763
GetVertexAttribIuivRobustANGLEContextANGLE(GLeglContext ctx,GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)24764 void GL_APIENTRY GetVertexAttribIuivRobustANGLEContextANGLE(GLeglContext ctx,
24765 GLuint index,
24766 GLenum pname,
24767 GLsizei bufSize,
24768 GLsizei *length,
24769 GLuint *params)
24770 {
24771 Context *context = static_cast<gl::Context *>(ctx);
24772 EVENT("glGetVertexAttribIuivRobustANGLE",
24773 "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24774 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
24775 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24776 (uintptr_t)length, (uintptr_t)params);
24777
24778 if (context)
24779 {
24780 ASSERT(context == GetValidGlobalContext());
24781 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24782 bool isCallValid =
24783 (context->skipValidation() || ValidateGetVertexAttribIuivRobustANGLE(
24784 context, index, pname, bufSize, length, params));
24785 if (isCallValid)
24786 {
24787 context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
24788 }
24789 ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname, bufSize,
24790 length, params);
24791 }
24792 }
24793
GetUniformuivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)24794 void GL_APIENTRY GetUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
24795 GLuint program,
24796 GLint location,
24797 GLsizei bufSize,
24798 GLsizei *length,
24799 GLuint *params)
24800 {
24801 Context *context = static_cast<gl::Context *>(ctx);
24802 EVENT("glGetUniformuivRobustANGLE",
24803 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
24804 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
24805 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
24806
24807 if (context)
24808 {
24809 ASSERT(context == GetValidGlobalContext());
24810 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
24811 UniformLocation locationPacked = FromGL<UniformLocation>(location);
24812 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24813 bool isCallValid = (context->skipValidation() ||
24814 ValidateGetUniformuivRobustANGLE(context, programPacked, locationPacked,
24815 bufSize, length, params));
24816 if (isCallValid)
24817 {
24818 context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
24819 }
24820 ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, locationPacked,
24821 bufSize, length, params);
24822 }
24823 }
24824
GetActiveUniformBlockivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)24825 void GL_APIENTRY GetActiveUniformBlockivRobustANGLEContextANGLE(GLeglContext ctx,
24826 GLuint program,
24827 GLuint uniformBlockIndex,
24828 GLenum pname,
24829 GLsizei bufSize,
24830 GLsizei *length,
24831 GLint *params)
24832 {
24833 Context *context = static_cast<gl::Context *>(ctx);
24834 EVENT("glGetActiveUniformBlockivRobustANGLE",
24835 "context = %d, GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = %s, "
24836 "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
24837 ", GLint * params = 0x%016" PRIxPTR "",
24838 CID(context), program, uniformBlockIndex,
24839 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
24840 (uintptr_t)params);
24841
24842 if (context)
24843 {
24844 ASSERT(context == GetValidGlobalContext());
24845 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
24846 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24847 bool isCallValid =
24848 (context->skipValidation() ||
24849 ValidateGetActiveUniformBlockivRobustANGLE(context, programPacked, uniformBlockIndex,
24850 pname, bufSize, length, params));
24851 if (isCallValid)
24852 {
24853 context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndex, pname, bufSize,
24854 length, params);
24855 }
24856 ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked,
24857 uniformBlockIndex, pname, bufSize, length, params);
24858 }
24859 }
24860
GetInteger64vRobustANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)24861 void GL_APIENTRY GetInteger64vRobustANGLEContextANGLE(GLeglContext ctx,
24862 GLenum pname,
24863 GLsizei bufSize,
24864 GLsizei *length,
24865 GLint64 *data)
24866 {
24867 Context *context = static_cast<gl::Context *>(ctx);
24868 EVENT("glGetInteger64vRobustANGLE",
24869 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
24870 ", GLint64 * data = 0x%016" PRIxPTR "",
24871 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24872 (uintptr_t)length, (uintptr_t)data);
24873
24874 if (context)
24875 {
24876 ASSERT(context == GetValidGlobalContext());
24877 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24878 bool isCallValid =
24879 (context->skipValidation() ||
24880 ValidateGetInteger64vRobustANGLE(context, pname, bufSize, length, data));
24881 if (isCallValid)
24882 {
24883 context->getInteger64vRobust(pname, bufSize, length, data);
24884 }
24885 ANGLE_CAPTURE(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length, data);
24886 }
24887 }
24888
GetInteger64i_vRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)24889 void GL_APIENTRY GetInteger64i_vRobustANGLEContextANGLE(GLeglContext ctx,
24890 GLenum target,
24891 GLuint index,
24892 GLsizei bufSize,
24893 GLsizei *length,
24894 GLint64 *data)
24895 {
24896 Context *context = static_cast<gl::Context *>(ctx);
24897 EVENT("glGetInteger64i_vRobustANGLE",
24898 "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
24899 "length = 0x%016" PRIxPTR ", GLint64 * data = 0x%016" PRIxPTR "",
24900 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
24901 (uintptr_t)length, (uintptr_t)data);
24902
24903 if (context)
24904 {
24905 ASSERT(context == GetValidGlobalContext());
24906 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24907 bool isCallValid =
24908 (context->skipValidation() ||
24909 ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, length, data));
24910 if (isCallValid)
24911 {
24912 context->getInteger64i_vRobust(target, index, bufSize, length, data);
24913 }
24914 ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize,
24915 length, data);
24916 }
24917 }
24918
GetBufferParameteri64vRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)24919 void GL_APIENTRY GetBufferParameteri64vRobustANGLEContextANGLE(GLeglContext ctx,
24920 GLenum target,
24921 GLenum pname,
24922 GLsizei bufSize,
24923 GLsizei *length,
24924 GLint64 *params)
24925 {
24926 Context *context = static_cast<gl::Context *>(ctx);
24927 EVENT("glGetBufferParameteri64vRobustANGLE",
24928 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
24929 "length = 0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR "",
24930 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
24931 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
24932 (uintptr_t)params);
24933
24934 if (context)
24935 {
24936 ASSERT(context == GetValidGlobalContext());
24937 BufferBinding targetPacked = FromGL<BufferBinding>(target);
24938 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24939 bool isCallValid = (context->skipValidation() ||
24940 ValidateGetBufferParameteri64vRobustANGLE(context, targetPacked, pname,
24941 bufSize, length, params));
24942 if (isCallValid)
24943 {
24944 context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
24945 }
24946 ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked, pname,
24947 bufSize, length, params);
24948 }
24949 }
24950
SamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLuint pname,GLsizei bufSize,const GLint * param)24951 void GL_APIENTRY SamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
24952 GLuint sampler,
24953 GLuint pname,
24954 GLsizei bufSize,
24955 const GLint *param)
24956 {
24957 Context *context = static_cast<gl::Context *>(ctx);
24958 EVENT("glSamplerParameterivRobustANGLE",
24959 "context = %d, GLuint sampler = %u, GLuint pname = %u, GLsizei bufSize = %d, const GLint "
24960 "* param = 0x%016" PRIxPTR "",
24961 CID(context), sampler, pname, bufSize, (uintptr_t)param);
24962
24963 if (context)
24964 {
24965 ASSERT(context == GetValidGlobalContext());
24966 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
24967 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24968 bool isCallValid =
24969 (context->skipValidation() ||
24970 ValidateSamplerParameterivRobustANGLE(context, samplerPacked, pname, bufSize, param));
24971 if (isCallValid)
24972 {
24973 context->samplerParameterivRobust(samplerPacked, pname, bufSize, param);
24974 }
24975 ANGLE_CAPTURE(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
24976 bufSize, param);
24977 }
24978 }
24979
SamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,const GLfloat * param)24980 void GL_APIENTRY SamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
24981 GLuint sampler,
24982 GLenum pname,
24983 GLsizei bufSize,
24984 const GLfloat *param)
24985 {
24986 Context *context = static_cast<gl::Context *>(ctx);
24987 EVENT("glSamplerParameterfvRobustANGLE",
24988 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const "
24989 "GLfloat * param = 0x%016" PRIxPTR "",
24990 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
24991 (uintptr_t)param);
24992
24993 if (context)
24994 {
24995 ASSERT(context == GetValidGlobalContext());
24996 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
24997 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
24998 bool isCallValid =
24999 (context->skipValidation() ||
25000 ValidateSamplerParameterfvRobustANGLE(context, samplerPacked, pname, bufSize, param));
25001 if (isCallValid)
25002 {
25003 context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param);
25004 }
25005 ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
25006 bufSize, param);
25007 }
25008 }
25009
GetSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25010 void GL_APIENTRY GetSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
25011 GLuint sampler,
25012 GLenum pname,
25013 GLsizei bufSize,
25014 GLsizei *length,
25015 GLint *params)
25016 {
25017 Context *context = static_cast<gl::Context *>(ctx);
25018 EVENT("glGetSamplerParameterivRobustANGLE",
25019 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25020 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25021 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25022 (uintptr_t)length, (uintptr_t)params);
25023
25024 if (context)
25025 {
25026 ASSERT(context == GetValidGlobalContext());
25027 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
25028 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25029 bool isCallValid = (context->skipValidation() ||
25030 ValidateGetSamplerParameterivRobustANGLE(context, samplerPacked, pname,
25031 bufSize, length, params));
25032 if (isCallValid)
25033 {
25034 context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params);
25035 }
25036 ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
25037 bufSize, length, params);
25038 }
25039 }
25040
GetSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)25041 void GL_APIENTRY GetSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
25042 GLuint sampler,
25043 GLenum pname,
25044 GLsizei bufSize,
25045 GLsizei *length,
25046 GLfloat *params)
25047 {
25048 Context *context = static_cast<gl::Context *>(ctx);
25049 EVENT("glGetSamplerParameterfvRobustANGLE",
25050 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25051 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
25052 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25053 (uintptr_t)length, (uintptr_t)params);
25054
25055 if (context)
25056 {
25057 ASSERT(context == GetValidGlobalContext());
25058 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
25059 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25060 bool isCallValid = (context->skipValidation() ||
25061 ValidateGetSamplerParameterfvRobustANGLE(context, samplerPacked, pname,
25062 bufSize, length, params));
25063 if (isCallValid)
25064 {
25065 context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params);
25066 }
25067 ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
25068 bufSize, length, params);
25069 }
25070 }
25071
GetFramebufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25072 void GL_APIENTRY GetFramebufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
25073 GLenum target,
25074 GLenum pname,
25075 GLsizei bufSize,
25076 GLsizei *length,
25077 GLint *params)
25078 {
25079 Context *context = static_cast<gl::Context *>(ctx);
25080 EVENT("glGetFramebufferParameterivRobustANGLE",
25081 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25082 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25083 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
25084 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
25085 (uintptr_t)params);
25086
25087 if (context)
25088 {
25089 ASSERT(context == GetValidGlobalContext());
25090 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25091 bool isCallValid =
25092 (context->skipValidation() || ValidateGetFramebufferParameterivRobustANGLE(
25093 context, target, pname, bufSize, length, params));
25094 if (isCallValid)
25095 {
25096 context->getFramebufferParameterivRobust(target, pname, bufSize, length, params);
25097 }
25098 ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname,
25099 bufSize, length, params);
25100 }
25101 }
25102
GetProgramInterfaceivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25103 void GL_APIENTRY GetProgramInterfaceivRobustANGLEContextANGLE(GLeglContext ctx,
25104 GLuint program,
25105 GLenum programInterface,
25106 GLenum pname,
25107 GLsizei bufSize,
25108 GLsizei *length,
25109 GLint *params)
25110 {
25111 Context *context = static_cast<gl::Context *>(ctx);
25112 EVENT("glGetProgramInterfaceivRobustANGLE",
25113 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLenum pname = %s, "
25114 "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
25115 ", GLint * params = 0x%016" PRIxPTR "",
25116 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, programInterface),
25117 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
25118 (uintptr_t)params);
25119
25120 if (context)
25121 {
25122 ASSERT(context == GetValidGlobalContext());
25123 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
25124 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25125 bool isCallValid =
25126 (context->skipValidation() ||
25127 ValidateGetProgramInterfaceivRobustANGLE(context, programPacked, programInterface,
25128 pname, bufSize, length, params));
25129 if (isCallValid)
25130 {
25131 context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize,
25132 length, params);
25133 }
25134 ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked,
25135 programInterface, pname, bufSize, length, params);
25136 }
25137 }
25138
GetBooleani_vRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)25139 void GL_APIENTRY GetBooleani_vRobustANGLEContextANGLE(GLeglContext ctx,
25140 GLenum target,
25141 GLuint index,
25142 GLsizei bufSize,
25143 GLsizei *length,
25144 GLboolean *data)
25145 {
25146 Context *context = static_cast<gl::Context *>(ctx);
25147 EVENT("glGetBooleani_vRobustANGLE",
25148 "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
25149 "length = 0x%016" PRIxPTR ", GLboolean * data = 0x%016" PRIxPTR "",
25150 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
25151 (uintptr_t)length, (uintptr_t)data);
25152
25153 if (context)
25154 {
25155 ASSERT(context == GetValidGlobalContext());
25156 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25157 bool isCallValid =
25158 (context->skipValidation() ||
25159 ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, length, data));
25160 if (isCallValid)
25161 {
25162 context->getBooleani_vRobust(target, index, bufSize, length, data);
25163 }
25164 ANGLE_CAPTURE(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize,
25165 length, data);
25166 }
25167 }
25168
GetMultisamplefvRobustANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)25169 void GL_APIENTRY GetMultisamplefvRobustANGLEContextANGLE(GLeglContext ctx,
25170 GLenum pname,
25171 GLuint index,
25172 GLsizei bufSize,
25173 GLsizei *length,
25174 GLfloat *val)
25175 {
25176 Context *context = static_cast<gl::Context *>(ctx);
25177 EVENT("glGetMultisamplefvRobustANGLE",
25178 "context = %d, GLenum pname = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * "
25179 "length = 0x%016" PRIxPTR ", GLfloat * val = 0x%016" PRIxPTR "",
25180 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, bufSize,
25181 (uintptr_t)length, (uintptr_t)val);
25182
25183 if (context)
25184 {
25185 ASSERT(context == GetValidGlobalContext());
25186 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25187 bool isCallValid =
25188 (context->skipValidation() ||
25189 ValidateGetMultisamplefvRobustANGLE(context, pname, index, bufSize, length, val));
25190 if (isCallValid)
25191 {
25192 context->getMultisamplefvRobust(pname, index, bufSize, length, val);
25193 }
25194 ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize,
25195 length, val);
25196 }
25197 }
25198
GetTexLevelParameterivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25199 void GL_APIENTRY GetTexLevelParameterivRobustANGLEContextANGLE(GLeglContext ctx,
25200 GLenum target,
25201 GLint level,
25202 GLenum pname,
25203 GLsizei bufSize,
25204 GLsizei *length,
25205 GLint *params)
25206 {
25207 Context *context = static_cast<gl::Context *>(ctx);
25208 EVENT("glGetTexLevelParameterivRobustANGLE",
25209 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLsizei bufSize "
25210 "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25211 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
25212 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
25213 (uintptr_t)params);
25214
25215 if (context)
25216 {
25217 ASSERT(context == GetValidGlobalContext());
25218 TextureTarget targetPacked = FromGL<TextureTarget>(target);
25219 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25220 bool isCallValid = (context->skipValidation() ||
25221 ValidateGetTexLevelParameterivRobustANGLE(
25222 context, targetPacked, level, pname, bufSize, length, params));
25223 if (isCallValid)
25224 {
25225 context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
25226 params);
25227 }
25228 ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked, level,
25229 pname, bufSize, length, params);
25230 }
25231 }
25232
GetTexLevelParameterfvRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)25233 void GL_APIENTRY GetTexLevelParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
25234 GLenum target,
25235 GLint level,
25236 GLenum pname,
25237 GLsizei bufSize,
25238 GLsizei *length,
25239 GLfloat *params)
25240 {
25241 Context *context = static_cast<gl::Context *>(ctx);
25242 EVENT("glGetTexLevelParameterfvRobustANGLE",
25243 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLsizei bufSize "
25244 "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
25245 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
25246 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
25247 (uintptr_t)params);
25248
25249 if (context)
25250 {
25251 ASSERT(context == GetValidGlobalContext());
25252 TextureTarget targetPacked = FromGL<TextureTarget>(target);
25253 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25254 bool isCallValid = (context->skipValidation() ||
25255 ValidateGetTexLevelParameterfvRobustANGLE(
25256 context, targetPacked, level, pname, bufSize, length, params));
25257 if (isCallValid)
25258 {
25259 context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
25260 params);
25261 }
25262 ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked, level,
25263 pname, bufSize, length, params);
25264 }
25265 }
25266
GetPointervRobustANGLERobustANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)25267 void GL_APIENTRY GetPointervRobustANGLERobustANGLEContextANGLE(GLeglContext ctx,
25268 GLenum pname,
25269 GLsizei bufSize,
25270 GLsizei *length,
25271 void **params)
25272 {
25273 Context *context = static_cast<gl::Context *>(ctx);
25274 EVENT("glGetPointervRobustANGLERobustANGLE",
25275 "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
25276 ", void ** params = 0x%016" PRIxPTR "",
25277 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25278 (uintptr_t)length, (uintptr_t)params);
25279
25280 if (context)
25281 {
25282 ASSERT(context == GetValidGlobalContext());
25283 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25284 bool isCallValid =
25285 (context->skipValidation() ||
25286 ValidateGetPointervRobustANGLERobustANGLE(context, pname, bufSize, length, params));
25287 if (isCallValid)
25288 {
25289 context->getPointervRobustANGLERobust(pname, bufSize, length, params);
25290 }
25291 ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize,
25292 length, params);
25293 }
25294 }
25295
ReadnPixelsRobustANGLEContextANGLE(GLeglContext ctx,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * data)25296 void GL_APIENTRY ReadnPixelsRobustANGLEContextANGLE(GLeglContext ctx,
25297 GLint x,
25298 GLint y,
25299 GLsizei width,
25300 GLsizei height,
25301 GLenum format,
25302 GLenum type,
25303 GLsizei bufSize,
25304 GLsizei *length,
25305 GLsizei *columns,
25306 GLsizei *rows,
25307 void *data)
25308 {
25309 Context *context = static_cast<gl::Context *>(ctx);
25310 EVENT(
25311 "glReadnPixelsRobustANGLE",
25312 "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum "
25313 "format = %s, GLenum type = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
25314 ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
25315 ", void * data = 0x%016" PRIxPTR "",
25316 CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
25317 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
25318 (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)data);
25319
25320 if (context)
25321 {
25322 ASSERT(context == GetValidGlobalContext());
25323 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25324 bool isCallValid =
25325 (context->skipValidation() ||
25326 ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
25327 length, columns, rows, data));
25328 if (isCallValid)
25329 {
25330 context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
25331 rows, data);
25332 }
25333 ANGLE_CAPTURE(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
25334 type, bufSize, length, columns, rows, data);
25335 }
25336 }
25337
GetnUniformfvRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)25338 void GL_APIENTRY GetnUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
25339 GLuint program,
25340 GLint location,
25341 GLsizei bufSize,
25342 GLsizei *length,
25343 GLfloat *params)
25344 {
25345 Context *context = static_cast<gl::Context *>(ctx);
25346 EVENT("glGetnUniformfvRobustANGLE",
25347 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
25348 "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "",
25349 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
25350
25351 if (context)
25352 {
25353 ASSERT(context == GetValidGlobalContext());
25354 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
25355 UniformLocation locationPacked = FromGL<UniformLocation>(location);
25356 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25357 bool isCallValid = (context->skipValidation() ||
25358 ValidateGetnUniformfvRobustANGLE(context, programPacked, locationPacked,
25359 bufSize, length, params));
25360 if (isCallValid)
25361 {
25362 context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
25363 }
25364 ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
25365 bufSize, length, params);
25366 }
25367 }
25368
GetnUniformivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)25369 void GL_APIENTRY GetnUniformivRobustANGLEContextANGLE(GLeglContext ctx,
25370 GLuint program,
25371 GLint location,
25372 GLsizei bufSize,
25373 GLsizei *length,
25374 GLint *params)
25375 {
25376 Context *context = static_cast<gl::Context *>(ctx);
25377 EVENT("glGetnUniformivRobustANGLE",
25378 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
25379 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25380 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
25381
25382 if (context)
25383 {
25384 ASSERT(context == GetValidGlobalContext());
25385 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
25386 UniformLocation locationPacked = FromGL<UniformLocation>(location);
25387 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25388 bool isCallValid = (context->skipValidation() ||
25389 ValidateGetnUniformivRobustANGLE(context, programPacked, locationPacked,
25390 bufSize, length, params));
25391 if (isCallValid)
25392 {
25393 context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
25394 }
25395 ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
25396 bufSize, length, params);
25397 }
25398 }
25399
GetnUniformuivRobustANGLEContextANGLE(GLeglContext ctx,GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)25400 void GL_APIENTRY GetnUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
25401 GLuint program,
25402 GLint location,
25403 GLsizei bufSize,
25404 GLsizei *length,
25405 GLuint *params)
25406 {
25407 Context *context = static_cast<gl::Context *>(ctx);
25408 EVENT("glGetnUniformuivRobustANGLE",
25409 "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * "
25410 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
25411 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
25412
25413 if (context)
25414 {
25415 ASSERT(context == GetValidGlobalContext());
25416 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
25417 UniformLocation locationPacked = FromGL<UniformLocation>(location);
25418 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25419 bool isCallValid = (context->skipValidation() ||
25420 ValidateGetnUniformuivRobustANGLE(
25421 context, programPacked, locationPacked, bufSize, length, params));
25422 if (isCallValid)
25423 {
25424 context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
25425 }
25426 ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
25427 locationPacked, bufSize, length, params);
25428 }
25429 }
25430
TexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)25431 void GL_APIENTRY TexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
25432 GLenum target,
25433 GLenum pname,
25434 GLsizei bufSize,
25435 const GLint *params)
25436 {
25437 Context *context = static_cast<gl::Context *>(ctx);
25438 EVENT("glTexParameterIivRobustANGLE",
25439 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLint "
25440 "* params = 0x%016" PRIxPTR "",
25441 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
25442 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
25443
25444 if (context)
25445 {
25446 ASSERT(context == GetValidGlobalContext());
25447 TextureType targetPacked = FromGL<TextureType>(target);
25448 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25449 bool isCallValid =
25450 (context->skipValidation() ||
25451 ValidateTexParameterIivRobustANGLE(context, targetPacked, pname, bufSize, params));
25452 if (isCallValid)
25453 {
25454 context->texParameterIivRobust(targetPacked, pname, bufSize, params);
25455 }
25456 ANGLE_CAPTURE(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
25457 bufSize, params);
25458 }
25459 }
25460
TexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,const GLuint * params)25461 void GL_APIENTRY TexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
25462 GLenum target,
25463 GLenum pname,
25464 GLsizei bufSize,
25465 const GLuint *params)
25466 {
25467 Context *context = static_cast<gl::Context *>(ctx);
25468 EVENT("glTexParameterIuivRobustANGLE",
25469 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLuint "
25470 "* params = 0x%016" PRIxPTR "",
25471 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
25472 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
25473
25474 if (context)
25475 {
25476 ASSERT(context == GetValidGlobalContext());
25477 TextureType targetPacked = FromGL<TextureType>(target);
25478 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25479 bool isCallValid =
25480 (context->skipValidation() ||
25481 ValidateTexParameterIuivRobustANGLE(context, targetPacked, pname, bufSize, params));
25482 if (isCallValid)
25483 {
25484 context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
25485 }
25486 ANGLE_CAPTURE(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
25487 bufSize, params);
25488 }
25489 }
25490
GetTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25491 void GL_APIENTRY GetTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
25492 GLenum target,
25493 GLenum pname,
25494 GLsizei bufSize,
25495 GLsizei *length,
25496 GLint *params)
25497 {
25498 Context *context = static_cast<gl::Context *>(ctx);
25499 EVENT("glGetTexParameterIivRobustANGLE",
25500 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25501 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25502 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
25503 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
25504 (uintptr_t)params);
25505
25506 if (context)
25507 {
25508 ASSERT(context == GetValidGlobalContext());
25509 TextureType targetPacked = FromGL<TextureType>(target);
25510 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25511 bool isCallValid = (context->skipValidation() ||
25512 ValidateGetTexParameterIivRobustANGLE(context, targetPacked, pname,
25513 bufSize, length, params));
25514 if (isCallValid)
25515 {
25516 context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
25517 }
25518 ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
25519 bufSize, length, params);
25520 }
25521 }
25522
GetTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)25523 void GL_APIENTRY GetTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
25524 GLenum target,
25525 GLenum pname,
25526 GLsizei bufSize,
25527 GLsizei *length,
25528 GLuint *params)
25529 {
25530 Context *context = static_cast<gl::Context *>(ctx);
25531 EVENT("glGetTexParameterIuivRobustANGLE",
25532 "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25533 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
25534 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
25535 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
25536 (uintptr_t)params);
25537
25538 if (context)
25539 {
25540 ASSERT(context == GetValidGlobalContext());
25541 TextureType targetPacked = FromGL<TextureType>(target);
25542 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25543 bool isCallValid = (context->skipValidation() ||
25544 ValidateGetTexParameterIuivRobustANGLE(context, targetPacked, pname,
25545 bufSize, length, params));
25546 if (isCallValid)
25547 {
25548 context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
25549 }
25550 ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
25551 bufSize, length, params);
25552 }
25553 }
25554
SamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,const GLint * param)25555 void GL_APIENTRY SamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
25556 GLuint sampler,
25557 GLenum pname,
25558 GLsizei bufSize,
25559 const GLint *param)
25560 {
25561 Context *context = static_cast<gl::Context *>(ctx);
25562 EVENT("glSamplerParameterIivRobustANGLE",
25563 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const GLint "
25564 "* param = 0x%016" PRIxPTR "",
25565 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25566 (uintptr_t)param);
25567
25568 if (context)
25569 {
25570 ASSERT(context == GetValidGlobalContext());
25571 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
25572 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25573 bool isCallValid =
25574 (context->skipValidation() ||
25575 ValidateSamplerParameterIivRobustANGLE(context, samplerPacked, pname, bufSize, param));
25576 if (isCallValid)
25577 {
25578 context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param);
25579 }
25580 ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
25581 bufSize, param);
25582 }
25583 }
25584
SamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,const GLuint * param)25585 void GL_APIENTRY SamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
25586 GLuint sampler,
25587 GLenum pname,
25588 GLsizei bufSize,
25589 const GLuint *param)
25590 {
25591 Context *context = static_cast<gl::Context *>(ctx);
25592 EVENT("glSamplerParameterIuivRobustANGLE",
25593 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const "
25594 "GLuint * param = 0x%016" PRIxPTR "",
25595 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25596 (uintptr_t)param);
25597
25598 if (context)
25599 {
25600 ASSERT(context == GetValidGlobalContext());
25601 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
25602 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25603 bool isCallValid =
25604 (context->skipValidation() || ValidateSamplerParameterIuivRobustANGLE(
25605 context, samplerPacked, pname, bufSize, param));
25606 if (isCallValid)
25607 {
25608 context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param);
25609 }
25610 ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, pname,
25611 bufSize, param);
25612 }
25613 }
25614
GetSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25615 void GL_APIENTRY GetSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
25616 GLuint sampler,
25617 GLenum pname,
25618 GLsizei bufSize,
25619 GLsizei *length,
25620 GLint *params)
25621 {
25622 Context *context = static_cast<gl::Context *>(ctx);
25623 EVENT("glGetSamplerParameterIivRobustANGLE",
25624 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25625 "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25626 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25627 (uintptr_t)length, (uintptr_t)params);
25628
25629 if (context)
25630 {
25631 ASSERT(context == GetValidGlobalContext());
25632 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
25633 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25634 bool isCallValid = (context->skipValidation() ||
25635 ValidateGetSamplerParameterIivRobustANGLE(context, samplerPacked, pname,
25636 bufSize, length, params));
25637 if (isCallValid)
25638 {
25639 context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params);
25640 }
25641 ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
25642 bufSize, length, params);
25643 }
25644 }
25645
GetSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)25646 void GL_APIENTRY GetSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
25647 GLuint sampler,
25648 GLenum pname,
25649 GLsizei bufSize,
25650 GLsizei *length,
25651 GLuint *params)
25652 {
25653 Context *context = static_cast<gl::Context *>(ctx);
25654 EVENT("glGetSamplerParameterIuivRobustANGLE",
25655 "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * "
25656 "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "",
25657 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25658 (uintptr_t)length, (uintptr_t)params);
25659
25660 if (context)
25661 {
25662 ASSERT(context == GetValidGlobalContext());
25663 SamplerID samplerPacked = FromGL<SamplerID>(sampler);
25664 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25665 bool isCallValid = (context->skipValidation() ||
25666 ValidateGetSamplerParameterIuivRobustANGLE(
25667 context, samplerPacked, pname, bufSize, length, params));
25668 if (isCallValid)
25669 {
25670 context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params);
25671 }
25672 ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked,
25673 pname, bufSize, length, params);
25674 }
25675 }
25676
GetQueryObjectivRobustANGLEContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)25677 void GL_APIENTRY GetQueryObjectivRobustANGLEContextANGLE(GLeglContext ctx,
25678 GLuint id,
25679 GLenum pname,
25680 GLsizei bufSize,
25681 GLsizei *length,
25682 GLint *params)
25683 {
25684 Context *context = static_cast<gl::Context *>(ctx);
25685 EVENT("glGetQueryObjectivRobustANGLE",
25686 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
25687 "= 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "",
25688 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25689 (uintptr_t)length, (uintptr_t)params);
25690
25691 if (context)
25692 {
25693 ASSERT(context == GetValidGlobalContext());
25694 QueryID idPacked = FromGL<QueryID>(id);
25695 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25696 bool isCallValid =
25697 (context->skipValidation() || ValidateGetQueryObjectivRobustANGLE(
25698 context, idPacked, pname, bufSize, length, params));
25699 if (isCallValid)
25700 {
25701 context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params);
25702 }
25703 ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
25704 length, params);
25705 }
25706 }
25707
GetQueryObjecti64vRobustANGLEContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)25708 void GL_APIENTRY GetQueryObjecti64vRobustANGLEContextANGLE(GLeglContext ctx,
25709 GLuint id,
25710 GLenum pname,
25711 GLsizei bufSize,
25712 GLsizei *length,
25713 GLint64 *params)
25714 {
25715 Context *context = static_cast<gl::Context *>(ctx);
25716 EVENT("glGetQueryObjecti64vRobustANGLE",
25717 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
25718 "= 0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR "",
25719 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25720 (uintptr_t)length, (uintptr_t)params);
25721
25722 if (context)
25723 {
25724 ASSERT(context == GetValidGlobalContext());
25725 QueryID idPacked = FromGL<QueryID>(id);
25726 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25727 bool isCallValid =
25728 (context->skipValidation() || ValidateGetQueryObjecti64vRobustANGLE(
25729 context, idPacked, pname, bufSize, length, params));
25730 if (isCallValid)
25731 {
25732 context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params);
25733 }
25734 ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
25735 length, params);
25736 }
25737 }
25738
GetQueryObjectui64vRobustANGLEContextANGLE(GLeglContext ctx,GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)25739 void GL_APIENTRY GetQueryObjectui64vRobustANGLEContextANGLE(GLeglContext ctx,
25740 GLuint id,
25741 GLenum pname,
25742 GLsizei bufSize,
25743 GLsizei *length,
25744 GLuint64 *params)
25745 {
25746 Context *context = static_cast<gl::Context *>(ctx);
25747 EVENT("glGetQueryObjectui64vRobustANGLE",
25748 "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length "
25749 "= 0x%016" PRIxPTR ", GLuint64 * params = 0x%016" PRIxPTR "",
25750 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
25751 (uintptr_t)length, (uintptr_t)params);
25752
25753 if (context)
25754 {
25755 ASSERT(context == GetValidGlobalContext());
25756 QueryID idPacked = FromGL<QueryID>(id);
25757 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25758 bool isCallValid =
25759 (context->skipValidation() || ValidateGetQueryObjectui64vRobustANGLE(
25760 context, idPacked, pname, bufSize, length, params));
25761 if (isCallValid)
25762 {
25763 context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params);
25764 }
25765 ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname,
25766 bufSize, length, params);
25767 }
25768 }
25769
CopyTexture3DANGLEContextANGLE(GLeglContext ctx,GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)25770 void GL_APIENTRY CopyTexture3DANGLEContextANGLE(GLeglContext ctx,
25771 GLuint sourceId,
25772 GLint sourceLevel,
25773 GLenum destTarget,
25774 GLuint destId,
25775 GLint destLevel,
25776 GLint internalFormat,
25777 GLenum destType,
25778 GLboolean unpackFlipY,
25779 GLboolean unpackPremultiplyAlpha,
25780 GLboolean unpackUnmultiplyAlpha)
25781 {
25782 Context *context = static_cast<gl::Context *>(ctx);
25783 EVENT("glCopyTexture3DANGLE",
25784 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
25785 "GLuint destId = %u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = "
25786 "%s, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = %s, GLboolean "
25787 "unpackUnmultiplyAlpha = %s",
25788 CID(context), sourceId, sourceLevel,
25789 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
25790 GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
25791 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
25792
25793 if (context)
25794 {
25795 ASSERT(context == GetValidGlobalContext());
25796 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
25797 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
25798 TextureID destIdPacked = FromGL<TextureID>(destId);
25799 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25800 bool isCallValid = (context->skipValidation() ||
25801 ValidateCopyTexture3DANGLE(
25802 context, sourceIdPacked, sourceLevel, destTargetPacked,
25803 destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
25804 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
25805 if (isCallValid)
25806 {
25807 context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
25808 destLevel, internalFormat, destType, unpackFlipY,
25809 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
25810 }
25811 ANGLE_CAPTURE(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
25812 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
25813 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
25814 }
25815 }
25816
CopySubTexture3DANGLEContextANGLE(GLeglContext ctx,GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLint z,GLint width,GLint height,GLint depth,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)25817 void GL_APIENTRY CopySubTexture3DANGLEContextANGLE(GLeglContext ctx,
25818 GLuint sourceId,
25819 GLint sourceLevel,
25820 GLenum destTarget,
25821 GLuint destId,
25822 GLint destLevel,
25823 GLint xoffset,
25824 GLint yoffset,
25825 GLint zoffset,
25826 GLint x,
25827 GLint y,
25828 GLint z,
25829 GLint width,
25830 GLint height,
25831 GLint depth,
25832 GLboolean unpackFlipY,
25833 GLboolean unpackPremultiplyAlpha,
25834 GLboolean unpackUnmultiplyAlpha)
25835 {
25836 Context *context = static_cast<gl::Context *>(ctx);
25837 EVENT("glCopySubTexture3DANGLE",
25838 "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, "
25839 "GLuint destId = %u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
25840 "zoffset = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height "
25841 "= %d, GLint depth = %d, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = "
25842 "%s, GLboolean unpackUnmultiplyAlpha = %s",
25843 CID(context), sourceId, sourceLevel,
25844 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
25845 yoffset, zoffset, x, y, z, width, height, depth, GLbooleanToString(unpackFlipY),
25846 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
25847
25848 if (context)
25849 {
25850 ASSERT(context == GetValidGlobalContext());
25851 TextureID sourceIdPacked = FromGL<TextureID>(sourceId);
25852 TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget);
25853 TextureID destIdPacked = FromGL<TextureID>(destId);
25854 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25855 bool isCallValid =
25856 (context->skipValidation() ||
25857 ValidateCopySubTexture3DANGLE(context, sourceIdPacked, sourceLevel, destTargetPacked,
25858 destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y,
25859 z, width, height, depth, unpackFlipY,
25860 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
25861 if (isCallValid)
25862 {
25863 context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
25864 destLevel, xoffset, yoffset, zoffset, x, y, z, width, height,
25865 depth, unpackFlipY, unpackPremultiplyAlpha,
25866 unpackUnmultiplyAlpha);
25867 }
25868 ANGLE_CAPTURE(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
25869 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z,
25870 width, height, depth, unpackFlipY, unpackPremultiplyAlpha,
25871 unpackUnmultiplyAlpha);
25872 }
25873 }
25874
TexStorage2DMultisampleANGLEContextANGLE(GLeglContext ctx,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)25875 void GL_APIENTRY TexStorage2DMultisampleANGLEContextANGLE(GLeglContext ctx,
25876 GLenum target,
25877 GLsizei samples,
25878 GLenum internalformat,
25879 GLsizei width,
25880 GLsizei height,
25881 GLboolean fixedsamplelocations)
25882 {
25883 Context *context = static_cast<gl::Context *>(ctx);
25884 EVENT("glTexStorage2DMultisampleANGLE",
25885 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
25886 "GLsizei width = %d, GLsizei height = %d, GLboolean fixedsamplelocations = %s",
25887 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), samples,
25888 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height,
25889 GLbooleanToString(fixedsamplelocations));
25890
25891 if (context)
25892 {
25893 ASSERT(context == GetValidGlobalContext());
25894 TextureType targetPacked = FromGL<TextureType>(target);
25895 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25896 bool isCallValid =
25897 (context->skipValidation() ||
25898 ValidateTexStorage2DMultisampleANGLE(context, targetPacked, samples, internalformat,
25899 width, height, fixedsamplelocations));
25900 if (isCallValid)
25901 {
25902 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
25903 fixedsamplelocations);
25904 }
25905 ANGLE_CAPTURE(TexStorage2DMultisampleANGLE, isCallValid, context, targetPacked, samples,
25906 internalformat, width, height, fixedsamplelocations);
25907 }
25908 }
25909
GetTexLevelParameterivANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum pname,GLint * params)25910 void GL_APIENTRY GetTexLevelParameterivANGLEContextANGLE(GLeglContext ctx,
25911 GLenum target,
25912 GLint level,
25913 GLenum pname,
25914 GLint *params)
25915 {
25916 Context *context = static_cast<gl::Context *>(ctx);
25917 EVENT("glGetTexLevelParameterivANGLE",
25918 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint * params = "
25919 "0x%016" PRIxPTR "",
25920 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
25921 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
25922
25923 if (context)
25924 {
25925 ASSERT(context == GetValidGlobalContext());
25926 TextureTarget targetPacked = FromGL<TextureTarget>(target);
25927 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25928 bool isCallValid =
25929 (context->skipValidation() ||
25930 ValidateGetTexLevelParameterivANGLE(context, targetPacked, level, pname, params));
25931 if (isCallValid)
25932 {
25933 context->getTexLevelParameteriv(targetPacked, level, pname, params);
25934 }
25935 ANGLE_CAPTURE(GetTexLevelParameterivANGLE, isCallValid, context, targetPacked, level, pname,
25936 params);
25937 }
25938 }
25939
GetTexLevelParameterfvANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum pname,GLfloat * params)25940 void GL_APIENTRY GetTexLevelParameterfvANGLEContextANGLE(GLeglContext ctx,
25941 GLenum target,
25942 GLint level,
25943 GLenum pname,
25944 GLfloat *params)
25945 {
25946 Context *context = static_cast<gl::Context *>(ctx);
25947 EVENT("glGetTexLevelParameterfvANGLE",
25948 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat * params "
25949 "= 0x%016" PRIxPTR "",
25950 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
25951 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
25952
25953 if (context)
25954 {
25955 ASSERT(context == GetValidGlobalContext());
25956 TextureTarget targetPacked = FromGL<TextureTarget>(target);
25957 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25958 bool isCallValid =
25959 (context->skipValidation() ||
25960 ValidateGetTexLevelParameterfvANGLE(context, targetPacked, level, pname, params));
25961 if (isCallValid)
25962 {
25963 context->getTexLevelParameterfv(targetPacked, level, pname, params);
25964 }
25965 ANGLE_CAPTURE(GetTexLevelParameterfvANGLE, isCallValid, context, targetPacked, level, pname,
25966 params);
25967 }
25968 }
25969
MultiDrawArraysANGLEContextANGLE(GLeglContext ctx,GLenum mode,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)25970 void GL_APIENTRY MultiDrawArraysANGLEContextANGLE(GLeglContext ctx,
25971 GLenum mode,
25972 const GLint *firsts,
25973 const GLsizei *counts,
25974 GLsizei drawcount)
25975 {
25976 Context *context = static_cast<gl::Context *>(ctx);
25977 EVENT("glMultiDrawArraysANGLE",
25978 "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR
25979 ", const GLsizei *counts = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
25980 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
25981 (uintptr_t)counts, drawcount);
25982
25983 if (context)
25984 {
25985 ASSERT(context == GetValidGlobalContext());
25986 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
25987 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
25988 bool isCallValid =
25989 (context->skipValidation() ||
25990 ValidateMultiDrawArraysANGLE(context, modePacked, firsts, counts, drawcount));
25991 if (isCallValid)
25992 {
25993 context->multiDrawArrays(modePacked, firsts, counts, drawcount);
25994 }
25995 ANGLE_CAPTURE(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts,
25996 drawcount);
25997 }
25998 }
25999
MultiDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)26000 void GL_APIENTRY MultiDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
26001 GLenum mode,
26002 const GLint *firsts,
26003 const GLsizei *counts,
26004 const GLsizei *instanceCounts,
26005 GLsizei drawcount)
26006 {
26007 Context *context = static_cast<gl::Context *>(ctx);
26008 EVENT("glMultiDrawArraysInstancedANGLE",
26009 "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR
26010 ", const GLsizei *counts = 0x%016" PRIxPTR
26011 ", const GLsizei *instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
26012 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
26013 (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
26014
26015 if (context)
26016 {
26017 ASSERT(context == GetValidGlobalContext());
26018 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26019 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26020 bool isCallValid = (context->skipValidation() ||
26021 ValidateMultiDrawArraysInstancedANGLE(
26022 context, modePacked, firsts, counts, instanceCounts, drawcount));
26023 if (isCallValid)
26024 {
26025 context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
26026 drawcount);
26027 }
26028 ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts,
26029 counts, instanceCounts, drawcount);
26030 }
26031 }
26032
MultiDrawElementsANGLEContextANGLE(GLeglContext ctx,GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,GLsizei drawcount)26033 void GL_APIENTRY MultiDrawElementsANGLEContextANGLE(GLeglContext ctx,
26034 GLenum mode,
26035 const GLsizei *counts,
26036 GLenum type,
26037 const GLvoid *const *indices,
26038 GLsizei drawcount)
26039 {
26040 Context *context = static_cast<gl::Context *>(ctx);
26041 EVENT("glMultiDrawElementsANGLE",
26042 "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR
26043 ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR
26044 ", GLsizei drawcount = %d",
26045 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
26046 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount);
26047
26048 if (context)
26049 {
26050 ASSERT(context == GetValidGlobalContext());
26051 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26052 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
26053 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26054 bool isCallValid = (context->skipValidation() ||
26055 ValidateMultiDrawElementsANGLE(context, modePacked, counts, typePacked,
26056 indices, drawcount));
26057 if (isCallValid)
26058 {
26059 context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
26060 }
26061 ANGLE_CAPTURE(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts, typePacked,
26062 indices, drawcount);
26063 }
26064 }
26065
MultiDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)26066 void GL_APIENTRY MultiDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
26067 GLenum mode,
26068 const GLsizei *counts,
26069 GLenum type,
26070 const GLvoid *const *indices,
26071 const GLsizei *instanceCounts,
26072 GLsizei drawcount)
26073 {
26074 Context *context = static_cast<gl::Context *>(ctx);
26075 EVENT("glMultiDrawElementsInstancedANGLE",
26076 "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR
26077 ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR
26078 ", const GLsizei*instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
26079 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
26080 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
26081 (uintptr_t)instanceCounts, drawcount);
26082
26083 if (context)
26084 {
26085 ASSERT(context == GetValidGlobalContext());
26086 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26087 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
26088 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26089 bool isCallValid =
26090 (context->skipValidation() ||
26091 ValidateMultiDrawElementsInstancedANGLE(context, modePacked, counts, typePacked,
26092 indices, instanceCounts, drawcount));
26093 if (isCallValid)
26094 {
26095 context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
26096 instanceCounts, drawcount);
26097 }
26098 ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts,
26099 typePacked, indices, instanceCounts, drawcount);
26100 }
26101 }
26102
DrawArraysInstancedBaseInstanceANGLEContextANGLE(GLeglContext ctx,GLenum mode,GLint first,GLsizei count,GLsizei instanceCount,GLuint baseInstance)26103 void GL_APIENTRY DrawArraysInstancedBaseInstanceANGLEContextANGLE(GLeglContext ctx,
26104 GLenum mode,
26105 GLint first,
26106 GLsizei count,
26107 GLsizei instanceCount,
26108 GLuint baseInstance)
26109 {
26110 Context *context = static_cast<gl::Context *>(ctx);
26111 EVENT("glDrawArraysInstancedBaseInstanceANGLE",
26112 "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei "
26113 "instanceCount = %d, GLuint baseInstance = %u",
26114 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count,
26115 instanceCount, baseInstance);
26116
26117 if (context)
26118 {
26119 ASSERT(context == GetValidGlobalContext());
26120 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26121 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26122 bool isCallValid = (context->skipValidation() ||
26123 ValidateDrawArraysInstancedBaseInstanceANGLE(
26124 context, modePacked, first, count, instanceCount, baseInstance));
26125 if (isCallValid)
26126 {
26127 context->drawArraysInstancedBaseInstance(modePacked, first, count, instanceCount,
26128 baseInstance);
26129 }
26130 ANGLE_CAPTURE(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, first,
26131 count, instanceCount, baseInstance);
26132 }
26133 }
26134
26135 void GL_APIENTRY
DrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(GLeglContext ctx,GLenum mode,GLsizei count,GLenum type,const GLvoid * indices,GLsizei instanceCounts,GLint baseVertex,GLuint baseInstance)26136 DrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(GLeglContext ctx,
26137 GLenum mode,
26138 GLsizei count,
26139 GLenum type,
26140 const GLvoid *indices,
26141 GLsizei instanceCounts,
26142 GLint baseVertex,
26143 GLuint baseInstance)
26144 {
26145 Context *context = static_cast<gl::Context *>(ctx);
26146 EVENT("glDrawElementsInstancedBaseVertexBaseInstanceANGLE",
26147 "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const GLvoid "
26148 "*indices = 0x%016" PRIxPTR
26149 ", GLsizei instanceCounts = %d, GLint baseVertex = %d, GLuint baseInstance = %u",
26150 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
26151 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instanceCounts,
26152 baseVertex, baseInstance);
26153
26154 if (context)
26155 {
26156 ASSERT(context == GetValidGlobalContext());
26157 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26158 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
26159 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26160 bool isCallValid =
26161 (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE(
26162 context, modePacked, count, typePacked, indices,
26163 instanceCounts, baseVertex, baseInstance));
26164 if (isCallValid)
26165 {
26166 context->drawElementsInstancedBaseVertexBaseInstance(
26167 modePacked, count, typePacked, indices, instanceCounts, baseVertex, baseInstance);
26168 }
26169 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
26170 modePacked, count, typePacked, indices, instanceCounts, baseVertex,
26171 baseInstance);
26172 }
26173 }
26174
26175 void GL_APIENTRY
MultiDrawArraysInstancedBaseInstanceANGLEContextANGLE(GLeglContext ctx,GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)26176 MultiDrawArraysInstancedBaseInstanceANGLEContextANGLE(GLeglContext ctx,
26177 GLenum mode,
26178 const GLint *firsts,
26179 const GLsizei *counts,
26180 const GLsizei *instanceCounts,
26181 const GLuint *baseInstances,
26182 GLsizei drawcount)
26183 {
26184 Context *context = static_cast<gl::Context *>(ctx);
26185 EVENT("glMultiDrawArraysInstancedBaseInstanceANGLE",
26186 "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR
26187 ", const GLsizei *counts = 0x%016" PRIxPTR
26188 ", const GLsizei *instanceCounts = 0x%016" PRIxPTR
26189 ", const GLuint *baseInstances = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
26190 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
26191 (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount);
26192
26193 if (context)
26194 {
26195 ASSERT(context == GetValidGlobalContext());
26196 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26197 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26198 bool isCallValid =
26199 (context->skipValidation() ||
26200 ValidateMultiDrawArraysInstancedBaseInstanceANGLE(
26201 context, modePacked, firsts, counts, instanceCounts, baseInstances, drawcount));
26202 if (isCallValid)
26203 {
26204 context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts,
26205 instanceCounts, baseInstances, drawcount);
26206 }
26207 ANGLE_CAPTURE(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked,
26208 firsts, counts, instanceCounts, baseInstances, drawcount);
26209 }
26210 }
26211
26212 void GL_APIENTRY
MultiDrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(GLeglContext ctx,GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,const GLsizei * instanceCounts,const GLint * baseVertices,const GLuint * baseInstances,GLsizei drawcount)26213 MultiDrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(GLeglContext ctx,
26214 GLenum mode,
26215 const GLsizei *counts,
26216 GLenum type,
26217 const GLvoid *const *indices,
26218 const GLsizei *instanceCounts,
26219 const GLint *baseVertices,
26220 const GLuint *baseInstances,
26221 GLsizei drawcount)
26222 {
26223 Context *context = static_cast<gl::Context *>(ctx);
26224 EVENT("glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE",
26225 "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR
26226 ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR
26227 ", const GLsizei *instanceCounts = 0x%016" PRIxPTR
26228 ", const GLint *baseVertices = 0x%016" PRIxPTR
26229 ", const GLuint *baseInstances = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
26230 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
26231 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
26232 (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount);
26233
26234 if (context)
26235 {
26236 ASSERT(context == GetValidGlobalContext());
26237 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
26238 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
26239 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26240 bool isCallValid = (context->skipValidation() ||
26241 ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
26242 context, modePacked, counts, typePacked, indices, instanceCounts,
26243 baseVertices, baseInstances, drawcount));
26244 if (isCallValid)
26245 {
26246 context->multiDrawElementsInstancedBaseVertexBaseInstance(
26247 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
26248 baseInstances, drawcount);
26249 }
26250 ANGLE_CAPTURE(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
26251 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
26252 baseInstances, drawcount);
26253 }
26254 }
26255
GetMultisamplefvANGLEContextANGLE(GLeglContext ctx,GLenum pname,GLuint index,GLfloat * val)26256 void GL_APIENTRY GetMultisamplefvANGLEContextANGLE(GLeglContext ctx,
26257 GLenum pname,
26258 GLuint index,
26259 GLfloat *val)
26260 {
26261 Context *context = static_cast<gl::Context *>(ctx);
26262 EVENT("glGetMultisamplefvANGLE",
26263 "context = %d, GLenum pname = %s, GLuint index = %u, GLfloat * val = 0x%016" PRIxPTR "",
26264 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
26265
26266 if (context)
26267 {
26268 ASSERT(context == GetValidGlobalContext());
26269 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26270 bool isCallValid = (context->skipValidation() ||
26271 ValidateGetMultisamplefvANGLE(context, pname, index, val));
26272 if (isCallValid)
26273 {
26274 context->getMultisamplefv(pname, index, val);
26275 }
26276 ANGLE_CAPTURE(GetMultisamplefvANGLE, isCallValid, context, pname, index, val);
26277 }
26278 }
26279
SampleMaskiANGLEContextANGLE(GLeglContext ctx,GLuint maskNumber,GLbitfield mask)26280 void GL_APIENTRY SampleMaskiANGLEContextANGLE(GLeglContext ctx, GLuint maskNumber, GLbitfield mask)
26281 {
26282 Context *context = static_cast<gl::Context *>(ctx);
26283 EVENT("glSampleMaskiANGLE", "context = %d, GLuint maskNumber = %u, GLbitfield mask = %s",
26284 CID(context), maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
26285
26286 if (context)
26287 {
26288 ASSERT(context == GetValidGlobalContext());
26289 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26290 bool isCallValid =
26291 (context->skipValidation() || ValidateSampleMaskiANGLE(context, maskNumber, mask));
26292 if (isCallValid)
26293 {
26294 context->sampleMaski(maskNumber, mask);
26295 }
26296 ANGLE_CAPTURE(SampleMaskiANGLE, isCallValid, context, maskNumber, mask);
26297 }
26298 }
26299
ProvokingVertexANGLEContextANGLE(GLeglContext ctx,GLenum mode)26300 void GL_APIENTRY ProvokingVertexANGLEContextANGLE(GLeglContext ctx, GLenum mode)
26301 {
26302 Context *context = static_cast<gl::Context *>(ctx);
26303 EVENT("glProvokingVertexANGLE", "context = %d, GLenum mode = %s", CID(context),
26304 GLenumToString(GLenumGroup::VertexProvokingMode, mode));
26305
26306 if (context)
26307 {
26308 ASSERT(context == GetValidGlobalContext());
26309 ProvokingVertexConvention modePacked = FromGL<ProvokingVertexConvention>(mode);
26310 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26311 bool isCallValid =
26312 (context->skipValidation() || ValidateProvokingVertexANGLE(context, modePacked));
26313 if (isCallValid)
26314 {
26315 context->provokingVertex(modePacked);
26316 }
26317 ANGLE_CAPTURE(ProvokingVertexANGLE, isCallValid, context, modePacked);
26318 }
26319 }
26320
LoseContextCHROMIUMContextANGLE(GLeglContext ctx,GLenum current,GLenum other)26321 void GL_APIENTRY LoseContextCHROMIUMContextANGLE(GLeglContext ctx, GLenum current, GLenum other)
26322 {
26323 Context *context = static_cast<gl::Context *>(ctx);
26324 EVENT("glLoseContextCHROMIUM", "context = %d, GLenum current = %s, GLenum other = %s",
26325 CID(context), GLenumToString(GLenumGroup::GraphicsResetStatus, current),
26326 GLenumToString(GLenumGroup::GraphicsResetStatus, other));
26327
26328 if (context)
26329 {
26330 ASSERT(context == GetValidGlobalContext());
26331 GraphicsResetStatus currentPacked = FromGL<GraphicsResetStatus>(current);
26332 GraphicsResetStatus otherPacked = FromGL<GraphicsResetStatus>(other);
26333 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26334 bool isCallValid = (context->skipValidation() ||
26335 ValidateLoseContextCHROMIUM(context, currentPacked, otherPacked));
26336 if (isCallValid)
26337 {
26338 context->loseContext(currentPacked, otherPacked);
26339 }
26340 ANGLE_CAPTURE(LoseContextCHROMIUM, isCallValid, context, currentPacked, otherPacked);
26341 }
26342 }
26343
TexImage2DExternalANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)26344 void GL_APIENTRY TexImage2DExternalANGLEContextANGLE(GLeglContext ctx,
26345 GLenum target,
26346 GLint level,
26347 GLint internalformat,
26348 GLsizei width,
26349 GLsizei height,
26350 GLint border,
26351 GLenum format,
26352 GLenum type)
26353 {
26354 Context *context = static_cast<gl::Context *>(ctx);
26355 EVENT(
26356 "glTexImage2DExternalANGLE",
26357 "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
26358 "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = %s",
26359 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
26360 width, height, border, GLenumToString(GLenumGroup::PixelFormat, format),
26361 GLenumToString(GLenumGroup::PixelType, type));
26362
26363 if (context)
26364 {
26365 ASSERT(context == GetValidGlobalContext());
26366 TextureTarget targetPacked = FromGL<TextureTarget>(target);
26367 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26368 bool isCallValid =
26369 (context->skipValidation() ||
26370 ValidateTexImage2DExternalANGLE(context, targetPacked, level, internalformat, width,
26371 height, border, format, type));
26372 if (isCallValid)
26373 {
26374 context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
26375 format, type);
26376 }
26377 ANGLE_CAPTURE(TexImage2DExternalANGLE, isCallValid, context, targetPacked, level,
26378 internalformat, width, height, border, format, type);
26379 }
26380 }
26381
InvalidateTextureANGLEContextANGLE(GLeglContext ctx,GLenum target)26382 void GL_APIENTRY InvalidateTextureANGLEContextANGLE(GLeglContext ctx, GLenum target)
26383 {
26384 Context *context = static_cast<gl::Context *>(ctx);
26385 EVENT("glInvalidateTextureANGLE", "context = %d, GLenum target = %s", CID(context),
26386 GLenumToString(GLenumGroup::TextureTarget, target));
26387
26388 if (context)
26389 {
26390 ASSERT(context == GetValidGlobalContext());
26391 TextureType targetPacked = FromGL<TextureType>(target);
26392 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26393 bool isCallValid =
26394 (context->skipValidation() || ValidateInvalidateTextureANGLE(context, targetPacked));
26395 if (isCallValid)
26396 {
26397 context->invalidateTexture(targetPacked);
26398 }
26399 ANGLE_CAPTURE(InvalidateTextureANGLE, isCallValid, context, targetPacked);
26400 }
26401 }
26402
GetTexImageANGLEContextANGLE(GLeglContext ctx,GLenum target,GLint level,GLenum format,GLenum type,void * pixels)26403 void GL_APIENTRY GetTexImageANGLEContextANGLE(GLeglContext ctx,
26404 GLenum target,
26405 GLint level,
26406 GLenum format,
26407 GLenum type,
26408 void *pixels)
26409 {
26410 Context *context = static_cast<gl::Context *>(ctx);
26411 EVENT("glGetTexImageANGLE",
26412 "context = %d, GLenum target = %s, GLint level = %d, GLenum format = %s, GLenum type = "
26413 "%s, void *pixels = 0x%016" PRIxPTR "",
26414 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
26415 GLenumToString(GLenumGroup::PixelFormat, format),
26416 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
26417
26418 if (context)
26419 {
26420 ASSERT(context == GetValidGlobalContext());
26421 TextureTarget targetPacked = FromGL<TextureTarget>(target);
26422 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26423 bool isCallValid =
26424 (context->skipValidation() ||
26425 ValidateGetTexImageANGLE(context, targetPacked, level, format, type, pixels));
26426 if (isCallValid)
26427 {
26428 context->getTexImage(targetPacked, level, format, type, pixels);
26429 }
26430 ANGLE_CAPTURE(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type,
26431 pixels);
26432 }
26433 }
26434
GetRenderbufferImageANGLEContextANGLE(GLeglContext ctx,GLenum target,GLenum format,GLenum type,void * pixels)26435 void GL_APIENTRY GetRenderbufferImageANGLEContextANGLE(GLeglContext ctx,
26436 GLenum target,
26437 GLenum format,
26438 GLenum type,
26439 void *pixels)
26440 {
26441 Context *context = static_cast<gl::Context *>(ctx);
26442 EVENT("glGetRenderbufferImageANGLE",
26443 "context = %d, GLenum target = %s, GLenum format = %s, GLenum type = %s, void *pixels = "
26444 "0x%016" PRIxPTR "",
26445 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
26446 GLenumToString(GLenumGroup::PixelFormat, format),
26447 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
26448
26449 if (context)
26450 {
26451 ASSERT(context == GetValidGlobalContext());
26452 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26453 bool isCallValid =
26454 (context->skipValidation() ||
26455 ValidateGetRenderbufferImageANGLE(context, target, format, type, pixels));
26456 if (isCallValid)
26457 {
26458 context->getRenderbufferImage(target, format, type, pixels);
26459 }
26460 ANGLE_CAPTURE(GetRenderbufferImageANGLE, isCallValid, context, target, format, type,
26461 pixels);
26462 }
26463 }
26464
ImportMemoryZirconHandleANGLEContextANGLE(GLeglContext ctx,GLuint memory,GLuint64 size,GLenum handleType,GLuint handle)26465 void GL_APIENTRY ImportMemoryZirconHandleANGLEContextANGLE(GLeglContext ctx,
26466 GLuint memory,
26467 GLuint64 size,
26468 GLenum handleType,
26469 GLuint handle)
26470 {
26471 Context *context = static_cast<gl::Context *>(ctx);
26472 EVENT("glImportMemoryZirconHandleANGLE",
26473 "context = %d, GLuint memory = %u, GLuint64 size = %llu, GLenum handleType = %s, GLuint "
26474 "handle = %u",
26475 CID(context), memory, static_cast<unsigned long long>(size),
26476 GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle);
26477
26478 if (context)
26479 {
26480 ASSERT(context == GetValidGlobalContext());
26481 MemoryObjectID memoryPacked = FromGL<MemoryObjectID>(memory);
26482 HandleType handleTypePacked = FromGL<HandleType>(handleType);
26483 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26484 bool isCallValid = (context->skipValidation() ||
26485 ValidateImportMemoryZirconHandleANGLE(context, memoryPacked, size,
26486 handleTypePacked, handle));
26487 if (isCallValid)
26488 {
26489 context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle);
26490 }
26491 ANGLE_CAPTURE(ImportMemoryZirconHandleANGLE, isCallValid, context, memoryPacked, size,
26492 handleTypePacked, handle);
26493 }
26494 }
26495
ImportSemaphoreZirconHandleANGLEContextANGLE(GLeglContext ctx,GLuint semaphore,GLenum handleType,GLuint handle)26496 void GL_APIENTRY ImportSemaphoreZirconHandleANGLEContextANGLE(GLeglContext ctx,
26497 GLuint semaphore,
26498 GLenum handleType,
26499 GLuint handle)
26500 {
26501 Context *context = static_cast<gl::Context *>(ctx);
26502 EVENT("glImportSemaphoreZirconHandleANGLE",
26503 "context = %d, GLuint semaphore = %u, GLenum handleType = %s, GLuint handle = %u",
26504 CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType),
26505 handle);
26506
26507 if (context)
26508 {
26509 ASSERT(context == GetValidGlobalContext());
26510 SemaphoreID semaphorePacked = FromGL<SemaphoreID>(semaphore);
26511 HandleType handleTypePacked = FromGL<HandleType>(handleType);
26512 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
26513 bool isCallValid =
26514 (context->skipValidation() || ValidateImportSemaphoreZirconHandleANGLE(
26515 context, semaphorePacked, handleTypePacked, handle));
26516 if (isCallValid)
26517 {
26518 context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle);
26519 }
26520 ANGLE_CAPTURE(ImportSemaphoreZirconHandleANGLE, isCallValid, context, semaphorePacked,
26521 handleTypePacked, handle);
26522 }
26523 }
26524 } // namespace gl
26525