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 "common/entry_points_enum_autogen.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/Context.inl.h"
16 #include "libANGLE/capture/capture_gles_ext_autogen.h"
17 #include "libANGLE/capture/gl_enum_utils.h"
18 #include "libANGLE/entry_points_utils.h"
19 #include "libANGLE/validationESEXT.h"
20 #include "libGLESv2/global_state.h"
21
22 using namespace gl;
23
24 #include "libANGLE/capture/capture_gles_1_0_autogen.h"
25 #include "libANGLE/capture/capture_gles_2_0_autogen.h"
26 #include "libANGLE/capture/capture_gles_3_0_autogen.h"
27 #include "libANGLE/capture/capture_gles_3_1_autogen.h"
28 #include "libANGLE/capture/capture_gles_3_2_autogen.h"
29 #include "libANGLE/validationES1.h"
30 #include "libANGLE/validationES2.h"
31 #include "libANGLE/validationES3.h"
32 #include "libANGLE/validationES31.h"
33 #include "libANGLE/validationES32.h"
34
35 using namespace gl;
36
37 extern "C" {
38
39 // GL_AMD_performance_monitor
GL_BeginPerfMonitorAMD(GLuint monitor)40 void GL_APIENTRY GL_BeginPerfMonitorAMD(GLuint monitor)
41 {
42 Context *context = GetValidGlobalContext();
43 EVENT(context, GLBeginPerfMonitorAMD, "context = %d, monitor = %u", CID(context), monitor);
44
45 if (context)
46 {
47 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
48 bool isCallValid = (context->skipValidation() ||
49 ValidateBeginPerfMonitorAMD(
50 context, angle::EntryPoint::GLBeginPerfMonitorAMD, monitor));
51 if (isCallValid)
52 {
53 context->beginPerfMonitor(monitor);
54 }
55 ANGLE_CAPTURE(BeginPerfMonitorAMD, isCallValid, context, monitor);
56 }
57 else
58 {
59 GenerateContextLostErrorOnCurrentGlobalContext();
60 }
61 }
62
GL_DeletePerfMonitorsAMD(GLsizei n,GLuint * monitors)63 void GL_APIENTRY GL_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
64 {
65 Context *context = GetValidGlobalContext();
66 EVENT(context, GLDeletePerfMonitorsAMD, "context = %d, n = %d, monitors = 0x%016" PRIxPTR "",
67 CID(context), n, (uintptr_t)monitors);
68
69 if (context)
70 {
71 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
72 bool isCallValid = (context->skipValidation() ||
73 ValidateDeletePerfMonitorsAMD(
74 context, angle::EntryPoint::GLDeletePerfMonitorsAMD, n, monitors));
75 if (isCallValid)
76 {
77 context->deletePerfMonitors(n, monitors);
78 }
79 ANGLE_CAPTURE(DeletePerfMonitorsAMD, isCallValid, context, n, monitors);
80 }
81 else
82 {
83 GenerateContextLostErrorOnCurrentGlobalContext();
84 }
85 }
86
GL_EndPerfMonitorAMD(GLuint monitor)87 void GL_APIENTRY GL_EndPerfMonitorAMD(GLuint monitor)
88 {
89 Context *context = GetValidGlobalContext();
90 EVENT(context, GLEndPerfMonitorAMD, "context = %d, monitor = %u", CID(context), monitor);
91
92 if (context)
93 {
94 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
95 bool isCallValid =
96 (context->skipValidation() ||
97 ValidateEndPerfMonitorAMD(context, angle::EntryPoint::GLEndPerfMonitorAMD, monitor));
98 if (isCallValid)
99 {
100 context->endPerfMonitor(monitor);
101 }
102 ANGLE_CAPTURE(EndPerfMonitorAMD, isCallValid, context, monitor);
103 }
104 else
105 {
106 GenerateContextLostErrorOnCurrentGlobalContext();
107 }
108 }
109
GL_GenPerfMonitorsAMD(GLsizei n,GLuint * monitors)110 void GL_APIENTRY GL_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
111 {
112 Context *context = GetValidGlobalContext();
113 EVENT(context, GLGenPerfMonitorsAMD, "context = %d, n = %d, monitors = 0x%016" PRIxPTR "",
114 CID(context), n, (uintptr_t)monitors);
115
116 if (context)
117 {
118 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
119 bool isCallValid = (context->skipValidation() ||
120 ValidateGenPerfMonitorsAMD(
121 context, angle::EntryPoint::GLGenPerfMonitorsAMD, n, monitors));
122 if (isCallValid)
123 {
124 context->genPerfMonitors(n, monitors);
125 }
126 ANGLE_CAPTURE(GenPerfMonitorsAMD, isCallValid, context, n, monitors);
127 }
128 else
129 {
130 GenerateContextLostErrorOnCurrentGlobalContext();
131 }
132 }
133
GL_GetPerfMonitorCounterDataAMD(GLuint monitor,GLenum pname,GLsizei dataSize,GLuint * data,GLint * bytesWritten)134 void GL_APIENTRY GL_GetPerfMonitorCounterDataAMD(GLuint monitor,
135 GLenum pname,
136 GLsizei dataSize,
137 GLuint *data,
138 GLint *bytesWritten)
139 {
140 Context *context = GetValidGlobalContext();
141 EVENT(context, GLGetPerfMonitorCounterDataAMD,
142 "context = %d, monitor = %u, pname = %s, dataSize = %d, data = 0x%016" PRIxPTR
143 ", bytesWritten = 0x%016" PRIxPTR "",
144 CID(context), monitor, GLenumToString(GLenumGroup::DefaultGroup, pname), dataSize,
145 (uintptr_t)data, (uintptr_t)bytesWritten);
146
147 if (context)
148 {
149 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
150 bool isCallValid = (context->skipValidation() ||
151 ValidateGetPerfMonitorCounterDataAMD(
152 context, angle::EntryPoint::GLGetPerfMonitorCounterDataAMD, monitor,
153 pname, dataSize, data, bytesWritten));
154 if (isCallValid)
155 {
156 context->getPerfMonitorCounterData(monitor, pname, dataSize, data, bytesWritten);
157 }
158 ANGLE_CAPTURE(GetPerfMonitorCounterDataAMD, isCallValid, context, monitor, pname, dataSize,
159 data, bytesWritten);
160 }
161 else
162 {
163 GenerateContextLostErrorOnCurrentGlobalContext();
164 }
165 }
166
GL_GetPerfMonitorCounterInfoAMD(GLuint group,GLuint counter,GLenum pname,void * data)167 void GL_APIENTRY GL_GetPerfMonitorCounterInfoAMD(GLuint group,
168 GLuint counter,
169 GLenum pname,
170 void *data)
171 {
172 Context *context = GetValidGlobalContext();
173 EVENT(context, GLGetPerfMonitorCounterInfoAMD,
174 "context = %d, group = %u, counter = %u, pname = %s, data = 0x%016" PRIxPTR "",
175 CID(context), group, counter, GLenumToString(GLenumGroup::DefaultGroup, pname),
176 (uintptr_t)data);
177
178 if (context)
179 {
180 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
181 bool isCallValid = (context->skipValidation() ||
182 ValidateGetPerfMonitorCounterInfoAMD(
183 context, angle::EntryPoint::GLGetPerfMonitorCounterInfoAMD, group,
184 counter, pname, data));
185 if (isCallValid)
186 {
187 context->getPerfMonitorCounterInfo(group, counter, pname, data);
188 }
189 ANGLE_CAPTURE(GetPerfMonitorCounterInfoAMD, isCallValid, context, group, counter, pname,
190 data);
191 }
192 else
193 {
194 GenerateContextLostErrorOnCurrentGlobalContext();
195 }
196 }
197
GL_GetPerfMonitorCounterStringAMD(GLuint group,GLuint counter,GLsizei bufSize,GLsizei * length,GLchar * counterString)198 void GL_APIENTRY GL_GetPerfMonitorCounterStringAMD(GLuint group,
199 GLuint counter,
200 GLsizei bufSize,
201 GLsizei *length,
202 GLchar *counterString)
203 {
204 Context *context = GetValidGlobalContext();
205 EVENT(context, GLGetPerfMonitorCounterStringAMD,
206 "context = %d, group = %u, counter = %u, bufSize = %d, length = 0x%016" PRIxPTR
207 ", counterString = 0x%016" PRIxPTR "",
208 CID(context), group, counter, bufSize, (uintptr_t)length, (uintptr_t)counterString);
209
210 if (context)
211 {
212 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
213 bool isCallValid = (context->skipValidation() ||
214 ValidateGetPerfMonitorCounterStringAMD(
215 context, angle::EntryPoint::GLGetPerfMonitorCounterStringAMD, group,
216 counter, bufSize, length, counterString));
217 if (isCallValid)
218 {
219 context->getPerfMonitorCounterString(group, counter, bufSize, length, counterString);
220 }
221 ANGLE_CAPTURE(GetPerfMonitorCounterStringAMD, isCallValid, context, group, counter, bufSize,
222 length, counterString);
223 }
224 else
225 {
226 GenerateContextLostErrorOnCurrentGlobalContext();
227 }
228 }
229
GL_GetPerfMonitorCountersAMD(GLuint group,GLint * numCounters,GLint * maxActiveCounters,GLsizei counterSize,GLuint * counters)230 void GL_APIENTRY GL_GetPerfMonitorCountersAMD(GLuint group,
231 GLint *numCounters,
232 GLint *maxActiveCounters,
233 GLsizei counterSize,
234 GLuint *counters)
235 {
236 Context *context = GetValidGlobalContext();
237 EVENT(context, GLGetPerfMonitorCountersAMD,
238 "context = %d, group = %u, numCounters = 0x%016" PRIxPTR
239 ", maxActiveCounters = 0x%016" PRIxPTR ", counterSize = %d, counters = 0x%016" PRIxPTR "",
240 CID(context), group, (uintptr_t)numCounters, (uintptr_t)maxActiveCounters, counterSize,
241 (uintptr_t)counters);
242
243 if (context)
244 {
245 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
246 bool isCallValid = (context->skipValidation() ||
247 ValidateGetPerfMonitorCountersAMD(
248 context, angle::EntryPoint::GLGetPerfMonitorCountersAMD, group,
249 numCounters, maxActiveCounters, counterSize, counters));
250 if (isCallValid)
251 {
252 context->getPerfMonitorCounters(group, numCounters, maxActiveCounters, counterSize,
253 counters);
254 }
255 ANGLE_CAPTURE(GetPerfMonitorCountersAMD, isCallValid, context, group, numCounters,
256 maxActiveCounters, counterSize, counters);
257 }
258 else
259 {
260 GenerateContextLostErrorOnCurrentGlobalContext();
261 }
262 }
263
GL_GetPerfMonitorGroupStringAMD(GLuint group,GLsizei bufSize,GLsizei * length,GLchar * groupString)264 void GL_APIENTRY GL_GetPerfMonitorGroupStringAMD(GLuint group,
265 GLsizei bufSize,
266 GLsizei *length,
267 GLchar *groupString)
268 {
269 Context *context = GetValidGlobalContext();
270 EVENT(context, GLGetPerfMonitorGroupStringAMD,
271 "context = %d, group = %u, bufSize = %d, length = 0x%016" PRIxPTR
272 ", groupString = 0x%016" PRIxPTR "",
273 CID(context), group, bufSize, (uintptr_t)length, (uintptr_t)groupString);
274
275 if (context)
276 {
277 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
278 bool isCallValid = (context->skipValidation() ||
279 ValidateGetPerfMonitorGroupStringAMD(
280 context, angle::EntryPoint::GLGetPerfMonitorGroupStringAMD, group,
281 bufSize, length, groupString));
282 if (isCallValid)
283 {
284 context->getPerfMonitorGroupString(group, bufSize, length, groupString);
285 }
286 ANGLE_CAPTURE(GetPerfMonitorGroupStringAMD, isCallValid, context, group, bufSize, length,
287 groupString);
288 }
289 else
290 {
291 GenerateContextLostErrorOnCurrentGlobalContext();
292 }
293 }
294
GL_GetPerfMonitorGroupsAMD(GLint * numGroups,GLsizei groupsSize,GLuint * groups)295 void GL_APIENTRY GL_GetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups)
296 {
297 Context *context = GetValidGlobalContext();
298 EVENT(context, GLGetPerfMonitorGroupsAMD,
299 "context = %d, numGroups = 0x%016" PRIxPTR ", groupsSize = %d, groups = 0x%016" PRIxPTR
300 "",
301 CID(context), (uintptr_t)numGroups, groupsSize, (uintptr_t)groups);
302
303 if (context)
304 {
305 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
306 bool isCallValid =
307 (context->skipValidation() ||
308 ValidateGetPerfMonitorGroupsAMD(context, angle::EntryPoint::GLGetPerfMonitorGroupsAMD,
309 numGroups, groupsSize, groups));
310 if (isCallValid)
311 {
312 context->getPerfMonitorGroups(numGroups, groupsSize, groups);
313 }
314 ANGLE_CAPTURE(GetPerfMonitorGroupsAMD, isCallValid, context, numGroups, groupsSize, groups);
315 }
316 else
317 {
318 GenerateContextLostErrorOnCurrentGlobalContext();
319 }
320 }
321
GL_SelectPerfMonitorCountersAMD(GLuint monitor,GLboolean enable,GLuint group,GLint numCounters,GLuint * counterList)322 void GL_APIENTRY GL_SelectPerfMonitorCountersAMD(GLuint monitor,
323 GLboolean enable,
324 GLuint group,
325 GLint numCounters,
326 GLuint *counterList)
327 {
328 Context *context = GetValidGlobalContext();
329 EVENT(context, GLSelectPerfMonitorCountersAMD,
330 "context = %d, monitor = %u, enable = %s, group = %u, numCounters = %d, counterList = "
331 "0x%016" PRIxPTR "",
332 CID(context), monitor, GLbooleanToString(enable), group, numCounters,
333 (uintptr_t)counterList);
334
335 if (context)
336 {
337 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
338 bool isCallValid = (context->skipValidation() ||
339 ValidateSelectPerfMonitorCountersAMD(
340 context, angle::EntryPoint::GLSelectPerfMonitorCountersAMD, monitor,
341 enable, group, numCounters, counterList));
342 if (isCallValid)
343 {
344 context->selectPerfMonitorCounters(monitor, enable, group, numCounters, counterList);
345 }
346 ANGLE_CAPTURE(SelectPerfMonitorCountersAMD, isCallValid, context, monitor, enable, group,
347 numCounters, counterList);
348 }
349 else
350 {
351 GenerateContextLostErrorOnCurrentGlobalContext();
352 }
353 }
354
355 // GL_ANDROID_extension_pack_es31a
356
357 // GL_ANGLE_base_vertex_base_instance
GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode,GLint first,GLsizei count,GLsizei instanceCount,GLuint baseInstance)358 void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode,
359 GLint first,
360 GLsizei count,
361 GLsizei instanceCount,
362 GLuint baseInstance)
363 {
364 Context *context = GetValidGlobalContext();
365 EVENT(context, GLDrawArraysInstancedBaseInstanceANGLE,
366 "context = %d, mode = %s, first = %d, count = %d, instanceCount = %d, baseInstance = %u",
367 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count,
368 instanceCount, baseInstance);
369
370 if (context)
371 {
372 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
373 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
374 bool isCallValid = (context->skipValidation() ||
375 ValidateDrawArraysInstancedBaseInstanceANGLE(
376 context, angle::EntryPoint::GLDrawArraysInstancedBaseInstanceANGLE,
377 modePacked, first, count, instanceCount, baseInstance));
378 if (isCallValid)
379 {
380 context->drawArraysInstancedBaseInstance(modePacked, first, count, instanceCount,
381 baseInstance);
382 }
383 ANGLE_CAPTURE(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, first,
384 count, instanceCount, baseInstance);
385 }
386 else
387 {
388 GenerateContextLostErrorOnCurrentGlobalContext();
389 }
390 }
391
GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,GLsizei count,GLenum type,const GLvoid * indices,GLsizei instanceCount,GLint baseVertex,GLuint baseInstance)392 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
393 GLsizei count,
394 GLenum type,
395 const GLvoid *indices,
396 GLsizei instanceCount,
397 GLint baseVertex,
398 GLuint baseInstance)
399 {
400 Context *context = GetValidGlobalContext();
401 EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
402 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
403 ", instanceCount = %d, baseVertex = %d, baseInstance = %u",
404 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
405 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instanceCount,
406 baseVertex, baseInstance);
407
408 if (context)
409 {
410 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
411 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
412 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
413 bool isCallValid =
414 (context->skipValidation() ||
415 ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE(
416 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
417 modePacked, count, typePacked, indices, instanceCount, baseVertex, baseInstance));
418 if (isCallValid)
419 {
420 context->drawElementsInstancedBaseVertexBaseInstance(
421 modePacked, count, typePacked, indices, instanceCount, baseVertex, baseInstance);
422 }
423 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
424 modePacked, count, typePacked, indices, instanceCount, baseVertex,
425 baseInstance);
426 }
427 else
428 {
429 GenerateContextLostErrorOnCurrentGlobalContext();
430 }
431 }
432
GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)433 void GL_APIENTRY GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
434 const GLint *firsts,
435 const GLsizei *counts,
436 const GLsizei *instanceCounts,
437 const GLuint *baseInstances,
438 GLsizei drawcount)
439 {
440 Context *context = GetValidGlobalContext();
441 EVENT(context, GLMultiDrawArraysInstancedBaseInstanceANGLE,
442 "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
443 ", instanceCounts = 0x%016" PRIxPTR ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d",
444 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
445 (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount);
446
447 if (context)
448 {
449 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
450 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
451 bool isCallValid =
452 (context->skipValidation() ||
453 ValidateMultiDrawArraysInstancedBaseInstanceANGLE(
454 context, angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
455 modePacked, firsts, counts, instanceCounts, baseInstances, drawcount));
456 if (isCallValid)
457 {
458 context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts,
459 instanceCounts, baseInstances, drawcount);
460 }
461 ANGLE_CAPTURE(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked,
462 firsts, counts, instanceCounts, baseInstances, drawcount);
463 }
464 else
465 {
466 GenerateContextLostErrorOnCurrentGlobalContext();
467 }
468 }
469
470 void GL_APIENTRY
GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,const GLsizei * instanceCounts,const GLint * baseVertices,const GLuint * baseInstances,GLsizei drawcount)471 GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
472 const GLsizei *counts,
473 GLenum type,
474 const GLvoid *const *indices,
475 const GLsizei *instanceCounts,
476 const GLint *baseVertices,
477 const GLuint *baseInstances,
478 GLsizei drawcount)
479 {
480 Context *context = GetValidGlobalContext();
481 EVENT(context, GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
482 "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
483 ", instanceCounts = 0x%016" PRIxPTR ", baseVertices = 0x%016" PRIxPTR
484 ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d",
485 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
486 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
487 (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount);
488
489 if (context)
490 {
491 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
492 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
493 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
494 bool isCallValid =
495 (context->skipValidation() ||
496 ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
497 context,
498 angle::EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
499 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
500 baseInstances, drawcount));
501 if (isCallValid)
502 {
503 context->multiDrawElementsInstancedBaseVertexBaseInstance(
504 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
505 baseInstances, drawcount);
506 }
507 ANGLE_CAPTURE(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
508 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
509 baseInstances, drawcount);
510 }
511 else
512 {
513 GenerateContextLostErrorOnCurrentGlobalContext();
514 }
515 }
516
517 // GL_ANGLE_copy_texture_3d
GL_CopyTexture3DANGLE(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)518 void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId,
519 GLint sourceLevel,
520 GLenum destTarget,
521 GLuint destId,
522 GLint destLevel,
523 GLint internalFormat,
524 GLenum destType,
525 GLboolean unpackFlipY,
526 GLboolean unpackPremultiplyAlpha,
527 GLboolean unpackUnmultiplyAlpha)
528 {
529 Context *context = GetValidGlobalContext();
530 EVENT(context, GLCopyTexture3DANGLE,
531 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
532 "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = "
533 "%s, unpackUnmultiplyAlpha = %s",
534 CID(context), sourceId, sourceLevel,
535 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
536 GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
537 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
538
539 if (context)
540 {
541 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
542 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
543 TextureID destIdPacked = PackParam<TextureID>(destId);
544 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
545 bool isCallValid =
546 (context->skipValidation() ||
547 ValidateCopyTexture3DANGLE(context, angle::EntryPoint::GLCopyTexture3DANGLE,
548 sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
549 destLevel, internalFormat, destType, unpackFlipY,
550 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
551 if (isCallValid)
552 {
553 context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
554 destLevel, internalFormat, destType, unpackFlipY,
555 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
556 }
557 ANGLE_CAPTURE(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
558 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
559 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
560 }
561 else
562 {
563 GenerateContextLostErrorOnCurrentGlobalContext();
564 }
565 }
566
GL_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)567 void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId,
568 GLint sourceLevel,
569 GLenum destTarget,
570 GLuint destId,
571 GLint destLevel,
572 GLint xoffset,
573 GLint yoffset,
574 GLint zoffset,
575 GLint x,
576 GLint y,
577 GLint z,
578 GLint width,
579 GLint height,
580 GLint depth,
581 GLboolean unpackFlipY,
582 GLboolean unpackPremultiplyAlpha,
583 GLboolean unpackUnmultiplyAlpha)
584 {
585 Context *context = GetValidGlobalContext();
586 EVENT(context, GLCopySubTexture3DANGLE,
587 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
588 "= %d, xoffset = %d, yoffset = %d, zoffset = %d, x = %d, y = %d, z = %d, width = %d, "
589 "height = %d, depth = %d, unpackFlipY = %s, unpackPremultiplyAlpha = %s, "
590 "unpackUnmultiplyAlpha = %s",
591 CID(context), sourceId, sourceLevel,
592 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
593 yoffset, zoffset, x, y, z, width, height, depth, GLbooleanToString(unpackFlipY),
594 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
595
596 if (context)
597 {
598 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
599 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
600 TextureID destIdPacked = PackParam<TextureID>(destId);
601 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
602 bool isCallValid =
603 (context->skipValidation() ||
604 ValidateCopySubTexture3DANGLE(
605 context, angle::EntryPoint::GLCopySubTexture3DANGLE, sourceIdPacked, sourceLevel,
606 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z,
607 width, height, depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
608 if (isCallValid)
609 {
610 context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
611 destLevel, xoffset, yoffset, zoffset, x, y, z, width, height,
612 depth, unpackFlipY, unpackPremultiplyAlpha,
613 unpackUnmultiplyAlpha);
614 }
615 ANGLE_CAPTURE(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
616 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z,
617 width, height, depth, unpackFlipY, unpackPremultiplyAlpha,
618 unpackUnmultiplyAlpha);
619 }
620 else
621 {
622 GenerateContextLostErrorOnCurrentGlobalContext();
623 }
624 }
625
626 // GL_ANGLE_depth_texture
627
628 // GL_ANGLE_framebuffer_blit
GL_BlitFramebufferANGLE(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)629 void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0,
630 GLint srcY0,
631 GLint srcX1,
632 GLint srcY1,
633 GLint dstX0,
634 GLint dstY0,
635 GLint dstX1,
636 GLint dstY1,
637 GLbitfield mask,
638 GLenum filter)
639 {
640 Context *context = GetValidGlobalContext();
641 EVENT(context, GLBlitFramebufferANGLE,
642 "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
643 "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
644 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
645 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
646 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
647
648 if (context)
649 {
650 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
651 bool isCallValid = (context->skipValidation() ||
652 ValidateBlitFramebufferANGLE(
653 context, angle::EntryPoint::GLBlitFramebufferANGLE, srcX0, srcY0,
654 srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
655 if (isCallValid)
656 {
657 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
658 filter);
659 }
660 ANGLE_CAPTURE(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
661 dstY0, dstX1, dstY1, mask, filter);
662 }
663 else
664 {
665 GenerateContextLostErrorOnCurrentGlobalContext();
666 }
667 }
668
669 // GL_ANGLE_framebuffer_multisample
GL_RenderbufferStorageMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)670 void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target,
671 GLsizei samples,
672 GLenum internalformat,
673 GLsizei width,
674 GLsizei height)
675 {
676 Context *context = GetValidGlobalContext();
677 EVENT(context, GLRenderbufferStorageMultisampleANGLE,
678 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
679 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
680 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
681
682 if (context)
683 {
684 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
685 bool isCallValid = (context->skipValidation() ||
686 ValidateRenderbufferStorageMultisampleANGLE(
687 context, angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE,
688 target, samples, internalformat, width, height));
689 if (isCallValid)
690 {
691 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
692 }
693 ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples,
694 internalformat, width, height);
695 }
696 else
697 {
698 GenerateContextLostErrorOnCurrentGlobalContext();
699 }
700 }
701
702 // GL_ANGLE_get_image
703 void GL_APIENTRY
GL_GetTexImageANGLE(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)704 GL_GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
705 {
706 Context *context = GetValidGlobalContext();
707 EVENT(context, GLGetTexImageANGLE,
708 "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR
709 "",
710 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
711 GLenumToString(GLenumGroup::PixelFormat, format),
712 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
713
714 if (context)
715 {
716 TextureTarget targetPacked = PackParam<TextureTarget>(target);
717 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
718 bool isCallValid = (context->skipValidation() ||
719 ValidateGetTexImageANGLE(context, angle::EntryPoint::GLGetTexImageANGLE,
720 targetPacked, level, format, type, pixels));
721 if (isCallValid)
722 {
723 context->getTexImage(targetPacked, level, format, type, pixels);
724 }
725 ANGLE_CAPTURE(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type,
726 pixels);
727 }
728 else
729 {
730 GenerateContextLostErrorOnCurrentGlobalContext();
731 }
732 }
733
GL_GetCompressedTexImageANGLE(GLenum target,GLint level,void * pixels)734 void GL_APIENTRY GL_GetCompressedTexImageANGLE(GLenum target, GLint level, void *pixels)
735 {
736 Context *context = GetValidGlobalContext();
737 EVENT(context, GLGetCompressedTexImageANGLE,
738 "context = %d, target = %s, level = %d, pixels = 0x%016" PRIxPTR "", CID(context),
739 GLenumToString(GLenumGroup::TextureTarget, target), level, (uintptr_t)pixels);
740
741 if (context)
742 {
743 TextureTarget targetPacked = PackParam<TextureTarget>(target);
744 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
745 bool isCallValid = (context->skipValidation() ||
746 ValidateGetCompressedTexImageANGLE(
747 context, angle::EntryPoint::GLGetCompressedTexImageANGLE,
748 targetPacked, level, pixels));
749 if (isCallValid)
750 {
751 context->getCompressedTexImage(targetPacked, level, pixels);
752 }
753 ANGLE_CAPTURE(GetCompressedTexImageANGLE, isCallValid, context, targetPacked, level,
754 pixels);
755 }
756 else
757 {
758 GenerateContextLostErrorOnCurrentGlobalContext();
759 }
760 }
761
GL_GetRenderbufferImageANGLE(GLenum target,GLenum format,GLenum type,void * pixels)762 void GL_APIENTRY GL_GetRenderbufferImageANGLE(GLenum target,
763 GLenum format,
764 GLenum type,
765 void *pixels)
766 {
767 Context *context = GetValidGlobalContext();
768 EVENT(context, GLGetRenderbufferImageANGLE,
769 "context = %d, target = %s, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
770 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target),
771 GLenumToString(GLenumGroup::PixelFormat, format),
772 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
773
774 if (context)
775 {
776 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
777 bool isCallValid = (context->skipValidation() ||
778 ValidateGetRenderbufferImageANGLE(
779 context, angle::EntryPoint::GLGetRenderbufferImageANGLE, target,
780 format, type, pixels));
781 if (isCallValid)
782 {
783 context->getRenderbufferImage(target, format, type, pixels);
784 }
785 ANGLE_CAPTURE(GetRenderbufferImageANGLE, isCallValid, context, target, format, type,
786 pixels);
787 }
788 else
789 {
790 GenerateContextLostErrorOnCurrentGlobalContext();
791 }
792 }
793
794 // GL_ANGLE_get_tex_level_parameter
GL_GetTexLevelParameterivANGLE(GLenum target,GLint level,GLenum pname,GLint * params)795 void GL_APIENTRY GL_GetTexLevelParameterivANGLE(GLenum target,
796 GLint level,
797 GLenum pname,
798 GLint *params)
799 {
800 Context *context = GetValidGlobalContext();
801 EVENT(context, GLGetTexLevelParameterivANGLE,
802 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
803 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
804 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
805
806 if (context)
807 {
808 TextureTarget targetPacked = PackParam<TextureTarget>(target);
809 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
810 bool isCallValid = (context->skipValidation() ||
811 ValidateGetTexLevelParameterivANGLE(
812 context, angle::EntryPoint::GLGetTexLevelParameterivANGLE,
813 targetPacked, level, pname, params));
814 if (isCallValid)
815 {
816 context->getTexLevelParameteriv(targetPacked, level, pname, params);
817 }
818 ANGLE_CAPTURE(GetTexLevelParameterivANGLE, isCallValid, context, targetPacked, level, pname,
819 params);
820 }
821 else
822 {
823 GenerateContextLostErrorOnCurrentGlobalContext();
824 }
825 }
826
GL_GetTexLevelParameterfvANGLE(GLenum target,GLint level,GLenum pname,GLfloat * params)827 void GL_APIENTRY GL_GetTexLevelParameterfvANGLE(GLenum target,
828 GLint level,
829 GLenum pname,
830 GLfloat *params)
831 {
832 Context *context = GetValidGlobalContext();
833 EVENT(context, GLGetTexLevelParameterfvANGLE,
834 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
835 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
836 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
837
838 if (context)
839 {
840 TextureTarget targetPacked = PackParam<TextureTarget>(target);
841 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
842 bool isCallValid = (context->skipValidation() ||
843 ValidateGetTexLevelParameterfvANGLE(
844 context, angle::EntryPoint::GLGetTexLevelParameterfvANGLE,
845 targetPacked, level, pname, params));
846 if (isCallValid)
847 {
848 context->getTexLevelParameterfv(targetPacked, level, pname, params);
849 }
850 ANGLE_CAPTURE(GetTexLevelParameterfvANGLE, isCallValid, context, targetPacked, level, pname,
851 params);
852 }
853 else
854 {
855 GenerateContextLostErrorOnCurrentGlobalContext();
856 }
857 }
858
859 // GL_ANGLE_instanced_arrays
GL_DrawArraysInstancedANGLE(GLenum mode,GLint first,GLsizei count,GLsizei primcount)860 void GL_APIENTRY GL_DrawArraysInstancedANGLE(GLenum mode,
861 GLint first,
862 GLsizei count,
863 GLsizei primcount)
864 {
865 Context *context = GetValidGlobalContext();
866 EVENT(context, GLDrawArraysInstancedANGLE,
867 "context = %d, mode = %s, first = %d, count = %d, primcount = %d", CID(context),
868 GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, primcount);
869
870 if (context)
871 {
872 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
873 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
874 bool isCallValid = (context->skipValidation() ||
875 ValidateDrawArraysInstancedANGLE(
876 context, angle::EntryPoint::GLDrawArraysInstancedANGLE, modePacked,
877 first, count, primcount));
878 if (isCallValid)
879 {
880 context->drawArraysInstanced(modePacked, first, count, primcount);
881 }
882 ANGLE_CAPTURE(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count,
883 primcount);
884 }
885 else
886 {
887 GenerateContextLostErrorOnCurrentGlobalContext();
888 }
889 }
890
GL_DrawElementsInstancedANGLE(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)891 void GL_APIENTRY GL_DrawElementsInstancedANGLE(GLenum mode,
892 GLsizei count,
893 GLenum type,
894 const void *indices,
895 GLsizei primcount)
896 {
897 Context *context = GetValidGlobalContext();
898 EVENT(context, GLDrawElementsInstancedANGLE,
899 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
900 ", primcount = %d",
901 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
902 GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, primcount);
903
904 if (context)
905 {
906 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
907 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
908 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
909 bool isCallValid = (context->skipValidation() ||
910 ValidateDrawElementsInstancedANGLE(
911 context, angle::EntryPoint::GLDrawElementsInstancedANGLE,
912 modePacked, count, typePacked, indices, primcount));
913 if (isCallValid)
914 {
915 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
916 }
917 ANGLE_CAPTURE(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count,
918 typePacked, indices, primcount);
919 }
920 else
921 {
922 GenerateContextLostErrorOnCurrentGlobalContext();
923 }
924 }
925
GL_VertexAttribDivisorANGLE(GLuint index,GLuint divisor)926 void GL_APIENTRY GL_VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
927 {
928 Context *context = GetValidGlobalContext();
929 EVENT(context, GLVertexAttribDivisorANGLE, "context = %d, index = %u, divisor = %u",
930 CID(context), index, divisor);
931
932 if (context)
933 {
934 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
935 bool isCallValid =
936 (context->skipValidation() ||
937 ValidateVertexAttribDivisorANGLE(
938 context, angle::EntryPoint::GLVertexAttribDivisorANGLE, index, divisor));
939 if (isCallValid)
940 {
941 context->vertexAttribDivisor(index, divisor);
942 }
943 ANGLE_CAPTURE(VertexAttribDivisorANGLE, isCallValid, context, index, divisor);
944 }
945 else
946 {
947 GenerateContextLostErrorOnCurrentGlobalContext();
948 }
949 }
950
951 // GL_ANGLE_memory_object_flags
GL_TexStorageMemFlags2DANGLE(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)952 void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target,
953 GLsizei levels,
954 GLenum internalFormat,
955 GLsizei width,
956 GLsizei height,
957 GLuint memory,
958 GLuint64 offset,
959 GLbitfield createFlags,
960 GLbitfield usageFlags,
961 const void *imageCreateInfoPNext)
962 {
963 Context *context = GetValidGlobalContext();
964 EVENT(context, GLTexStorageMemFlags2DANGLE,
965 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
966 "memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, imageCreateInfoPNext = "
967 "0x%016" PRIxPTR "",
968 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
969 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory,
970 static_cast<unsigned long long>(offset),
971 GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
972 GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(),
973 (uintptr_t)imageCreateInfoPNext);
974
975 if (context)
976 {
977 TextureType targetPacked = PackParam<TextureType>(target);
978 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
979 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
980 bool isCallValid = (context->skipValidation() ||
981 ValidateTexStorageMemFlags2DANGLE(
982 context, angle::EntryPoint::GLTexStorageMemFlags2DANGLE,
983 targetPacked, levels, internalFormat, width, height, memoryPacked,
984 offset, createFlags, usageFlags, imageCreateInfoPNext));
985 if (isCallValid)
986 {
987 context->texStorageMemFlags2D(targetPacked, levels, internalFormat, width, height,
988 memoryPacked, offset, createFlags, usageFlags,
989 imageCreateInfoPNext);
990 }
991 ANGLE_CAPTURE(TexStorageMemFlags2DANGLE, isCallValid, context, targetPacked, levels,
992 internalFormat, width, height, memoryPacked, offset, createFlags, usageFlags,
993 imageCreateInfoPNext);
994 }
995 else
996 {
997 GenerateContextLostErrorOnCurrentGlobalContext();
998 }
999 }
1000
GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1001 void GL_APIENTRY GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target,
1002 GLsizei samples,
1003 GLenum internalFormat,
1004 GLsizei width,
1005 GLsizei height,
1006 GLboolean fixedSampleLocations,
1007 GLuint memory,
1008 GLuint64 offset,
1009 GLbitfield createFlags,
1010 GLbitfield usageFlags,
1011 const void *imageCreateInfoPNext)
1012 {
1013 Context *context = GetValidGlobalContext();
1014 EVENT(context, GLTexStorageMemFlags2DMultisampleANGLE,
1015 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
1016 "fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, usageFlags = "
1017 "%s, imageCreateInfoPNext = 0x%016" PRIxPTR "",
1018 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
1019 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height,
1020 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset),
1021 GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
1022 GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(),
1023 (uintptr_t)imageCreateInfoPNext);
1024
1025 if (context)
1026 {
1027 TextureType targetPacked = PackParam<TextureType>(target);
1028 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1029 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1030 bool isCallValid =
1031 (context->skipValidation() ||
1032 ValidateTexStorageMemFlags2DMultisampleANGLE(
1033 context, angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, targetPacked,
1034 samples, internalFormat, width, height, fixedSampleLocations, memoryPacked, offset,
1035 createFlags, usageFlags, imageCreateInfoPNext));
1036 if (isCallValid)
1037 {
1038 context->texStorageMemFlags2DMultisample(
1039 targetPacked, samples, internalFormat, width, height, fixedSampleLocations,
1040 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext);
1041 }
1042 ANGLE_CAPTURE(TexStorageMemFlags2DMultisampleANGLE, isCallValid, context, targetPacked,
1043 samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
1044 offset, createFlags, usageFlags, imageCreateInfoPNext);
1045 }
1046 else
1047 {
1048 GenerateContextLostErrorOnCurrentGlobalContext();
1049 }
1050 }
1051
GL_TexStorageMemFlags3DANGLE(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1052 void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target,
1053 GLsizei levels,
1054 GLenum internalFormat,
1055 GLsizei width,
1056 GLsizei height,
1057 GLsizei depth,
1058 GLuint memory,
1059 GLuint64 offset,
1060 GLbitfield createFlags,
1061 GLbitfield usageFlags,
1062 const void *imageCreateInfoPNext)
1063 {
1064 Context *context = GetValidGlobalContext();
1065 EVENT(context, GLTexStorageMemFlags3DANGLE,
1066 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
1067 "depth = %d, memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, "
1068 "imageCreateInfoPNext = 0x%016" PRIxPTR "",
1069 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
1070 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory,
1071 static_cast<unsigned long long>(offset),
1072 GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
1073 GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(),
1074 (uintptr_t)imageCreateInfoPNext);
1075
1076 if (context)
1077 {
1078 TextureType targetPacked = PackParam<TextureType>(target);
1079 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1080 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1081 bool isCallValid =
1082 (context->skipValidation() ||
1083 ValidateTexStorageMemFlags3DANGLE(
1084 context, angle::EntryPoint::GLTexStorageMemFlags3DANGLE, targetPacked, levels,
1085 internalFormat, width, height, depth, memoryPacked, offset, createFlags,
1086 usageFlags, imageCreateInfoPNext));
1087 if (isCallValid)
1088 {
1089 context->texStorageMemFlags3D(targetPacked, levels, internalFormat, width, height,
1090 depth, memoryPacked, offset, createFlags, usageFlags,
1091 imageCreateInfoPNext);
1092 }
1093 ANGLE_CAPTURE(TexStorageMemFlags3DANGLE, isCallValid, context, targetPacked, levels,
1094 internalFormat, width, height, depth, memoryPacked, offset, createFlags,
1095 usageFlags, imageCreateInfoPNext);
1096 }
1097 else
1098 {
1099 GenerateContextLostErrorOnCurrentGlobalContext();
1100 }
1101 }
1102
GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset,GLbitfield createFlags,GLbitfield usageFlags,const void * imageCreateInfoPNext)1103 void GL_APIENTRY GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target,
1104 GLsizei samples,
1105 GLenum internalFormat,
1106 GLsizei width,
1107 GLsizei height,
1108 GLsizei depth,
1109 GLboolean fixedSampleLocations,
1110 GLuint memory,
1111 GLuint64 offset,
1112 GLbitfield createFlags,
1113 GLbitfield usageFlags,
1114 const void *imageCreateInfoPNext)
1115 {
1116 Context *context = GetValidGlobalContext();
1117 EVENT(context, GLTexStorageMemFlags3DMultisampleANGLE,
1118 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
1119 "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, "
1120 "usageFlags = %s, imageCreateInfoPNext = 0x%016" PRIxPTR "",
1121 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
1122 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth,
1123 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset),
1124 GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(),
1125 GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(),
1126 (uintptr_t)imageCreateInfoPNext);
1127
1128 if (context)
1129 {
1130 TextureType targetPacked = PackParam<TextureType>(target);
1131 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1132 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1133 bool isCallValid =
1134 (context->skipValidation() ||
1135 ValidateTexStorageMemFlags3DMultisampleANGLE(
1136 context, angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, targetPacked,
1137 samples, internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
1138 offset, createFlags, usageFlags, imageCreateInfoPNext));
1139 if (isCallValid)
1140 {
1141 context->texStorageMemFlags3DMultisample(
1142 targetPacked, samples, internalFormat, width, height, depth, fixedSampleLocations,
1143 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext);
1144 }
1145 ANGLE_CAPTURE(TexStorageMemFlags3DMultisampleANGLE, isCallValid, context, targetPacked,
1146 samples, internalFormat, width, height, depth, fixedSampleLocations,
1147 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext);
1148 }
1149 else
1150 {
1151 GenerateContextLostErrorOnCurrentGlobalContext();
1152 }
1153 }
1154
1155 // GL_ANGLE_memory_object_fuchsia
GL_ImportMemoryZirconHandleANGLE(GLuint memory,GLuint64 size,GLenum handleType,GLuint handle)1156 void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory,
1157 GLuint64 size,
1158 GLenum handleType,
1159 GLuint handle)
1160 {
1161 Context *context = GetValidGlobalContext();
1162 EVENT(context, GLImportMemoryZirconHandleANGLE,
1163 "context = %d, memory = %u, size = %llu, handleType = %s, handle = %u", CID(context),
1164 memory, static_cast<unsigned long long>(size),
1165 GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle);
1166
1167 if (context)
1168 {
1169 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1170 HandleType handleTypePacked = PackParam<HandleType>(handleType);
1171 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1172 bool isCallValid = (context->skipValidation() ||
1173 ValidateImportMemoryZirconHandleANGLE(
1174 context, angle::EntryPoint::GLImportMemoryZirconHandleANGLE,
1175 memoryPacked, size, handleTypePacked, handle));
1176 if (isCallValid)
1177 {
1178 context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle);
1179 }
1180 ANGLE_CAPTURE(ImportMemoryZirconHandleANGLE, isCallValid, context, memoryPacked, size,
1181 handleTypePacked, handle);
1182 }
1183 else
1184 {
1185 GenerateContextLostErrorOnCurrentGlobalContext();
1186 }
1187 }
1188
1189 // GL_ANGLE_multi_draw
GL_MultiDrawArraysANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)1190 void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode,
1191 const GLint *firsts,
1192 const GLsizei *counts,
1193 GLsizei drawcount)
1194 {
1195 Context *context = GetValidGlobalContext();
1196 EVENT(context, GLMultiDrawArraysANGLE,
1197 "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
1198 ", drawcount = %d",
1199 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
1200 (uintptr_t)counts, drawcount);
1201
1202 if (context)
1203 {
1204 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1205 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1206 bool isCallValid =
1207 (context->skipValidation() ||
1208 ValidateMultiDrawArraysANGLE(context, angle::EntryPoint::GLMultiDrawArraysANGLE,
1209 modePacked, firsts, counts, drawcount));
1210 if (isCallValid)
1211 {
1212 context->multiDrawArrays(modePacked, firsts, counts, drawcount);
1213 }
1214 ANGLE_CAPTURE(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts,
1215 drawcount);
1216 }
1217 else
1218 {
1219 GenerateContextLostErrorOnCurrentGlobalContext();
1220 }
1221 }
1222
GL_MultiDrawArraysInstancedANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)1223 void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode,
1224 const GLint *firsts,
1225 const GLsizei *counts,
1226 const GLsizei *instanceCounts,
1227 GLsizei drawcount)
1228 {
1229 Context *context = GetValidGlobalContext();
1230 EVENT(context, GLMultiDrawArraysInstancedANGLE,
1231 "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
1232 ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d",
1233 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts,
1234 (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
1235
1236 if (context)
1237 {
1238 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1239 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1240 bool isCallValid = (context->skipValidation() ||
1241 ValidateMultiDrawArraysInstancedANGLE(
1242 context, angle::EntryPoint::GLMultiDrawArraysInstancedANGLE,
1243 modePacked, firsts, counts, instanceCounts, drawcount));
1244 if (isCallValid)
1245 {
1246 context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
1247 drawcount);
1248 }
1249 ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts,
1250 counts, instanceCounts, drawcount);
1251 }
1252 else
1253 {
1254 GenerateContextLostErrorOnCurrentGlobalContext();
1255 }
1256 }
1257
GL_MultiDrawElementsANGLE(GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,GLsizei drawcount)1258 void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode,
1259 const GLsizei *counts,
1260 GLenum type,
1261 const GLvoid *const *indices,
1262 GLsizei drawcount)
1263 {
1264 Context *context = GetValidGlobalContext();
1265 EVENT(context, GLMultiDrawElementsANGLE,
1266 "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
1267 ", drawcount = %d",
1268 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
1269 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount);
1270
1271 if (context)
1272 {
1273 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1274 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
1275 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1276 bool isCallValid =
1277 (context->skipValidation() ||
1278 ValidateMultiDrawElementsANGLE(context, angle::EntryPoint::GLMultiDrawElementsANGLE,
1279 modePacked, counts, typePacked, indices, drawcount));
1280 if (isCallValid)
1281 {
1282 context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
1283 }
1284 ANGLE_CAPTURE(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts, typePacked,
1285 indices, drawcount);
1286 }
1287 else
1288 {
1289 GenerateContextLostErrorOnCurrentGlobalContext();
1290 }
1291 }
1292
GL_MultiDrawElementsInstancedANGLE(GLenum mode,const GLsizei * counts,GLenum type,const GLvoid * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)1293 void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode,
1294 const GLsizei *counts,
1295 GLenum type,
1296 const GLvoid *const *indices,
1297 const GLsizei *instanceCounts,
1298 GLsizei drawcount)
1299 {
1300 Context *context = GetValidGlobalContext();
1301 EVENT(context, GLMultiDrawElementsInstancedANGLE,
1302 "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
1303 ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d",
1304 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts,
1305 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices,
1306 (uintptr_t)instanceCounts, drawcount);
1307
1308 if (context)
1309 {
1310 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1311 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
1312 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1313 bool isCallValid =
1314 (context->skipValidation() ||
1315 ValidateMultiDrawElementsInstancedANGLE(
1316 context, angle::EntryPoint::GLMultiDrawElementsInstancedANGLE, modePacked, counts,
1317 typePacked, indices, instanceCounts, drawcount));
1318 if (isCallValid)
1319 {
1320 context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
1321 instanceCounts, drawcount);
1322 }
1323 ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts,
1324 typePacked, indices, instanceCounts, drawcount);
1325 }
1326 else
1327 {
1328 GenerateContextLostErrorOnCurrentGlobalContext();
1329 }
1330 }
1331
1332 // GL_ANGLE_pack_reverse_row_order
1333
1334 // GL_ANGLE_program_binary
1335
1336 // GL_ANGLE_provoking_vertex
GL_ProvokingVertexANGLE(GLenum mode)1337 void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum mode)
1338 {
1339 Context *context = GetValidGlobalContext();
1340 EVENT(context, GLProvokingVertexANGLE, "context = %d, mode = %s", CID(context),
1341 GLenumToString(GLenumGroup::VertexProvokingMode, mode));
1342
1343 if (context)
1344 {
1345 ProvokingVertexConvention modePacked = PackParam<ProvokingVertexConvention>(mode);
1346 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1347 bool isCallValid = (context->skipValidation() ||
1348 ValidateProvokingVertexANGLE(
1349 context, angle::EntryPoint::GLProvokingVertexANGLE, modePacked));
1350 if (isCallValid)
1351 {
1352 context->provokingVertex(modePacked);
1353 }
1354 ANGLE_CAPTURE(ProvokingVertexANGLE, isCallValid, context, modePacked);
1355 }
1356 else
1357 {
1358 GenerateContextLostErrorOnCurrentGlobalContext();
1359 }
1360 }
1361
1362 // GL_ANGLE_request_extension
GL_RequestExtensionANGLE(const GLchar * name)1363 void GL_APIENTRY GL_RequestExtensionANGLE(const GLchar *name)
1364 {
1365 Context *context = GetValidGlobalContext();
1366 EVENT(context, GLRequestExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context),
1367 (uintptr_t)name);
1368
1369 if (context)
1370 {
1371 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1372 bool isCallValid = (context->skipValidation() ||
1373 ValidateRequestExtensionANGLE(
1374 context, angle::EntryPoint::GLRequestExtensionANGLE, name));
1375 if (isCallValid)
1376 {
1377 context->requestExtension(name);
1378 }
1379 ANGLE_CAPTURE(RequestExtensionANGLE, isCallValid, context, name);
1380 }
1381 else
1382 {
1383 GenerateContextLostErrorOnCurrentGlobalContext();
1384 }
1385 }
1386
GL_DisableExtensionANGLE(const GLchar * name)1387 void GL_APIENTRY GL_DisableExtensionANGLE(const GLchar *name)
1388 {
1389 Context *context = GetValidGlobalContext();
1390 EVENT(context, GLDisableExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context),
1391 (uintptr_t)name);
1392
1393 if (context)
1394 {
1395 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1396 bool isCallValid = (context->skipValidation() ||
1397 ValidateDisableExtensionANGLE(
1398 context, angle::EntryPoint::GLDisableExtensionANGLE, name));
1399 if (isCallValid)
1400 {
1401 context->disableExtension(name);
1402 }
1403 ANGLE_CAPTURE(DisableExtensionANGLE, isCallValid, context, name);
1404 }
1405 else
1406 {
1407 GenerateContextLostErrorOnCurrentGlobalContext();
1408 }
1409 }
1410
1411 // GL_ANGLE_robust_client_memory
GL_GetBooleanvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)1412 void GL_APIENTRY GL_GetBooleanvRobustANGLE(GLenum pname,
1413 GLsizei bufSize,
1414 GLsizei *length,
1415 GLboolean *params)
1416 {
1417 Context *context = GetValidGlobalContext();
1418 EVENT(context, GLGetBooleanvRobustANGLE,
1419 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1420 ", params = 0x%016" PRIxPTR "",
1421 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1422 (uintptr_t)length, (uintptr_t)params);
1423
1424 if (context)
1425 {
1426 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1427 bool isCallValid =
1428 (context->skipValidation() ||
1429 ValidateGetBooleanvRobustANGLE(context, angle::EntryPoint::GLGetBooleanvRobustANGLE,
1430 pname, bufSize, length, params));
1431 if (isCallValid)
1432 {
1433 context->getBooleanvRobust(pname, bufSize, length, params);
1434 }
1435 ANGLE_CAPTURE(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
1436 }
1437 else
1438 {
1439 GenerateContextLostErrorOnCurrentGlobalContext();
1440 }
1441 }
1442
GL_GetBufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1443 void GL_APIENTRY GL_GetBufferParameterivRobustANGLE(GLenum target,
1444 GLenum pname,
1445 GLsizei bufSize,
1446 GLsizei *length,
1447 GLint *params)
1448 {
1449 Context *context = GetValidGlobalContext();
1450 EVENT(context, GLGetBufferParameterivRobustANGLE,
1451 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1452 ", params = 0x%016" PRIxPTR "",
1453 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1454 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1455 (uintptr_t)params);
1456
1457 if (context)
1458 {
1459 BufferBinding targetPacked = PackParam<BufferBinding>(target);
1460 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1461 bool isCallValid = (context->skipValidation() ||
1462 ValidateGetBufferParameterivRobustANGLE(
1463 context, angle::EntryPoint::GLGetBufferParameterivRobustANGLE,
1464 targetPacked, pname, bufSize, length, params));
1465 if (isCallValid)
1466 {
1467 context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
1468 }
1469 ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
1470 bufSize, length, params);
1471 }
1472 else
1473 {
1474 GenerateContextLostErrorOnCurrentGlobalContext();
1475 }
1476 }
1477
GL_GetFloatvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1478 void GL_APIENTRY GL_GetFloatvRobustANGLE(GLenum pname,
1479 GLsizei bufSize,
1480 GLsizei *length,
1481 GLfloat *params)
1482 {
1483 Context *context = GetValidGlobalContext();
1484 EVENT(context, GLGetFloatvRobustANGLE,
1485 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1486 ", params = 0x%016" PRIxPTR "",
1487 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1488 (uintptr_t)length, (uintptr_t)params);
1489
1490 if (context)
1491 {
1492 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1493 bool isCallValid =
1494 (context->skipValidation() ||
1495 ValidateGetFloatvRobustANGLE(context, angle::EntryPoint::GLGetFloatvRobustANGLE, pname,
1496 bufSize, length, params));
1497 if (isCallValid)
1498 {
1499 context->getFloatvRobust(pname, bufSize, length, params);
1500 }
1501 ANGLE_CAPTURE(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length, params);
1502 }
1503 else
1504 {
1505 GenerateContextLostErrorOnCurrentGlobalContext();
1506 }
1507 }
1508
GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1509 void GL_APIENTRY GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
1510 GLenum attachment,
1511 GLenum pname,
1512 GLsizei bufSize,
1513 GLsizei *length,
1514 GLint *params)
1515 {
1516 Context *context = GetValidGlobalContext();
1517 EVENT(context, GLGetFramebufferAttachmentParameterivRobustANGLE,
1518 "context = %d, target = %s, attachment = %s, pname = %s, bufSize = %d, length = "
1519 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
1520 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1521 GLenumToString(GLenumGroup::DefaultGroup, attachment),
1522 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1523 (uintptr_t)params);
1524
1525 if (context)
1526 {
1527 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1528 bool isCallValid =
1529 (context->skipValidation() ||
1530 ValidateGetFramebufferAttachmentParameterivRobustANGLE(
1531 context, angle::EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
1532 target, attachment, pname, bufSize, length, params));
1533 if (isCallValid)
1534 {
1535 context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
1536 length, params);
1537 }
1538 ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context, target,
1539 attachment, pname, bufSize, length, params);
1540 }
1541 else
1542 {
1543 GenerateContextLostErrorOnCurrentGlobalContext();
1544 }
1545 }
1546
GL_GetIntegervRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)1547 void GL_APIENTRY GL_GetIntegervRobustANGLE(GLenum pname,
1548 GLsizei bufSize,
1549 GLsizei *length,
1550 GLint *data)
1551 {
1552 Context *context = GetValidGlobalContext();
1553 EVENT(context, GLGetIntegervRobustANGLE,
1554 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1555 ", data = 0x%016" PRIxPTR "",
1556 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1557 (uintptr_t)length, (uintptr_t)data);
1558
1559 if (context)
1560 {
1561 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1562 bool isCallValid =
1563 (context->skipValidation() ||
1564 ValidateGetIntegervRobustANGLE(context, angle::EntryPoint::GLGetIntegervRobustANGLE,
1565 pname, bufSize, length, data));
1566 if (isCallValid)
1567 {
1568 context->getIntegervRobust(pname, bufSize, length, data);
1569 }
1570 ANGLE_CAPTURE(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length, data);
1571 }
1572 else
1573 {
1574 GenerateContextLostErrorOnCurrentGlobalContext();
1575 }
1576 }
1577
GL_GetProgramivRobustANGLE(GLuint program,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1578 void GL_APIENTRY GL_GetProgramivRobustANGLE(GLuint program,
1579 GLenum pname,
1580 GLsizei bufSize,
1581 GLsizei *length,
1582 GLint *params)
1583 {
1584 Context *context = GetGlobalContext();
1585 EVENT(context, GLGetProgramivRobustANGLE,
1586 "context = %d, program = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1587 ", params = 0x%016" PRIxPTR "",
1588 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1589 (uintptr_t)length, (uintptr_t)params);
1590
1591 if (context)
1592 {
1593 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1594 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1595 bool isCallValid =
1596 (context->skipValidation() ||
1597 ValidateGetProgramivRobustANGLE(context, angle::EntryPoint::GLGetProgramivRobustANGLE,
1598 programPacked, pname, bufSize, length, params));
1599 if (isCallValid)
1600 {
1601 context->getProgramivRobust(programPacked, pname, bufSize, length, params);
1602 }
1603 ANGLE_CAPTURE(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname, bufSize,
1604 length, params);
1605 }
1606 else
1607 {}
1608 }
1609
GL_GetRenderbufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1610 void GL_APIENTRY GL_GetRenderbufferParameterivRobustANGLE(GLenum target,
1611 GLenum pname,
1612 GLsizei bufSize,
1613 GLsizei *length,
1614 GLint *params)
1615 {
1616 Context *context = GetValidGlobalContext();
1617 EVENT(context, GLGetRenderbufferParameterivRobustANGLE,
1618 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1619 ", params = 0x%016" PRIxPTR "",
1620 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1621 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1622 (uintptr_t)params);
1623
1624 if (context)
1625 {
1626 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1627 bool isCallValid = (context->skipValidation() ||
1628 ValidateGetRenderbufferParameterivRobustANGLE(
1629 context, angle::EntryPoint::GLGetRenderbufferParameterivRobustANGLE,
1630 target, pname, bufSize, length, params));
1631 if (isCallValid)
1632 {
1633 context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
1634 }
1635 ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname,
1636 bufSize, length, params);
1637 }
1638 else
1639 {
1640 GenerateContextLostErrorOnCurrentGlobalContext();
1641 }
1642 }
1643
GL_GetShaderivRobustANGLE(GLuint shader,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1644 void GL_APIENTRY GL_GetShaderivRobustANGLE(GLuint shader,
1645 GLenum pname,
1646 GLsizei bufSize,
1647 GLsizei *length,
1648 GLint *params)
1649 {
1650 Context *context = GetGlobalContext();
1651 EVENT(context, GLGetShaderivRobustANGLE,
1652 "context = %d, shader = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1653 ", params = 0x%016" PRIxPTR "",
1654 CID(context), shader, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1655 (uintptr_t)length, (uintptr_t)params);
1656
1657 if (context)
1658 {
1659 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
1660 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1661 bool isCallValid =
1662 (context->skipValidation() ||
1663 ValidateGetShaderivRobustANGLE(context, angle::EntryPoint::GLGetShaderivRobustANGLE,
1664 shaderPacked, pname, bufSize, length, params));
1665 if (isCallValid)
1666 {
1667 context->getShaderivRobust(shaderPacked, pname, bufSize, length, params);
1668 }
1669 ANGLE_CAPTURE(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize,
1670 length, params);
1671 }
1672 else
1673 {}
1674 }
1675
GL_GetTexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1676 void GL_APIENTRY GL_GetTexParameterfvRobustANGLE(GLenum target,
1677 GLenum pname,
1678 GLsizei bufSize,
1679 GLsizei *length,
1680 GLfloat *params)
1681 {
1682 Context *context = GetValidGlobalContext();
1683 EVENT(context, GLGetTexParameterfvRobustANGLE,
1684 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1685 ", params = 0x%016" PRIxPTR "",
1686 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1687 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1688 (uintptr_t)params);
1689
1690 if (context)
1691 {
1692 TextureType targetPacked = PackParam<TextureType>(target);
1693 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1694 bool isCallValid = (context->skipValidation() ||
1695 ValidateGetTexParameterfvRobustANGLE(
1696 context, angle::EntryPoint::GLGetTexParameterfvRobustANGLE,
1697 targetPacked, pname, bufSize, length, params));
1698 if (isCallValid)
1699 {
1700 context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
1701 }
1702 ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname,
1703 bufSize, length, params);
1704 }
1705 else
1706 {
1707 GenerateContextLostErrorOnCurrentGlobalContext();
1708 }
1709 }
1710
GL_GetTexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1711 void GL_APIENTRY GL_GetTexParameterivRobustANGLE(GLenum target,
1712 GLenum pname,
1713 GLsizei bufSize,
1714 GLsizei *length,
1715 GLint *params)
1716 {
1717 Context *context = GetValidGlobalContext();
1718 EVENT(context, GLGetTexParameterivRobustANGLE,
1719 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1720 ", params = 0x%016" PRIxPTR "",
1721 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
1722 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
1723 (uintptr_t)params);
1724
1725 if (context)
1726 {
1727 TextureType targetPacked = PackParam<TextureType>(target);
1728 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1729 bool isCallValid = (context->skipValidation() ||
1730 ValidateGetTexParameterivRobustANGLE(
1731 context, angle::EntryPoint::GLGetTexParameterivRobustANGLE,
1732 targetPacked, pname, bufSize, length, params));
1733 if (isCallValid)
1734 {
1735 context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
1736 }
1737 ANGLE_CAPTURE(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
1738 bufSize, length, params);
1739 }
1740 else
1741 {
1742 GenerateContextLostErrorOnCurrentGlobalContext();
1743 }
1744 }
1745
GL_GetUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)1746 void GL_APIENTRY GL_GetUniformfvRobustANGLE(GLuint program,
1747 GLint location,
1748 GLsizei bufSize,
1749 GLsizei *length,
1750 GLfloat *params)
1751 {
1752 Context *context = GetValidGlobalContext();
1753 EVENT(context, GLGetUniformfvRobustANGLE,
1754 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
1755 ", params = 0x%016" PRIxPTR "",
1756 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1757
1758 if (context)
1759 {
1760 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1761 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1762 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1763 bool isCallValid = (context->skipValidation() ||
1764 ValidateGetUniformfvRobustANGLE(
1765 context, angle::EntryPoint::GLGetUniformfvRobustANGLE,
1766 programPacked, locationPacked, bufSize, length, params));
1767 if (isCallValid)
1768 {
1769 context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
1770 }
1771 ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
1772 bufSize, length, params);
1773 }
1774 else
1775 {
1776 GenerateContextLostErrorOnCurrentGlobalContext();
1777 }
1778 }
1779
GL_GetUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)1780 void GL_APIENTRY GL_GetUniformivRobustANGLE(GLuint program,
1781 GLint location,
1782 GLsizei bufSize,
1783 GLsizei *length,
1784 GLint *params)
1785 {
1786 Context *context = GetValidGlobalContext();
1787 EVENT(context, GLGetUniformivRobustANGLE,
1788 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
1789 ", params = 0x%016" PRIxPTR "",
1790 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1791
1792 if (context)
1793 {
1794 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1795 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1796 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1797 bool isCallValid = (context->skipValidation() ||
1798 ValidateGetUniformivRobustANGLE(
1799 context, angle::EntryPoint::GLGetUniformivRobustANGLE,
1800 programPacked, locationPacked, bufSize, length, params));
1801 if (isCallValid)
1802 {
1803 context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
1804 }
1805 ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
1806 bufSize, length, params);
1807 }
1808 else
1809 {
1810 GenerateContextLostErrorOnCurrentGlobalContext();
1811 }
1812 }
1813
GL_GetVertexAttribfvRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1814 void GL_APIENTRY GL_GetVertexAttribfvRobustANGLE(GLuint index,
1815 GLenum pname,
1816 GLsizei bufSize,
1817 GLsizei *length,
1818 GLfloat *params)
1819 {
1820 Context *context = GetValidGlobalContext();
1821 EVENT(context, GLGetVertexAttribfvRobustANGLE,
1822 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1823 ", params = 0x%016" PRIxPTR "",
1824 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1825 (uintptr_t)length, (uintptr_t)params);
1826
1827 if (context)
1828 {
1829 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1830 bool isCallValid = (context->skipValidation() ||
1831 ValidateGetVertexAttribfvRobustANGLE(
1832 context, angle::EntryPoint::GLGetVertexAttribfvRobustANGLE, index,
1833 pname, bufSize, length, params));
1834 if (isCallValid)
1835 {
1836 context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
1837 }
1838 ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize,
1839 length, params);
1840 }
1841 else
1842 {
1843 GenerateContextLostErrorOnCurrentGlobalContext();
1844 }
1845 }
1846
GL_GetVertexAttribivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1847 void GL_APIENTRY GL_GetVertexAttribivRobustANGLE(GLuint index,
1848 GLenum pname,
1849 GLsizei bufSize,
1850 GLsizei *length,
1851 GLint *params)
1852 {
1853 Context *context = GetValidGlobalContext();
1854 EVENT(context, GLGetVertexAttribivRobustANGLE,
1855 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1856 ", params = 0x%016" PRIxPTR "",
1857 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1858 (uintptr_t)length, (uintptr_t)params);
1859
1860 if (context)
1861 {
1862 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1863 bool isCallValid = (context->skipValidation() ||
1864 ValidateGetVertexAttribivRobustANGLE(
1865 context, angle::EntryPoint::GLGetVertexAttribivRobustANGLE, index,
1866 pname, bufSize, length, params));
1867 if (isCallValid)
1868 {
1869 context->getVertexAttribivRobust(index, pname, bufSize, length, params);
1870 }
1871 ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize,
1872 length, params);
1873 }
1874 else
1875 {
1876 GenerateContextLostErrorOnCurrentGlobalContext();
1877 }
1878 }
1879
GL_GetVertexAttribPointervRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)1880 void GL_APIENTRY GL_GetVertexAttribPointervRobustANGLE(GLuint index,
1881 GLenum pname,
1882 GLsizei bufSize,
1883 GLsizei *length,
1884 void **pointer)
1885 {
1886 Context *context = GetValidGlobalContext();
1887 EVENT(context, GLGetVertexAttribPointervRobustANGLE,
1888 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1889 ", pointer = 0x%016" PRIxPTR "",
1890 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
1891 (uintptr_t)length, (uintptr_t)pointer);
1892
1893 if (context)
1894 {
1895 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1896 bool isCallValid = (context->skipValidation() ||
1897 ValidateGetVertexAttribPointervRobustANGLE(
1898 context, angle::EntryPoint::GLGetVertexAttribPointervRobustANGLE,
1899 index, pname, bufSize, length, pointer));
1900 if (isCallValid)
1901 {
1902 context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
1903 }
1904 ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname,
1905 bufSize, length, pointer);
1906 }
1907 else
1908 {
1909 GenerateContextLostErrorOnCurrentGlobalContext();
1910 }
1911 }
1912
GL_ReadPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * pixels)1913 void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x,
1914 GLint y,
1915 GLsizei width,
1916 GLsizei height,
1917 GLenum format,
1918 GLenum type,
1919 GLsizei bufSize,
1920 GLsizei *length,
1921 GLsizei *columns,
1922 GLsizei *rows,
1923 void *pixels)
1924 {
1925 Context *context = GetValidGlobalContext();
1926 EVENT(context, GLReadPixelsRobustANGLE,
1927 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
1928 "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR
1929 ", pixels = 0x%016" PRIxPTR "",
1930 CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
1931 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
1932 (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)pixels);
1933
1934 if (context)
1935 {
1936 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1937 bool isCallValid = (context->skipValidation() ||
1938 ValidateReadPixelsRobustANGLE(
1939 context, angle::EntryPoint::GLReadPixelsRobustANGLE, x, y, width,
1940 height, format, type, bufSize, length, columns, rows, pixels));
1941 if (isCallValid)
1942 {
1943 context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
1944 rows, pixels);
1945 }
1946 ANGLE_CAPTURE(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
1947 type, bufSize, length, columns, rows, pixels);
1948 }
1949 else
1950 {
1951 GenerateContextLostErrorOnCurrentGlobalContext();
1952 }
1953 }
1954
GL_TexImage2DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)1955 void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target,
1956 GLint level,
1957 GLint internalformat,
1958 GLsizei width,
1959 GLsizei height,
1960 GLint border,
1961 GLenum format,
1962 GLenum type,
1963 GLsizei bufSize,
1964 const void *pixels)
1965 {
1966 Context *context = GetValidGlobalContext();
1967 EVENT(context, GLTexImage2DRobustANGLE,
1968 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
1969 "border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "",
1970 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
1971 width, height, border, GLenumToString(GLenumGroup::DefaultGroup, format),
1972 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
1973
1974 if (context)
1975 {
1976 TextureTarget targetPacked = PackParam<TextureTarget>(target);
1977 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1978 bool isCallValid =
1979 (context->skipValidation() ||
1980 ValidateTexImage2DRobustANGLE(context, angle::EntryPoint::GLTexImage2DRobustANGLE,
1981 targetPacked, level, internalformat, width, height,
1982 border, format, type, bufSize, pixels));
1983 if (isCallValid)
1984 {
1985 context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
1986 format, type, bufSize, pixels);
1987 }
1988 ANGLE_CAPTURE(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
1989 internalformat, width, height, border, format, type, bufSize, pixels);
1990 }
1991 else
1992 {
1993 GenerateContextLostErrorOnCurrentGlobalContext();
1994 }
1995 }
1996
GL_TexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLfloat * params)1997 void GL_APIENTRY GL_TexParameterfvRobustANGLE(GLenum target,
1998 GLenum pname,
1999 GLsizei bufSize,
2000 const GLfloat *params)
2001 {
2002 Context *context = GetValidGlobalContext();
2003 EVENT(context, GLTexParameterfvRobustANGLE,
2004 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
2005 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2006 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
2007
2008 if (context)
2009 {
2010 TextureType targetPacked = PackParam<TextureType>(target);
2011 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2012 bool isCallValid = (context->skipValidation() ||
2013 ValidateTexParameterfvRobustANGLE(
2014 context, angle::EntryPoint::GLTexParameterfvRobustANGLE,
2015 targetPacked, pname, bufSize, params));
2016 if (isCallValid)
2017 {
2018 context->texParameterfvRobust(targetPacked, pname, bufSize, params);
2019 }
2020 ANGLE_CAPTURE(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
2021 params);
2022 }
2023 else
2024 {
2025 GenerateContextLostErrorOnCurrentGlobalContext();
2026 }
2027 }
2028
GL_TexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)2029 void GL_APIENTRY GL_TexParameterivRobustANGLE(GLenum target,
2030 GLenum pname,
2031 GLsizei bufSize,
2032 const GLint *params)
2033 {
2034 Context *context = GetValidGlobalContext();
2035 EVENT(context, GLTexParameterivRobustANGLE,
2036 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
2037 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2038 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
2039
2040 if (context)
2041 {
2042 TextureType targetPacked = PackParam<TextureType>(target);
2043 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2044 bool isCallValid = (context->skipValidation() ||
2045 ValidateTexParameterivRobustANGLE(
2046 context, angle::EntryPoint::GLTexParameterivRobustANGLE,
2047 targetPacked, pname, bufSize, params));
2048 if (isCallValid)
2049 {
2050 context->texParameterivRobust(targetPacked, pname, bufSize, params);
2051 }
2052 ANGLE_CAPTURE(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
2053 params);
2054 }
2055 else
2056 {
2057 GenerateContextLostErrorOnCurrentGlobalContext();
2058 }
2059 }
2060
GL_TexSubImage2DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2061 void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target,
2062 GLint level,
2063 GLint xoffset,
2064 GLint yoffset,
2065 GLsizei width,
2066 GLsizei height,
2067 GLenum format,
2068 GLenum type,
2069 GLsizei bufSize,
2070 const void *pixels)
2071 {
2072 Context *context = GetValidGlobalContext();
2073 EVENT(context, GLTexSubImage2DRobustANGLE,
2074 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
2075 "%d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "",
2076 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
2077 width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
2078 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
2079
2080 if (context)
2081 {
2082 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2083 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2084 bool isCallValid =
2085 (context->skipValidation() ||
2086 ValidateTexSubImage2DRobustANGLE(
2087 context, angle::EntryPoint::GLTexSubImage2DRobustANGLE, targetPacked, level,
2088 xoffset, yoffset, width, height, format, type, bufSize, pixels));
2089 if (isCallValid)
2090 {
2091 context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
2092 format, type, bufSize, pixels);
2093 }
2094 ANGLE_CAPTURE(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
2095 yoffset, width, height, format, type, bufSize, pixels);
2096 }
2097 else
2098 {
2099 GenerateContextLostErrorOnCurrentGlobalContext();
2100 }
2101 }
2102
GL_TexImage3DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2103 void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target,
2104 GLint level,
2105 GLint internalformat,
2106 GLsizei width,
2107 GLsizei height,
2108 GLsizei depth,
2109 GLint border,
2110 GLenum format,
2111 GLenum type,
2112 GLsizei bufSize,
2113 const void *pixels)
2114 {
2115 Context *context = GetValidGlobalContext();
2116 EVENT(context, GLTexImage3DRobustANGLE,
2117 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
2118 "depth = %d, border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR
2119 "",
2120 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat,
2121 width, height, depth, border, GLenumToString(GLenumGroup::DefaultGroup, format),
2122 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
2123
2124 if (context)
2125 {
2126 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2127 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2128 bool isCallValid =
2129 (context->skipValidation() ||
2130 ValidateTexImage3DRobustANGLE(context, angle::EntryPoint::GLTexImage3DRobustANGLE,
2131 targetPacked, level, internalformat, width, height,
2132 depth, border, format, type, bufSize, pixels));
2133 if (isCallValid)
2134 {
2135 context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
2136 border, format, type, bufSize, pixels);
2137 }
2138 ANGLE_CAPTURE(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
2139 internalformat, width, height, depth, border, format, type, bufSize, pixels);
2140 }
2141 else
2142 {
2143 GenerateContextLostErrorOnCurrentGlobalContext();
2144 }
2145 }
2146
GL_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)2147 void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target,
2148 GLint level,
2149 GLint xoffset,
2150 GLint yoffset,
2151 GLint zoffset,
2152 GLsizei width,
2153 GLsizei height,
2154 GLsizei depth,
2155 GLenum format,
2156 GLenum type,
2157 GLsizei bufSize,
2158 const void *pixels)
2159 {
2160 Context *context = GetValidGlobalContext();
2161 EVENT(
2162 context, GLTexSubImage3DRobustANGLE,
2163 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width = "
2164 "%d, height = %d, depth = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR
2165 "",
2166 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
2167 zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
2168 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels);
2169
2170 if (context)
2171 {
2172 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2173 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2174 bool isCallValid =
2175 (context->skipValidation() ||
2176 ValidateTexSubImage3DRobustANGLE(
2177 context, angle::EntryPoint::GLTexSubImage3DRobustANGLE, targetPacked, level,
2178 xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels));
2179 if (isCallValid)
2180 {
2181 context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
2182 height, depth, format, type, bufSize, pixels);
2183 }
2184 ANGLE_CAPTURE(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, xoffset,
2185 yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
2186 }
2187 else
2188 {
2189 GenerateContextLostErrorOnCurrentGlobalContext();
2190 }
2191 }
2192
GL_CompressedTexImage2DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2193 void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target,
2194 GLint level,
2195 GLenum internalformat,
2196 GLsizei width,
2197 GLsizei height,
2198 GLint border,
2199 GLsizei imageSize,
2200 GLsizei dataSize,
2201 const GLvoid *data)
2202 {
2203 Context *context = GetValidGlobalContext();
2204 EVENT(context, GLCompressedTexImage2DRobustANGLE,
2205 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
2206 "border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
2207 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2208 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, border,
2209 imageSize, dataSize, (uintptr_t)data);
2210
2211 if (context)
2212 {
2213 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2214 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2215 bool isCallValid =
2216 (context->skipValidation() ||
2217 ValidateCompressedTexImage2DRobustANGLE(
2218 context, angle::EntryPoint::GLCompressedTexImage2DRobustANGLE, targetPacked, level,
2219 internalformat, width, height, border, imageSize, dataSize, data));
2220 if (isCallValid)
2221 {
2222 context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
2223 border, imageSize, dataSize, data);
2224 }
2225 ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
2226 internalformat, width, height, border, imageSize, dataSize, data);
2227 }
2228 else
2229 {
2230 GenerateContextLostErrorOnCurrentGlobalContext();
2231 }
2232 }
2233
GL_CompressedTexSubImage2DRobustANGLE(GLenum target,GLint level,GLsizei xoffset,GLsizei yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2234 void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target,
2235 GLint level,
2236 GLsizei xoffset,
2237 GLsizei yoffset,
2238 GLsizei width,
2239 GLsizei height,
2240 GLenum format,
2241 GLsizei imageSize,
2242 GLsizei dataSize,
2243 const GLvoid *data)
2244 {
2245 Context *context = GetValidGlobalContext();
2246 EVENT(context, GLCompressedTexSubImage2DRobustANGLE,
2247 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
2248 "%d, format = %s, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
2249 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
2250 width, height, GLenumToString(GLenumGroup::DefaultGroup, format), imageSize, dataSize,
2251 (uintptr_t)data);
2252
2253 if (context)
2254 {
2255 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2256 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2257 bool isCallValid =
2258 (context->skipValidation() ||
2259 ValidateCompressedTexSubImage2DRobustANGLE(
2260 context, angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE, targetPacked,
2261 level, xoffset, yoffset, width, height, format, imageSize, dataSize, data));
2262 if (isCallValid)
2263 {
2264 context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
2265 height, format, imageSize, dataSize, data);
2266 }
2267 ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level,
2268 xoffset, yoffset, width, height, format, imageSize, dataSize, data);
2269 }
2270 else
2271 {
2272 GenerateContextLostErrorOnCurrentGlobalContext();
2273 }
2274 }
2275
GL_CompressedTexImage3DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2276 void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target,
2277 GLint level,
2278 GLenum internalformat,
2279 GLsizei width,
2280 GLsizei height,
2281 GLsizei depth,
2282 GLint border,
2283 GLsizei imageSize,
2284 GLsizei dataSize,
2285 const GLvoid *data)
2286 {
2287 Context *context = GetValidGlobalContext();
2288 EVENT(context, GLCompressedTexImage3DRobustANGLE,
2289 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
2290 "depth = %d, border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
2291 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
2292 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, depth, border,
2293 imageSize, dataSize, (uintptr_t)data);
2294
2295 if (context)
2296 {
2297 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2298 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2299 bool isCallValid =
2300 (context->skipValidation() ||
2301 ValidateCompressedTexImage3DRobustANGLE(
2302 context, angle::EntryPoint::GLCompressedTexImage3DRobustANGLE, targetPacked, level,
2303 internalformat, width, height, depth, border, imageSize, dataSize, data));
2304 if (isCallValid)
2305 {
2306 context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
2307 depth, border, imageSize, dataSize, data);
2308 }
2309 ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
2310 internalformat, width, height, depth, border, imageSize, dataSize, data);
2311 }
2312 else
2313 {
2314 GenerateContextLostErrorOnCurrentGlobalContext();
2315 }
2316 }
2317
GL_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)2318 void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target,
2319 GLint level,
2320 GLint xoffset,
2321 GLint yoffset,
2322 GLint zoffset,
2323 GLsizei width,
2324 GLsizei height,
2325 GLsizei depth,
2326 GLenum format,
2327 GLsizei imageSize,
2328 GLsizei dataSize,
2329 const GLvoid *data)
2330 {
2331 Context *context = GetValidGlobalContext();
2332 EVENT(context, GLCompressedTexSubImage3DRobustANGLE,
2333 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
2334 "= %d, height = %d, depth = %d, format = %s, imageSize = %d, dataSize = %d, data = "
2335 "0x%016" PRIxPTR "",
2336 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
2337 zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format),
2338 imageSize, dataSize, (uintptr_t)data);
2339
2340 if (context)
2341 {
2342 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2343 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2344 bool isCallValid = (context->skipValidation() ||
2345 ValidateCompressedTexSubImage3DRobustANGLE(
2346 context, angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE,
2347 targetPacked, level, xoffset, yoffset, zoffset, width, height,
2348 depth, format, imageSize, dataSize, data));
2349 if (isCallValid)
2350 {
2351 context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
2352 width, height, depth, format, imageSize,
2353 dataSize, data);
2354 }
2355 ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level,
2356 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
2357 data);
2358 }
2359 else
2360 {
2361 GenerateContextLostErrorOnCurrentGlobalContext();
2362 }
2363 }
2364
GL_GetQueryivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2365 void GL_APIENTRY GL_GetQueryivRobustANGLE(GLenum target,
2366 GLenum pname,
2367 GLsizei bufSize,
2368 GLsizei *length,
2369 GLint *params)
2370 {
2371 Context *context = GetValidGlobalContext();
2372 EVENT(context, GLGetQueryivRobustANGLE,
2373 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2374 ", params = 0x%016" PRIxPTR "",
2375 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2376 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2377 (uintptr_t)params);
2378
2379 if (context)
2380 {
2381 QueryType targetPacked = PackParam<QueryType>(target);
2382 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2383 bool isCallValid =
2384 (context->skipValidation() ||
2385 ValidateGetQueryivRobustANGLE(context, angle::EntryPoint::GLGetQueryivRobustANGLE,
2386 targetPacked, pname, bufSize, length, params));
2387 if (isCallValid)
2388 {
2389 context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
2390 }
2391 ANGLE_CAPTURE(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
2392 length, params);
2393 }
2394 else
2395 {
2396 GenerateContextLostErrorOnCurrentGlobalContext();
2397 }
2398 }
2399
GL_GetQueryObjectuivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2400 void GL_APIENTRY GL_GetQueryObjectuivRobustANGLE(GLuint id,
2401 GLenum pname,
2402 GLsizei bufSize,
2403 GLsizei *length,
2404 GLuint *params)
2405 {
2406 Context *context = GetValidGlobalContext();
2407 EVENT(context, GLGetQueryObjectuivRobustANGLE,
2408 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2409 ", params = 0x%016" PRIxPTR "",
2410 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2411 (uintptr_t)length, (uintptr_t)params);
2412
2413 if (context)
2414 {
2415 QueryID idPacked = PackParam<QueryID>(id);
2416 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2417 bool isCallValid = (context->skipValidation() ||
2418 ValidateGetQueryObjectuivRobustANGLE(
2419 context, angle::EntryPoint::GLGetQueryObjectuivRobustANGLE,
2420 idPacked, pname, bufSize, length, params));
2421 if (isCallValid)
2422 {
2423 context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params);
2424 }
2425 ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
2426 length, params);
2427 }
2428 else
2429 {
2430 GenerateContextLostErrorOnCurrentGlobalContext();
2431 }
2432 }
2433
GL_GetBufferPointervRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2434 void GL_APIENTRY GL_GetBufferPointervRobustANGLE(GLenum target,
2435 GLenum pname,
2436 GLsizei bufSize,
2437 GLsizei *length,
2438 void **params)
2439 {
2440 Context *context = GetValidGlobalContext();
2441 EVENT(context, GLGetBufferPointervRobustANGLE,
2442 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2443 ", params = 0x%016" PRIxPTR "",
2444 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2445 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2446 (uintptr_t)params);
2447
2448 if (context)
2449 {
2450 BufferBinding targetPacked = PackParam<BufferBinding>(target);
2451 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2452 bool isCallValid = (context->skipValidation() ||
2453 ValidateGetBufferPointervRobustANGLE(
2454 context, angle::EntryPoint::GLGetBufferPointervRobustANGLE,
2455 targetPacked, pname, bufSize, length, params));
2456 if (isCallValid)
2457 {
2458 context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
2459 }
2460 ANGLE_CAPTURE(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname,
2461 bufSize, length, params);
2462 }
2463 else
2464 {
2465 GenerateContextLostErrorOnCurrentGlobalContext();
2466 }
2467 }
2468
GL_GetIntegeri_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)2469 void GL_APIENTRY GL_GetIntegeri_vRobustANGLE(GLenum target,
2470 GLuint index,
2471 GLsizei bufSize,
2472 GLsizei *length,
2473 GLint *data)
2474 {
2475 Context *context = GetValidGlobalContext();
2476 EVENT(context, GLGetIntegeri_vRobustANGLE,
2477 "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2478 ", data = 0x%016" PRIxPTR "",
2479 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2480 (uintptr_t)length, (uintptr_t)data);
2481
2482 if (context)
2483 {
2484 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2485 bool isCallValid = (context->skipValidation() ||
2486 ValidateGetIntegeri_vRobustANGLE(
2487 context, angle::EntryPoint::GLGetIntegeri_vRobustANGLE, target,
2488 index, bufSize, length, data));
2489 if (isCallValid)
2490 {
2491 context->getIntegeri_vRobust(target, index, bufSize, length, data);
2492 }
2493 ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize,
2494 length, data);
2495 }
2496 else
2497 {
2498 GenerateContextLostErrorOnCurrentGlobalContext();
2499 }
2500 }
2501
GL_GetInternalformativRobustANGLE(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2502 void GL_APIENTRY GL_GetInternalformativRobustANGLE(GLenum target,
2503 GLenum internalformat,
2504 GLenum pname,
2505 GLsizei bufSize,
2506 GLsizei *length,
2507 GLint *params)
2508 {
2509 Context *context = GetValidGlobalContext();
2510 EVENT(context, GLGetInternalformativRobustANGLE,
2511 "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, length = "
2512 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2513 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2514 GLenumToString(GLenumGroup::DefaultGroup, internalformat),
2515 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2516 (uintptr_t)params);
2517
2518 if (context)
2519 {
2520 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2521 bool isCallValid = (context->skipValidation() ||
2522 ValidateGetInternalformativRobustANGLE(
2523 context, angle::EntryPoint::GLGetInternalformativRobustANGLE,
2524 target, internalformat, pname, bufSize, length, params));
2525 if (isCallValid)
2526 {
2527 context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
2528 params);
2529 }
2530 ANGLE_CAPTURE(GetInternalformativRobustANGLE, isCallValid, context, target, internalformat,
2531 pname, bufSize, length, params);
2532 }
2533 else
2534 {
2535 GenerateContextLostErrorOnCurrentGlobalContext();
2536 }
2537 }
2538
GL_GetVertexAttribIivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2539 void GL_APIENTRY GL_GetVertexAttribIivRobustANGLE(GLuint index,
2540 GLenum pname,
2541 GLsizei bufSize,
2542 GLsizei *length,
2543 GLint *params)
2544 {
2545 Context *context = GetValidGlobalContext();
2546 EVENT(context, GLGetVertexAttribIivRobustANGLE,
2547 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2548 ", params = 0x%016" PRIxPTR "",
2549 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2550 (uintptr_t)length, (uintptr_t)params);
2551
2552 if (context)
2553 {
2554 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2555 bool isCallValid = (context->skipValidation() ||
2556 ValidateGetVertexAttribIivRobustANGLE(
2557 context, angle::EntryPoint::GLGetVertexAttribIivRobustANGLE, index,
2558 pname, bufSize, length, params));
2559 if (isCallValid)
2560 {
2561 context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
2562 }
2563 ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize,
2564 length, params);
2565 }
2566 else
2567 {
2568 GenerateContextLostErrorOnCurrentGlobalContext();
2569 }
2570 }
2571
GL_GetVertexAttribIuivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2572 void GL_APIENTRY GL_GetVertexAttribIuivRobustANGLE(GLuint index,
2573 GLenum pname,
2574 GLsizei bufSize,
2575 GLsizei *length,
2576 GLuint *params)
2577 {
2578 Context *context = GetValidGlobalContext();
2579 EVENT(context, GLGetVertexAttribIuivRobustANGLE,
2580 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2581 ", params = 0x%016" PRIxPTR "",
2582 CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2583 (uintptr_t)length, (uintptr_t)params);
2584
2585 if (context)
2586 {
2587 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2588 bool isCallValid = (context->skipValidation() ||
2589 ValidateGetVertexAttribIuivRobustANGLE(
2590 context, angle::EntryPoint::GLGetVertexAttribIuivRobustANGLE, index,
2591 pname, bufSize, length, params));
2592 if (isCallValid)
2593 {
2594 context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
2595 }
2596 ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname, bufSize,
2597 length, params);
2598 }
2599 else
2600 {
2601 GenerateContextLostErrorOnCurrentGlobalContext();
2602 }
2603 }
2604
GL_GetUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)2605 void GL_APIENTRY GL_GetUniformuivRobustANGLE(GLuint program,
2606 GLint location,
2607 GLsizei bufSize,
2608 GLsizei *length,
2609 GLuint *params)
2610 {
2611 Context *context = GetValidGlobalContext();
2612 EVENT(context, GLGetUniformuivRobustANGLE,
2613 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
2614 ", params = 0x%016" PRIxPTR "",
2615 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2616
2617 if (context)
2618 {
2619 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2620 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2621 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2622 bool isCallValid = (context->skipValidation() ||
2623 ValidateGetUniformuivRobustANGLE(
2624 context, angle::EntryPoint::GLGetUniformuivRobustANGLE,
2625 programPacked, locationPacked, bufSize, length, params));
2626 if (isCallValid)
2627 {
2628 context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
2629 }
2630 ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, locationPacked,
2631 bufSize, length, params);
2632 }
2633 else
2634 {
2635 GenerateContextLostErrorOnCurrentGlobalContext();
2636 }
2637 }
2638
GL_GetActiveUniformBlockivRobustANGLE(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2639 void GL_APIENTRY GL_GetActiveUniformBlockivRobustANGLE(GLuint program,
2640 GLuint uniformBlockIndex,
2641 GLenum pname,
2642 GLsizei bufSize,
2643 GLsizei *length,
2644 GLint *params)
2645 {
2646 Context *context = GetValidGlobalContext();
2647 EVENT(context, GLGetActiveUniformBlockivRobustANGLE,
2648 "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, bufSize = %d, length = "
2649 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2650 CID(context), program, uniformBlockIndex,
2651 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2652 (uintptr_t)params);
2653
2654 if (context)
2655 {
2656 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2657 UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex);
2658 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2659 bool isCallValid =
2660 (context->skipValidation() ||
2661 ValidateGetActiveUniformBlockivRobustANGLE(
2662 context, angle::EntryPoint::GLGetActiveUniformBlockivRobustANGLE, programPacked,
2663 uniformBlockIndexPacked, pname, bufSize, length, params));
2664 if (isCallValid)
2665 {
2666 context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndexPacked, pname,
2667 bufSize, length, params);
2668 }
2669 ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked,
2670 uniformBlockIndexPacked, pname, bufSize, length, params);
2671 }
2672 else
2673 {
2674 GenerateContextLostErrorOnCurrentGlobalContext();
2675 }
2676 }
2677
GL_GetInteger64vRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)2678 void GL_APIENTRY GL_GetInteger64vRobustANGLE(GLenum pname,
2679 GLsizei bufSize,
2680 GLsizei *length,
2681 GLint64 *data)
2682 {
2683 Context *context = GetValidGlobalContext();
2684 EVENT(context, GLGetInteger64vRobustANGLE,
2685 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2686 ", data = 0x%016" PRIxPTR "",
2687 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2688 (uintptr_t)length, (uintptr_t)data);
2689
2690 if (context)
2691 {
2692 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2693 bool isCallValid = (context->skipValidation() ||
2694 ValidateGetInteger64vRobustANGLE(
2695 context, angle::EntryPoint::GLGetInteger64vRobustANGLE, pname,
2696 bufSize, length, data));
2697 if (isCallValid)
2698 {
2699 context->getInteger64vRobust(pname, bufSize, length, data);
2700 }
2701 ANGLE_CAPTURE(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length, data);
2702 }
2703 else
2704 {
2705 GenerateContextLostErrorOnCurrentGlobalContext();
2706 }
2707 }
2708
GL_GetInteger64i_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)2709 void GL_APIENTRY GL_GetInteger64i_vRobustANGLE(GLenum target,
2710 GLuint index,
2711 GLsizei bufSize,
2712 GLsizei *length,
2713 GLint64 *data)
2714 {
2715 Context *context = GetValidGlobalContext();
2716 EVENT(context, GLGetInteger64i_vRobustANGLE,
2717 "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2718 ", data = 0x%016" PRIxPTR "",
2719 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2720 (uintptr_t)length, (uintptr_t)data);
2721
2722 if (context)
2723 {
2724 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2725 bool isCallValid = (context->skipValidation() ||
2726 ValidateGetInteger64i_vRobustANGLE(
2727 context, angle::EntryPoint::GLGetInteger64i_vRobustANGLE, target,
2728 index, bufSize, length, data));
2729 if (isCallValid)
2730 {
2731 context->getInteger64i_vRobust(target, index, bufSize, length, data);
2732 }
2733 ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize,
2734 length, data);
2735 }
2736 else
2737 {
2738 GenerateContextLostErrorOnCurrentGlobalContext();
2739 }
2740 }
2741
GL_GetBufferParameteri64vRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)2742 void GL_APIENTRY GL_GetBufferParameteri64vRobustANGLE(GLenum target,
2743 GLenum pname,
2744 GLsizei bufSize,
2745 GLsizei *length,
2746 GLint64 *params)
2747 {
2748 Context *context = GetValidGlobalContext();
2749 EVENT(context, GLGetBufferParameteri64vRobustANGLE,
2750 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2751 ", params = 0x%016" PRIxPTR "",
2752 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2753 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2754 (uintptr_t)params);
2755
2756 if (context)
2757 {
2758 BufferBinding targetPacked = PackParam<BufferBinding>(target);
2759 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2760 bool isCallValid = (context->skipValidation() ||
2761 ValidateGetBufferParameteri64vRobustANGLE(
2762 context, angle::EntryPoint::GLGetBufferParameteri64vRobustANGLE,
2763 targetPacked, pname, bufSize, length, params));
2764 if (isCallValid)
2765 {
2766 context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
2767 }
2768 ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked, pname,
2769 bufSize, length, params);
2770 }
2771 else
2772 {
2773 GenerateContextLostErrorOnCurrentGlobalContext();
2774 }
2775 }
2776
GL_SamplerParameterivRobustANGLE(GLuint sampler,GLuint pname,GLsizei bufSize,const GLint * param)2777 void GL_APIENTRY GL_SamplerParameterivRobustANGLE(GLuint sampler,
2778 GLuint pname,
2779 GLsizei bufSize,
2780 const GLint *param)
2781 {
2782 Context *context = GetValidGlobalContext();
2783 EVENT(context, GLSamplerParameterivRobustANGLE,
2784 "context = %d, sampler = %u, pname = %u, bufSize = %d, param = 0x%016" PRIxPTR "",
2785 CID(context), sampler, pname, bufSize, (uintptr_t)param);
2786
2787 if (context)
2788 {
2789 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2790 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2791 bool isCallValid = (context->skipValidation() ||
2792 ValidateSamplerParameterivRobustANGLE(
2793 context, angle::EntryPoint::GLSamplerParameterivRobustANGLE,
2794 samplerPacked, pname, bufSize, param));
2795 if (isCallValid)
2796 {
2797 context->samplerParameterivRobust(samplerPacked, pname, bufSize, param);
2798 }
2799 ANGLE_CAPTURE(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
2800 bufSize, param);
2801 }
2802 else
2803 {
2804 GenerateContextLostErrorOnCurrentGlobalContext();
2805 }
2806 }
2807
GL_SamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLfloat * param)2808 void GL_APIENTRY GL_SamplerParameterfvRobustANGLE(GLuint sampler,
2809 GLenum pname,
2810 GLsizei bufSize,
2811 const GLfloat *param)
2812 {
2813 Context *context = GetValidGlobalContext();
2814 EVENT(context, GLSamplerParameterfvRobustANGLE,
2815 "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
2816 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2817 (uintptr_t)param);
2818
2819 if (context)
2820 {
2821 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2822 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2823 bool isCallValid = (context->skipValidation() ||
2824 ValidateSamplerParameterfvRobustANGLE(
2825 context, angle::EntryPoint::GLSamplerParameterfvRobustANGLE,
2826 samplerPacked, pname, bufSize, param));
2827 if (isCallValid)
2828 {
2829 context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param);
2830 }
2831 ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
2832 bufSize, param);
2833 }
2834 else
2835 {
2836 GenerateContextLostErrorOnCurrentGlobalContext();
2837 }
2838 }
2839
GL_GetSamplerParameterivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2840 void GL_APIENTRY GL_GetSamplerParameterivRobustANGLE(GLuint sampler,
2841 GLenum pname,
2842 GLsizei bufSize,
2843 GLsizei *length,
2844 GLint *params)
2845 {
2846 Context *context = GetValidGlobalContext();
2847 EVENT(context, GLGetSamplerParameterivRobustANGLE,
2848 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2849 ", params = 0x%016" PRIxPTR "",
2850 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2851 (uintptr_t)length, (uintptr_t)params);
2852
2853 if (context)
2854 {
2855 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2857 bool isCallValid = (context->skipValidation() ||
2858 ValidateGetSamplerParameterivRobustANGLE(
2859 context, angle::EntryPoint::GLGetSamplerParameterivRobustANGLE,
2860 samplerPacked, pname, bufSize, length, params));
2861 if (isCallValid)
2862 {
2863 context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params);
2864 }
2865 ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
2866 bufSize, length, params);
2867 }
2868 else
2869 {
2870 GenerateContextLostErrorOnCurrentGlobalContext();
2871 }
2872 }
2873
GL_GetSamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2874 void GL_APIENTRY GL_GetSamplerParameterfvRobustANGLE(GLuint sampler,
2875 GLenum pname,
2876 GLsizei bufSize,
2877 GLsizei *length,
2878 GLfloat *params)
2879 {
2880 Context *context = GetValidGlobalContext();
2881 EVENT(context, GLGetSamplerParameterfvRobustANGLE,
2882 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2883 ", params = 0x%016" PRIxPTR "",
2884 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
2885 (uintptr_t)length, (uintptr_t)params);
2886
2887 if (context)
2888 {
2889 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
2890 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2891 bool isCallValid = (context->skipValidation() ||
2892 ValidateGetSamplerParameterfvRobustANGLE(
2893 context, angle::EntryPoint::GLGetSamplerParameterfvRobustANGLE,
2894 samplerPacked, pname, bufSize, length, params));
2895 if (isCallValid)
2896 {
2897 context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params);
2898 }
2899 ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
2900 bufSize, length, params);
2901 }
2902 else
2903 {
2904 GenerateContextLostErrorOnCurrentGlobalContext();
2905 }
2906 }
2907
GL_GetFramebufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2908 void GL_APIENTRY GL_GetFramebufferParameterivRobustANGLE(GLenum target,
2909 GLenum pname,
2910 GLsizei bufSize,
2911 GLsizei *length,
2912 GLint *params)
2913 {
2914 Context *context = GetValidGlobalContext();
2915 EVENT(context, GLGetFramebufferParameterivRobustANGLE,
2916 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2917 ", params = 0x%016" PRIxPTR "",
2918 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
2919 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2920 (uintptr_t)params);
2921
2922 if (context)
2923 {
2924 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2925 bool isCallValid = (context->skipValidation() ||
2926 ValidateGetFramebufferParameterivRobustANGLE(
2927 context, angle::EntryPoint::GLGetFramebufferParameterivRobustANGLE,
2928 target, pname, bufSize, length, params));
2929 if (isCallValid)
2930 {
2931 context->getFramebufferParameterivRobust(target, pname, bufSize, length, params);
2932 }
2933 ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname,
2934 bufSize, length, params);
2935 }
2936 else
2937 {
2938 GenerateContextLostErrorOnCurrentGlobalContext();
2939 }
2940 }
2941
GL_GetProgramInterfaceivRobustANGLE(GLuint program,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2942 void GL_APIENTRY GL_GetProgramInterfaceivRobustANGLE(GLuint program,
2943 GLenum programInterface,
2944 GLenum pname,
2945 GLsizei bufSize,
2946 GLsizei *length,
2947 GLint *params)
2948 {
2949 Context *context = GetValidGlobalContext();
2950 EVENT(context, GLGetProgramInterfaceivRobustANGLE,
2951 "context = %d, program = %u, programInterface = %s, pname = %s, bufSize = %d, length = "
2952 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2953 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, programInterface),
2954 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
2955 (uintptr_t)params);
2956
2957 if (context)
2958 {
2959 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2960 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2961 bool isCallValid = (context->skipValidation() ||
2962 ValidateGetProgramInterfaceivRobustANGLE(
2963 context, angle::EntryPoint::GLGetProgramInterfaceivRobustANGLE,
2964 programPacked, programInterface, pname, bufSize, length, params));
2965 if (isCallValid)
2966 {
2967 context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize,
2968 length, params);
2969 }
2970 ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked,
2971 programInterface, pname, bufSize, length, params);
2972 }
2973 else
2974 {
2975 GenerateContextLostErrorOnCurrentGlobalContext();
2976 }
2977 }
2978
GL_GetBooleani_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)2979 void GL_APIENTRY GL_GetBooleani_vRobustANGLE(GLenum target,
2980 GLuint index,
2981 GLsizei bufSize,
2982 GLsizei *length,
2983 GLboolean *data)
2984 {
2985 Context *context = GetValidGlobalContext();
2986 EVENT(context, GLGetBooleani_vRobustANGLE,
2987 "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2988 ", data = 0x%016" PRIxPTR "",
2989 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize,
2990 (uintptr_t)length, (uintptr_t)data);
2991
2992 if (context)
2993 {
2994 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2995 bool isCallValid = (context->skipValidation() ||
2996 ValidateGetBooleani_vRobustANGLE(
2997 context, angle::EntryPoint::GLGetBooleani_vRobustANGLE, target,
2998 index, bufSize, length, data));
2999 if (isCallValid)
3000 {
3001 context->getBooleani_vRobust(target, index, bufSize, length, data);
3002 }
3003 ANGLE_CAPTURE(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize,
3004 length, data);
3005 }
3006 else
3007 {
3008 GenerateContextLostErrorOnCurrentGlobalContext();
3009 }
3010 }
3011
GL_GetMultisamplefvRobustANGLE(GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)3012 void GL_APIENTRY GL_GetMultisamplefvRobustANGLE(GLenum pname,
3013 GLuint index,
3014 GLsizei bufSize,
3015 GLsizei *length,
3016 GLfloat *val)
3017 {
3018 Context *context = GetValidGlobalContext();
3019 EVENT(context, GLGetMultisamplefvRobustANGLE,
3020 "context = %d, pname = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
3021 ", val = 0x%016" PRIxPTR "",
3022 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, bufSize,
3023 (uintptr_t)length, (uintptr_t)val);
3024
3025 if (context)
3026 {
3027 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3028 bool isCallValid = (context->skipValidation() ||
3029 ValidateGetMultisamplefvRobustANGLE(
3030 context, angle::EntryPoint::GLGetMultisamplefvRobustANGLE, pname,
3031 index, bufSize, length, val));
3032 if (isCallValid)
3033 {
3034 context->getMultisamplefvRobust(pname, index, bufSize, length, val);
3035 }
3036 ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize,
3037 length, val);
3038 }
3039 else
3040 {
3041 GenerateContextLostErrorOnCurrentGlobalContext();
3042 }
3043 }
3044
GL_GetTexLevelParameterivRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3045 void GL_APIENTRY GL_GetTexLevelParameterivRobustANGLE(GLenum target,
3046 GLint level,
3047 GLenum pname,
3048 GLsizei bufSize,
3049 GLsizei *length,
3050 GLint *params)
3051 {
3052 Context *context = GetValidGlobalContext();
3053 EVENT(context, GLGetTexLevelParameterivRobustANGLE,
3054 "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3055 ", params = 0x%016" PRIxPTR "",
3056 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
3057 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
3058 (uintptr_t)params);
3059
3060 if (context)
3061 {
3062 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3063 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3064 bool isCallValid = (context->skipValidation() ||
3065 ValidateGetTexLevelParameterivRobustANGLE(
3066 context, angle::EntryPoint::GLGetTexLevelParameterivRobustANGLE,
3067 targetPacked, level, pname, bufSize, length, params));
3068 if (isCallValid)
3069 {
3070 context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
3071 params);
3072 }
3073 ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked, level,
3074 pname, bufSize, length, params);
3075 }
3076 else
3077 {
3078 GenerateContextLostErrorOnCurrentGlobalContext();
3079 }
3080 }
3081
GL_GetTexLevelParameterfvRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3082 void GL_APIENTRY GL_GetTexLevelParameterfvRobustANGLE(GLenum target,
3083 GLint level,
3084 GLenum pname,
3085 GLsizei bufSize,
3086 GLsizei *length,
3087 GLfloat *params)
3088 {
3089 Context *context = GetValidGlobalContext();
3090 EVENT(context, GLGetTexLevelParameterfvRobustANGLE,
3091 "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3092 ", params = 0x%016" PRIxPTR "",
3093 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level,
3094 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
3095 (uintptr_t)params);
3096
3097 if (context)
3098 {
3099 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3100 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3101 bool isCallValid = (context->skipValidation() ||
3102 ValidateGetTexLevelParameterfvRobustANGLE(
3103 context, angle::EntryPoint::GLGetTexLevelParameterfvRobustANGLE,
3104 targetPacked, level, pname, bufSize, length, params));
3105 if (isCallValid)
3106 {
3107 context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
3108 params);
3109 }
3110 ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked, level,
3111 pname, bufSize, length, params);
3112 }
3113 else
3114 {
3115 GenerateContextLostErrorOnCurrentGlobalContext();
3116 }
3117 }
3118
GL_GetPointervRobustANGLERobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)3119 void GL_APIENTRY GL_GetPointervRobustANGLERobustANGLE(GLenum pname,
3120 GLsizei bufSize,
3121 GLsizei *length,
3122 void **params)
3123 {
3124 Context *context = GetValidGlobalContext();
3125 EVENT(context, GLGetPointervRobustANGLERobustANGLE,
3126 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3127 ", params = 0x%016" PRIxPTR "",
3128 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3129 (uintptr_t)length, (uintptr_t)params);
3130
3131 if (context)
3132 {
3133 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3134 bool isCallValid = (context->skipValidation() ||
3135 ValidateGetPointervRobustANGLERobustANGLE(
3136 context, angle::EntryPoint::GLGetPointervRobustANGLERobustANGLE,
3137 pname, bufSize, length, params));
3138 if (isCallValid)
3139 {
3140 context->getPointervRobustANGLERobust(pname, bufSize, length, params);
3141 }
3142 ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize,
3143 length, params);
3144 }
3145 else
3146 {
3147 GenerateContextLostErrorOnCurrentGlobalContext();
3148 }
3149 }
3150
GL_ReadnPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * data)3151 void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x,
3152 GLint y,
3153 GLsizei width,
3154 GLsizei height,
3155 GLenum format,
3156 GLenum type,
3157 GLsizei bufSize,
3158 GLsizei *length,
3159 GLsizei *columns,
3160 GLsizei *rows,
3161 void *data)
3162 {
3163 Context *context = GetValidGlobalContext();
3164 EVENT(context, GLReadnPixelsRobustANGLE,
3165 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
3166 "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR
3167 ", data = 0x%016" PRIxPTR "",
3168 CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format),
3169 GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length,
3170 (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)data);
3171
3172 if (context)
3173 {
3174 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3175 bool isCallValid = (context->skipValidation() ||
3176 ValidateReadnPixelsRobustANGLE(
3177 context, angle::EntryPoint::GLReadnPixelsRobustANGLE, x, y, width,
3178 height, format, type, bufSize, length, columns, rows, data));
3179 if (isCallValid)
3180 {
3181 context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
3182 rows, data);
3183 }
3184 ANGLE_CAPTURE(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
3185 type, bufSize, length, columns, rows, data);
3186 }
3187 else
3188 {
3189 GenerateContextLostErrorOnCurrentGlobalContext();
3190 }
3191 }
3192
GL_GetnUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)3193 void GL_APIENTRY GL_GetnUniformfvRobustANGLE(GLuint program,
3194 GLint location,
3195 GLsizei bufSize,
3196 GLsizei *length,
3197 GLfloat *params)
3198 {
3199 Context *context = GetValidGlobalContext();
3200 EVENT(context, GLGetnUniformfvRobustANGLE,
3201 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
3202 ", params = 0x%016" PRIxPTR "",
3203 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
3204
3205 if (context)
3206 {
3207 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3208 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3209 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3210 bool isCallValid = (context->skipValidation() ||
3211 ValidateGetnUniformfvRobustANGLE(
3212 context, angle::EntryPoint::GLGetnUniformfvRobustANGLE,
3213 programPacked, locationPacked, bufSize, length, params));
3214 if (isCallValid)
3215 {
3216 context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
3217 }
3218 ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
3219 bufSize, length, params);
3220 }
3221 else
3222 {
3223 GenerateContextLostErrorOnCurrentGlobalContext();
3224 }
3225 }
3226
GL_GetnUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)3227 void GL_APIENTRY GL_GetnUniformivRobustANGLE(GLuint program,
3228 GLint location,
3229 GLsizei bufSize,
3230 GLsizei *length,
3231 GLint *params)
3232 {
3233 Context *context = GetValidGlobalContext();
3234 EVENT(context, GLGetnUniformivRobustANGLE,
3235 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
3236 ", params = 0x%016" PRIxPTR "",
3237 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
3238
3239 if (context)
3240 {
3241 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3242 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3243 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3244 bool isCallValid = (context->skipValidation() ||
3245 ValidateGetnUniformivRobustANGLE(
3246 context, angle::EntryPoint::GLGetnUniformivRobustANGLE,
3247 programPacked, locationPacked, bufSize, length, params));
3248 if (isCallValid)
3249 {
3250 context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
3251 }
3252 ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
3253 bufSize, length, params);
3254 }
3255 else
3256 {
3257 GenerateContextLostErrorOnCurrentGlobalContext();
3258 }
3259 }
3260
GL_GetnUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)3261 void GL_APIENTRY GL_GetnUniformuivRobustANGLE(GLuint program,
3262 GLint location,
3263 GLsizei bufSize,
3264 GLsizei *length,
3265 GLuint *params)
3266 {
3267 Context *context = GetValidGlobalContext();
3268 EVENT(context, GLGetnUniformuivRobustANGLE,
3269 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
3270 ", params = 0x%016" PRIxPTR "",
3271 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
3272
3273 if (context)
3274 {
3275 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3276 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3277 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3278 bool isCallValid = (context->skipValidation() ||
3279 ValidateGetnUniformuivRobustANGLE(
3280 context, angle::EntryPoint::GLGetnUniformuivRobustANGLE,
3281 programPacked, locationPacked, bufSize, length, params));
3282 if (isCallValid)
3283 {
3284 context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
3285 }
3286 ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
3287 locationPacked, bufSize, length, params);
3288 }
3289 else
3290 {
3291 GenerateContextLostErrorOnCurrentGlobalContext();
3292 }
3293 }
3294
GL_TexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)3295 void GL_APIENTRY GL_TexParameterIivRobustANGLE(GLenum target,
3296 GLenum pname,
3297 GLsizei bufSize,
3298 const GLint *params)
3299 {
3300 Context *context = GetValidGlobalContext();
3301 EVENT(context, GLTexParameterIivRobustANGLE,
3302 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
3303 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
3304 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
3305
3306 if (context)
3307 {
3308 TextureType targetPacked = PackParam<TextureType>(target);
3309 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3310 bool isCallValid = (context->skipValidation() ||
3311 ValidateTexParameterIivRobustANGLE(
3312 context, angle::EntryPoint::GLTexParameterIivRobustANGLE,
3313 targetPacked, pname, bufSize, params));
3314 if (isCallValid)
3315 {
3316 context->texParameterIivRobust(targetPacked, pname, bufSize, params);
3317 }
3318 ANGLE_CAPTURE(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
3319 bufSize, params);
3320 }
3321 else
3322 {
3323 GenerateContextLostErrorOnCurrentGlobalContext();
3324 }
3325 }
3326
GL_TexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLuint * params)3327 void GL_APIENTRY GL_TexParameterIuivRobustANGLE(GLenum target,
3328 GLenum pname,
3329 GLsizei bufSize,
3330 const GLuint *params)
3331 {
3332 Context *context = GetValidGlobalContext();
3333 EVENT(context, GLTexParameterIuivRobustANGLE,
3334 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
3335 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
3336 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params);
3337
3338 if (context)
3339 {
3340 TextureType targetPacked = PackParam<TextureType>(target);
3341 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3342 bool isCallValid = (context->skipValidation() ||
3343 ValidateTexParameterIuivRobustANGLE(
3344 context, angle::EntryPoint::GLTexParameterIuivRobustANGLE,
3345 targetPacked, pname, bufSize, params));
3346 if (isCallValid)
3347 {
3348 context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
3349 }
3350 ANGLE_CAPTURE(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
3351 bufSize, params);
3352 }
3353 else
3354 {
3355 GenerateContextLostErrorOnCurrentGlobalContext();
3356 }
3357 }
3358
GL_GetTexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3359 void GL_APIENTRY GL_GetTexParameterIivRobustANGLE(GLenum target,
3360 GLenum pname,
3361 GLsizei bufSize,
3362 GLsizei *length,
3363 GLint *params)
3364 {
3365 Context *context = GetValidGlobalContext();
3366 EVENT(context, GLGetTexParameterIivRobustANGLE,
3367 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3368 ", params = 0x%016" PRIxPTR "",
3369 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
3370 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
3371 (uintptr_t)params);
3372
3373 if (context)
3374 {
3375 TextureType targetPacked = PackParam<TextureType>(target);
3376 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3377 bool isCallValid = (context->skipValidation() ||
3378 ValidateGetTexParameterIivRobustANGLE(
3379 context, angle::EntryPoint::GLGetTexParameterIivRobustANGLE,
3380 targetPacked, pname, bufSize, length, params));
3381 if (isCallValid)
3382 {
3383 context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
3384 }
3385 ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
3386 bufSize, length, params);
3387 }
3388 else
3389 {
3390 GenerateContextLostErrorOnCurrentGlobalContext();
3391 }
3392 }
3393
GL_GetTexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3394 void GL_APIENTRY GL_GetTexParameterIuivRobustANGLE(GLenum target,
3395 GLenum pname,
3396 GLsizei bufSize,
3397 GLsizei *length,
3398 GLuint *params)
3399 {
3400 Context *context = GetValidGlobalContext();
3401 EVENT(context, GLGetTexParameterIuivRobustANGLE,
3402 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3403 ", params = 0x%016" PRIxPTR "",
3404 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
3405 GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length,
3406 (uintptr_t)params);
3407
3408 if (context)
3409 {
3410 TextureType targetPacked = PackParam<TextureType>(target);
3411 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3412 bool isCallValid = (context->skipValidation() ||
3413 ValidateGetTexParameterIuivRobustANGLE(
3414 context, angle::EntryPoint::GLGetTexParameterIuivRobustANGLE,
3415 targetPacked, pname, bufSize, length, params));
3416 if (isCallValid)
3417 {
3418 context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
3419 }
3420 ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
3421 bufSize, length, params);
3422 }
3423 else
3424 {
3425 GenerateContextLostErrorOnCurrentGlobalContext();
3426 }
3427 }
3428
GL_SamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLint * param)3429 void GL_APIENTRY GL_SamplerParameterIivRobustANGLE(GLuint sampler,
3430 GLenum pname,
3431 GLsizei bufSize,
3432 const GLint *param)
3433 {
3434 Context *context = GetValidGlobalContext();
3435 EVENT(context, GLSamplerParameterIivRobustANGLE,
3436 "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
3437 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3438 (uintptr_t)param);
3439
3440 if (context)
3441 {
3442 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3443 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3444 bool isCallValid = (context->skipValidation() ||
3445 ValidateSamplerParameterIivRobustANGLE(
3446 context, angle::EntryPoint::GLSamplerParameterIivRobustANGLE,
3447 samplerPacked, pname, bufSize, param));
3448 if (isCallValid)
3449 {
3450 context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param);
3451 }
3452 ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
3453 bufSize, param);
3454 }
3455 else
3456 {
3457 GenerateContextLostErrorOnCurrentGlobalContext();
3458 }
3459 }
3460
GL_SamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLuint * param)3461 void GL_APIENTRY GL_SamplerParameterIuivRobustANGLE(GLuint sampler,
3462 GLenum pname,
3463 GLsizei bufSize,
3464 const GLuint *param)
3465 {
3466 Context *context = GetValidGlobalContext();
3467 EVENT(context, GLSamplerParameterIuivRobustANGLE,
3468 "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
3469 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3470 (uintptr_t)param);
3471
3472 if (context)
3473 {
3474 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3475 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3476 bool isCallValid = (context->skipValidation() ||
3477 ValidateSamplerParameterIuivRobustANGLE(
3478 context, angle::EntryPoint::GLSamplerParameterIuivRobustANGLE,
3479 samplerPacked, pname, bufSize, param));
3480 if (isCallValid)
3481 {
3482 context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param);
3483 }
3484 ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, pname,
3485 bufSize, param);
3486 }
3487 else
3488 {
3489 GenerateContextLostErrorOnCurrentGlobalContext();
3490 }
3491 }
3492
GL_GetSamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3493 void GL_APIENTRY GL_GetSamplerParameterIivRobustANGLE(GLuint sampler,
3494 GLenum pname,
3495 GLsizei bufSize,
3496 GLsizei *length,
3497 GLint *params)
3498 {
3499 Context *context = GetValidGlobalContext();
3500 EVENT(context, GLGetSamplerParameterIivRobustANGLE,
3501 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3502 ", params = 0x%016" PRIxPTR "",
3503 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3504 (uintptr_t)length, (uintptr_t)params);
3505
3506 if (context)
3507 {
3508 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3509 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3510 bool isCallValid = (context->skipValidation() ||
3511 ValidateGetSamplerParameterIivRobustANGLE(
3512 context, angle::EntryPoint::GLGetSamplerParameterIivRobustANGLE,
3513 samplerPacked, pname, bufSize, length, params));
3514 if (isCallValid)
3515 {
3516 context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params);
3517 }
3518 ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
3519 bufSize, length, params);
3520 }
3521 else
3522 {
3523 GenerateContextLostErrorOnCurrentGlobalContext();
3524 }
3525 }
3526
GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3527 void GL_APIENTRY GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler,
3528 GLenum pname,
3529 GLsizei bufSize,
3530 GLsizei *length,
3531 GLuint *params)
3532 {
3533 Context *context = GetValidGlobalContext();
3534 EVENT(context, GLGetSamplerParameterIuivRobustANGLE,
3535 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3536 ", params = 0x%016" PRIxPTR "",
3537 CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3538 (uintptr_t)length, (uintptr_t)params);
3539
3540 if (context)
3541 {
3542 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3543 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3544 bool isCallValid = (context->skipValidation() ||
3545 ValidateGetSamplerParameterIuivRobustANGLE(
3546 context, angle::EntryPoint::GLGetSamplerParameterIuivRobustANGLE,
3547 samplerPacked, pname, bufSize, length, params));
3548 if (isCallValid)
3549 {
3550 context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params);
3551 }
3552 ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked,
3553 pname, bufSize, length, params);
3554 }
3555 else
3556 {
3557 GenerateContextLostErrorOnCurrentGlobalContext();
3558 }
3559 }
3560
GL_GetQueryObjectivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3561 void GL_APIENTRY GL_GetQueryObjectivRobustANGLE(GLuint id,
3562 GLenum pname,
3563 GLsizei bufSize,
3564 GLsizei *length,
3565 GLint *params)
3566 {
3567 Context *context = GetGlobalContext();
3568 EVENT(context, GLGetQueryObjectivRobustANGLE,
3569 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3570 ", params = 0x%016" PRIxPTR "",
3571 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3572 (uintptr_t)length, (uintptr_t)params);
3573
3574 if (context)
3575 {
3576 QueryID idPacked = PackParam<QueryID>(id);
3577 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3578 bool isCallValid = (context->skipValidation() ||
3579 ValidateGetQueryObjectivRobustANGLE(
3580 context, angle::EntryPoint::GLGetQueryObjectivRobustANGLE, idPacked,
3581 pname, bufSize, length, params));
3582 if (isCallValid)
3583 {
3584 context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params);
3585 }
3586 ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
3587 length, params);
3588 }
3589 else
3590 {}
3591 }
3592
GL_GetQueryObjecti64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3593 void GL_APIENTRY GL_GetQueryObjecti64vRobustANGLE(GLuint id,
3594 GLenum pname,
3595 GLsizei bufSize,
3596 GLsizei *length,
3597 GLint64 *params)
3598 {
3599 Context *context = GetGlobalContext();
3600 EVENT(context, GLGetQueryObjecti64vRobustANGLE,
3601 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3602 ", params = 0x%016" PRIxPTR "",
3603 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3604 (uintptr_t)length, (uintptr_t)params);
3605
3606 if (context)
3607 {
3608 QueryID idPacked = PackParam<QueryID>(id);
3609 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3610 bool isCallValid = (context->skipValidation() ||
3611 ValidateGetQueryObjecti64vRobustANGLE(
3612 context, angle::EntryPoint::GLGetQueryObjecti64vRobustANGLE,
3613 idPacked, pname, bufSize, length, params));
3614 if (isCallValid)
3615 {
3616 context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params);
3617 }
3618 ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname, bufSize,
3619 length, params);
3620 }
3621 else
3622 {}
3623 }
3624
GL_GetQueryObjectui64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)3625 void GL_APIENTRY GL_GetQueryObjectui64vRobustANGLE(GLuint id,
3626 GLenum pname,
3627 GLsizei bufSize,
3628 GLsizei *length,
3629 GLuint64 *params)
3630 {
3631 Context *context = GetValidGlobalContext();
3632 EVENT(context, GLGetQueryObjectui64vRobustANGLE,
3633 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3634 ", params = 0x%016" PRIxPTR "",
3635 CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize,
3636 (uintptr_t)length, (uintptr_t)params);
3637
3638 if (context)
3639 {
3640 QueryID idPacked = PackParam<QueryID>(id);
3641 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3642 bool isCallValid = (context->skipValidation() ||
3643 ValidateGetQueryObjectui64vRobustANGLE(
3644 context, angle::EntryPoint::GLGetQueryObjectui64vRobustANGLE,
3645 idPacked, pname, bufSize, length, params));
3646 if (isCallValid)
3647 {
3648 context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params);
3649 }
3650 ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname,
3651 bufSize, length, params);
3652 }
3653 else
3654 {
3655 GenerateContextLostErrorOnCurrentGlobalContext();
3656 }
3657 }
3658
3659 // GL_ANGLE_robust_resource_initialization
3660
3661 // GL_ANGLE_semaphore_fuchsia
GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore,GLenum handleType,GLuint handle)3662 void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore,
3663 GLenum handleType,
3664 GLuint handle)
3665 {
3666 Context *context = GetValidGlobalContext();
3667 EVENT(context, GLImportSemaphoreZirconHandleANGLE,
3668 "context = %d, semaphore = %u, handleType = %s, handle = %u", CID(context), semaphore,
3669 GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle);
3670
3671 if (context)
3672 {
3673 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
3674 HandleType handleTypePacked = PackParam<HandleType>(handleType);
3675 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3676 bool isCallValid = (context->skipValidation() ||
3677 ValidateImportSemaphoreZirconHandleANGLE(
3678 context, angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE,
3679 semaphorePacked, handleTypePacked, handle));
3680 if (isCallValid)
3681 {
3682 context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle);
3683 }
3684 ANGLE_CAPTURE(ImportSemaphoreZirconHandleANGLE, isCallValid, context, semaphorePacked,
3685 handleTypePacked, handle);
3686 }
3687 else
3688 {
3689 GenerateContextLostErrorOnCurrentGlobalContext();
3690 }
3691 }
3692
3693 // GL_ANGLE_texture_compression_dxt3
3694
3695 // GL_ANGLE_texture_compression_dxt5
3696
3697 // GL_ANGLE_texture_external_update
GL_TexImage2DExternalANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)3698 void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target,
3699 GLint level,
3700 GLint internalformat,
3701 GLsizei width,
3702 GLsizei height,
3703 GLint border,
3704 GLenum format,
3705 GLenum type)
3706 {
3707 Context *context = GetValidGlobalContext();
3708 EVENT(context, GLTexImage2DExternalANGLE,
3709 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
3710 "border = %d, format = %s, type = %s",
3711 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
3712 width, height, border, GLenumToString(GLenumGroup::PixelFormat, format),
3713 GLenumToString(GLenumGroup::PixelType, type));
3714
3715 if (context)
3716 {
3717 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3718 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3719 bool isCallValid = (context->skipValidation() ||
3720 ValidateTexImage2DExternalANGLE(
3721 context, angle::EntryPoint::GLTexImage2DExternalANGLE, targetPacked,
3722 level, internalformat, width, height, border, format, type));
3723 if (isCallValid)
3724 {
3725 context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
3726 format, type);
3727 }
3728 ANGLE_CAPTURE(TexImage2DExternalANGLE, isCallValid, context, targetPacked, level,
3729 internalformat, width, height, border, format, type);
3730 }
3731 else
3732 {
3733 GenerateContextLostErrorOnCurrentGlobalContext();
3734 }
3735 }
3736
GL_InvalidateTextureANGLE(GLenum target)3737 void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target)
3738 {
3739 Context *context = GetValidGlobalContext();
3740 EVENT(context, GLInvalidateTextureANGLE, "context = %d, target = %s", CID(context),
3741 GLenumToString(GLenumGroup::TextureTarget, target));
3742
3743 if (context)
3744 {
3745 TextureType targetPacked = PackParam<TextureType>(target);
3746 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3747 bool isCallValid =
3748 (context->skipValidation() ||
3749 ValidateInvalidateTextureANGLE(context, angle::EntryPoint::GLInvalidateTextureANGLE,
3750 targetPacked));
3751 if (isCallValid)
3752 {
3753 context->invalidateTexture(targetPacked);
3754 }
3755 ANGLE_CAPTURE(InvalidateTextureANGLE, isCallValid, context, targetPacked);
3756 }
3757 else
3758 {
3759 GenerateContextLostErrorOnCurrentGlobalContext();
3760 }
3761 }
3762
3763 // GL_ANGLE_texture_multisample
GL_TexStorage2DMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)3764 void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target,
3765 GLsizei samples,
3766 GLenum internalformat,
3767 GLsizei width,
3768 GLsizei height,
3769 GLboolean fixedsamplelocations)
3770 {
3771 Context *context = GetValidGlobalContext();
3772 EVENT(context, GLTexStorage2DMultisampleANGLE,
3773 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
3774 "fixedsamplelocations = %s",
3775 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), samples,
3776 GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height,
3777 GLbooleanToString(fixedsamplelocations));
3778
3779 if (context)
3780 {
3781 TextureType targetPacked = PackParam<TextureType>(target);
3782 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3783 bool isCallValid =
3784 (context->skipValidation() ||
3785 ValidateTexStorage2DMultisampleANGLE(
3786 context, angle::EntryPoint::GLTexStorage2DMultisampleANGLE, targetPacked, samples,
3787 internalformat, width, height, fixedsamplelocations));
3788 if (isCallValid)
3789 {
3790 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
3791 fixedsamplelocations);
3792 }
3793 ANGLE_CAPTURE(TexStorage2DMultisampleANGLE, isCallValid, context, targetPacked, samples,
3794 internalformat, width, height, fixedsamplelocations);
3795 }
3796 else
3797 {
3798 GenerateContextLostErrorOnCurrentGlobalContext();
3799 }
3800 }
3801
GL_GetMultisamplefvANGLE(GLenum pname,GLuint index,GLfloat * val)3802 void GL_APIENTRY GL_GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
3803 {
3804 Context *context = GetValidGlobalContext();
3805 EVENT(context, GLGetMultisamplefvANGLE,
3806 "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context),
3807 GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
3808
3809 if (context)
3810 {
3811 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3812 bool isCallValid =
3813 (context->skipValidation() ||
3814 ValidateGetMultisamplefvANGLE(context, angle::EntryPoint::GLGetMultisamplefvANGLE,
3815 pname, index, val));
3816 if (isCallValid)
3817 {
3818 context->getMultisamplefv(pname, index, val);
3819 }
3820 ANGLE_CAPTURE(GetMultisamplefvANGLE, isCallValid, context, pname, index, val);
3821 }
3822 else
3823 {
3824 GenerateContextLostErrorOnCurrentGlobalContext();
3825 }
3826 }
3827
GL_SampleMaskiANGLE(GLuint maskNumber,GLbitfield mask)3828 void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
3829 {
3830 Context *context = GetValidGlobalContext();
3831 EVENT(context, GLSampleMaskiANGLE, "context = %d, maskNumber = %u, mask = %s", CID(context),
3832 maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
3833
3834 if (context)
3835 {
3836 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3837 bool isCallValid = (context->skipValidation() ||
3838 ValidateSampleMaskiANGLE(context, angle::EntryPoint::GLSampleMaskiANGLE,
3839 maskNumber, mask));
3840 if (isCallValid)
3841 {
3842 context->sampleMaski(maskNumber, mask);
3843 }
3844 ANGLE_CAPTURE(SampleMaskiANGLE, isCallValid, context, maskNumber, mask);
3845 }
3846 else
3847 {
3848 GenerateContextLostErrorOnCurrentGlobalContext();
3849 }
3850 }
3851
3852 // GetTexLevelParameterfvANGLE is already defined.
3853
3854 // GetTexLevelParameterivANGLE is already defined.
3855
3856 // GL_ANGLE_texture_usage
3857
3858 // GL_ANGLE_translated_shader_source
GL_GetTranslatedShaderSourceANGLE(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * source)3859 void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader,
3860 GLsizei bufsize,
3861 GLsizei *length,
3862 GLchar *source)
3863 {
3864 Context *context = GetValidGlobalContext();
3865 EVENT(context, GLGetTranslatedShaderSourceANGLE,
3866 "context = %d, shader = %u, bufsize = %d, length = 0x%016" PRIxPTR
3867 ", source = 0x%016" PRIxPTR "",
3868 CID(context), shader, bufsize, (uintptr_t)length, (uintptr_t)source);
3869
3870 if (context)
3871 {
3872 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
3873 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3874 bool isCallValid = (context->skipValidation() ||
3875 ValidateGetTranslatedShaderSourceANGLE(
3876 context, angle::EntryPoint::GLGetTranslatedShaderSourceANGLE,
3877 shaderPacked, bufsize, length, source));
3878 if (isCallValid)
3879 {
3880 context->getTranslatedShaderSource(shaderPacked, bufsize, length, source);
3881 }
3882 ANGLE_CAPTURE(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked, bufsize,
3883 length, source);
3884 }
3885 else
3886 {
3887 GenerateContextLostErrorOnCurrentGlobalContext();
3888 }
3889 }
3890
3891 // GL_ANGLE_vulkan_image
GL_AcquireTexturesANGLE(GLuint numTextures,const GLuint * textures,const GLenum * layouts)3892 void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures,
3893 const GLuint *textures,
3894 const GLenum *layouts)
3895 {
3896 Context *context = GetValidGlobalContext();
3897 EVENT(context, GLAcquireTexturesANGLE,
3898 "context = %d, numTextures = %u, textures = 0x%016" PRIxPTR ", layouts = 0x%016" PRIxPTR
3899 "",
3900 CID(context), numTextures, (uintptr_t)textures, (uintptr_t)layouts);
3901
3902 if (context)
3903 {
3904 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
3905 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3906 bool isCallValid =
3907 (context->skipValidation() ||
3908 ValidateAcquireTexturesANGLE(context, angle::EntryPoint::GLAcquireTexturesANGLE,
3909 numTextures, texturesPacked, layouts));
3910 if (isCallValid)
3911 {
3912 context->acquireTextures(numTextures, texturesPacked, layouts);
3913 }
3914 ANGLE_CAPTURE(AcquireTexturesANGLE, isCallValid, context, numTextures, texturesPacked,
3915 layouts);
3916 }
3917 else
3918 {
3919 GenerateContextLostErrorOnCurrentGlobalContext();
3920 }
3921 }
3922
GL_ReleaseTexturesANGLE(GLuint numTextures,const GLuint * textures,GLenum * layouts)3923 void GL_APIENTRY GL_ReleaseTexturesANGLE(GLuint numTextures,
3924 const GLuint *textures,
3925 GLenum *layouts)
3926 {
3927 Context *context = GetValidGlobalContext();
3928 EVENT(context, GLReleaseTexturesANGLE,
3929 "context = %d, numTextures = %u, textures = 0x%016" PRIxPTR ", layouts = 0x%016" PRIxPTR
3930 "",
3931 CID(context), numTextures, (uintptr_t)textures, (uintptr_t)layouts);
3932
3933 if (context)
3934 {
3935 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
3936 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3937 bool isCallValid =
3938 (context->skipValidation() ||
3939 ValidateReleaseTexturesANGLE(context, angle::EntryPoint::GLReleaseTexturesANGLE,
3940 numTextures, texturesPacked, layouts));
3941 if (isCallValid)
3942 {
3943 context->releaseTextures(numTextures, texturesPacked, layouts);
3944 }
3945 ANGLE_CAPTURE(ReleaseTexturesANGLE, isCallValid, context, numTextures, texturesPacked,
3946 layouts);
3947 }
3948 else
3949 {
3950 GenerateContextLostErrorOnCurrentGlobalContext();
3951 }
3952 }
3953
3954 // GL_APPLE_clip_distance
3955
3956 // GL_ARB_sync
3957 // ClientWaitSync is already defined.
3958
3959 // DeleteSync is already defined.
3960
3961 // FenceSync is already defined.
3962
3963 // GetInteger64v is already defined.
3964
3965 // GetSynciv is already defined.
3966
3967 // IsSync is already defined.
3968
3969 // WaitSync is already defined.
3970
3971 // GL_CHROMIUM_bind_uniform_location
GL_BindUniformLocationCHROMIUM(GLuint program,GLint location,const GLchar * name)3972 void GL_APIENTRY GL_BindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
3973 {
3974 Context *context = GetValidGlobalContext();
3975 EVENT(context, GLBindUniformLocationCHROMIUM,
3976 "context = %d, program = %u, location = %d, name = 0x%016" PRIxPTR "", CID(context),
3977 program, location, (uintptr_t)name);
3978
3979 if (context)
3980 {
3981 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3982 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3983 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
3984 bool isCallValid = (context->skipValidation() ||
3985 ValidateBindUniformLocationCHROMIUM(
3986 context, angle::EntryPoint::GLBindUniformLocationCHROMIUM,
3987 programPacked, locationPacked, name));
3988 if (isCallValid)
3989 {
3990 context->bindUniformLocation(programPacked, locationPacked, name);
3991 }
3992 ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
3993 locationPacked, name);
3994 }
3995 else
3996 {
3997 GenerateContextLostErrorOnCurrentGlobalContext();
3998 }
3999 }
4000
4001 // GL_CHROMIUM_copy_compressed_texture
GL_CompressedCopyTextureCHROMIUM(GLuint sourceId,GLuint destId)4002 void GL_APIENTRY GL_CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
4003 {
4004 Context *context = GetValidGlobalContext();
4005 EVENT(context, GLCompressedCopyTextureCHROMIUM, "context = %d, sourceId = %u, destId = %u",
4006 CID(context), sourceId, destId);
4007
4008 if (context)
4009 {
4010 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
4011 TextureID destIdPacked = PackParam<TextureID>(destId);
4012 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4013 bool isCallValid = (context->skipValidation() ||
4014 ValidateCompressedCopyTextureCHROMIUM(
4015 context, angle::EntryPoint::GLCompressedCopyTextureCHROMIUM,
4016 sourceIdPacked, destIdPacked));
4017 if (isCallValid)
4018 {
4019 context->compressedCopyTexture(sourceIdPacked, destIdPacked);
4020 }
4021 ANGLE_CAPTURE(CompressedCopyTextureCHROMIUM, isCallValid, context, sourceIdPacked,
4022 destIdPacked);
4023 }
4024 else
4025 {
4026 GenerateContextLostErrorOnCurrentGlobalContext();
4027 }
4028 }
4029
4030 // GL_CHROMIUM_copy_texture
GL_CopyTextureCHROMIUM(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)4031 void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId,
4032 GLint sourceLevel,
4033 GLenum destTarget,
4034 GLuint destId,
4035 GLint destLevel,
4036 GLint internalFormat,
4037 GLenum destType,
4038 GLboolean unpackFlipY,
4039 GLboolean unpackPremultiplyAlpha,
4040 GLboolean unpackUnmultiplyAlpha)
4041 {
4042 Context *context = GetValidGlobalContext();
4043 EVENT(context, GLCopyTextureCHROMIUM,
4044 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
4045 "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = "
4046 "%s, unpackUnmultiplyAlpha = %s",
4047 CID(context), sourceId, sourceLevel,
4048 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat,
4049 GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY),
4050 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
4051
4052 if (context)
4053 {
4054 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
4055 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
4056 TextureID destIdPacked = PackParam<TextureID>(destId);
4057 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4058 bool isCallValid =
4059 (context->skipValidation() ||
4060 ValidateCopyTextureCHROMIUM(
4061 context, angle::EntryPoint::GLCopyTextureCHROMIUM, sourceIdPacked, sourceLevel,
4062 destTargetPacked, destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
4063 unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
4064 if (isCallValid)
4065 {
4066 context->copyTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
4067 destLevel, internalFormat, destType, unpackFlipY,
4068 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4069 }
4070 ANGLE_CAPTURE(CopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
4071 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
4072 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4073 }
4074 else
4075 {
4076 GenerateContextLostErrorOnCurrentGlobalContext();
4077 }
4078 }
4079
GL_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)4080 void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId,
4081 GLint sourceLevel,
4082 GLenum destTarget,
4083 GLuint destId,
4084 GLint destLevel,
4085 GLint xoffset,
4086 GLint yoffset,
4087 GLint x,
4088 GLint y,
4089 GLint width,
4090 GLint height,
4091 GLboolean unpackFlipY,
4092 GLboolean unpackPremultiplyAlpha,
4093 GLboolean unpackUnmultiplyAlpha)
4094 {
4095 Context *context = GetValidGlobalContext();
4096 EVENT(context, GLCopySubTextureCHROMIUM,
4097 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
4098 "= %d, xoffset = %d, yoffset = %d, x = %d, y = %d, width = %d, height = %d, unpackFlipY "
4099 "= %s, unpackPremultiplyAlpha = %s, unpackUnmultiplyAlpha = %s",
4100 CID(context), sourceId, sourceLevel,
4101 GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset,
4102 yoffset, x, y, width, height, GLbooleanToString(unpackFlipY),
4103 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
4104
4105 if (context)
4106 {
4107 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
4108 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
4109 TextureID destIdPacked = PackParam<TextureID>(destId);
4110 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4111 bool isCallValid =
4112 (context->skipValidation() ||
4113 ValidateCopySubTextureCHROMIUM(
4114 context, angle::EntryPoint::GLCopySubTextureCHROMIUM, sourceIdPacked, sourceLevel,
4115 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width, height,
4116 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
4117 if (isCallValid)
4118 {
4119 context->copySubTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
4120 destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
4121 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4122 }
4123 ANGLE_CAPTURE(CopySubTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
4124 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width,
4125 height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4126 }
4127 else
4128 {
4129 GenerateContextLostErrorOnCurrentGlobalContext();
4130 }
4131 }
4132
4133 // GL_CHROMIUM_framebuffer_mixed_samples
GL_CoverageModulationCHROMIUM(GLenum components)4134 void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components)
4135 {
4136 Context *context = GetValidGlobalContext();
4137 EVENT(context, GLCoverageModulationCHROMIUM, "context = %d, components = %s", CID(context),
4138 GLenumToString(GLenumGroup::DefaultGroup, components));
4139
4140 if (context)
4141 {
4142 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4143 bool isCallValid =
4144 (context->skipValidation() ||
4145 ValidateCoverageModulationCHROMIUM(
4146 context, angle::EntryPoint::GLCoverageModulationCHROMIUM, components));
4147 if (isCallValid)
4148 {
4149 context->coverageModulation(components);
4150 }
4151 ANGLE_CAPTURE(CoverageModulationCHROMIUM, isCallValid, context, components);
4152 }
4153 else
4154 {
4155 GenerateContextLostErrorOnCurrentGlobalContext();
4156 }
4157 }
4158
4159 // GL_CHROMIUM_lose_context
GL_LoseContextCHROMIUM(GLenum current,GLenum other)4160 void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other)
4161 {
4162 Context *context = GetValidGlobalContext();
4163 EVENT(context, GLLoseContextCHROMIUM, "context = %d, current = %s, other = %s", CID(context),
4164 GLenumToString(GLenumGroup::GraphicsResetStatus, current),
4165 GLenumToString(GLenumGroup::GraphicsResetStatus, other));
4166
4167 if (context)
4168 {
4169 GraphicsResetStatus currentPacked = PackParam<GraphicsResetStatus>(current);
4170 GraphicsResetStatus otherPacked = PackParam<GraphicsResetStatus>(other);
4171 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4172 bool isCallValid =
4173 (context->skipValidation() ||
4174 ValidateLoseContextCHROMIUM(context, angle::EntryPoint::GLLoseContextCHROMIUM,
4175 currentPacked, otherPacked));
4176 if (isCallValid)
4177 {
4178 context->loseContext(currentPacked, otherPacked);
4179 }
4180 ANGLE_CAPTURE(LoseContextCHROMIUM, isCallValid, context, currentPacked, otherPacked);
4181 }
4182 else
4183 {
4184 GenerateContextLostErrorOnCurrentGlobalContext();
4185 }
4186 }
4187
4188 // GL_EXT_EGL_image_array
4189
4190 // GL_EXT_EGL_image_storage
GL_EGLImageTargetTexStorageEXT(GLenum target,GLeglImageOES image,const GLint * attrib_list)4191 void GL_APIENTRY GL_EGLImageTargetTexStorageEXT(GLenum target,
4192 GLeglImageOES image,
4193 const GLint *attrib_list)
4194 {
4195 Context *context = GetValidGlobalContext();
4196 EVENT(context, GLEGLImageTargetTexStorageEXT,
4197 "context = %d, target = %s, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "",
4198 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image,
4199 (uintptr_t)attrib_list);
4200
4201 if (context)
4202 {
4203 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4204 bool isCallValid = (context->skipValidation() ||
4205 ValidateEGLImageTargetTexStorageEXT(
4206 context, angle::EntryPoint::GLEGLImageTargetTexStorageEXT, target,
4207 image, attrib_list));
4208 if (isCallValid)
4209 {
4210 context->eGLImageTargetTexStorage(target, image, attrib_list);
4211 }
4212 ANGLE_CAPTURE(EGLImageTargetTexStorageEXT, isCallValid, context, target, image,
4213 attrib_list);
4214 }
4215 else
4216 {
4217 GenerateContextLostErrorOnCurrentGlobalContext();
4218 }
4219 }
4220
GL_EGLImageTargetTextureStorageEXT(GLuint texture,GLeglImageOES image,const GLint * attrib_list)4221 void GL_APIENTRY GL_EGLImageTargetTextureStorageEXT(GLuint texture,
4222 GLeglImageOES image,
4223 const GLint *attrib_list)
4224 {
4225 Context *context = GetValidGlobalContext();
4226 EVENT(context, GLEGLImageTargetTextureStorageEXT,
4227 "context = %d, texture = %u, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "",
4228 CID(context), texture, (uintptr_t)image, (uintptr_t)attrib_list);
4229
4230 if (context)
4231 {
4232 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4233 bool isCallValid = (context->skipValidation() ||
4234 ValidateEGLImageTargetTextureStorageEXT(
4235 context, angle::EntryPoint::GLEGLImageTargetTextureStorageEXT,
4236 texture, image, attrib_list));
4237 if (isCallValid)
4238 {
4239 context->eGLImageTargetTextureStorage(texture, image, attrib_list);
4240 }
4241 ANGLE_CAPTURE(EGLImageTargetTextureStorageEXT, isCallValid, context, texture, image,
4242 attrib_list);
4243 }
4244 else
4245 {
4246 GenerateContextLostErrorOnCurrentGlobalContext();
4247 }
4248 }
4249
4250 // GL_EXT_YUV_target
4251
4252 // GL_EXT_blend_func_extended
GL_BindFragDataLocationEXT(GLuint program,GLuint color,const GLchar * name)4253 void GL_APIENTRY GL_BindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
4254 {
4255 Context *context = GetValidGlobalContext();
4256 EVENT(context, GLBindFragDataLocationEXT,
4257 "context = %d, program = %u, color = %u, name = 0x%016" PRIxPTR "", CID(context), program,
4258 color, (uintptr_t)name);
4259
4260 if (context)
4261 {
4262 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4263 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4264 bool isCallValid =
4265 (context->skipValidation() ||
4266 ValidateBindFragDataLocationEXT(context, angle::EntryPoint::GLBindFragDataLocationEXT,
4267 programPacked, color, name));
4268 if (isCallValid)
4269 {
4270 context->bindFragDataLocation(programPacked, color, name);
4271 }
4272 ANGLE_CAPTURE(BindFragDataLocationEXT, isCallValid, context, programPacked, color, name);
4273 }
4274 else
4275 {
4276 GenerateContextLostErrorOnCurrentGlobalContext();
4277 }
4278 }
4279
GL_BindFragDataLocationIndexedEXT(GLuint program,GLuint colorNumber,GLuint index,const GLchar * name)4280 void GL_APIENTRY GL_BindFragDataLocationIndexedEXT(GLuint program,
4281 GLuint colorNumber,
4282 GLuint index,
4283 const GLchar *name)
4284 {
4285 Context *context = GetValidGlobalContext();
4286 EVENT(context, GLBindFragDataLocationIndexedEXT,
4287 "context = %d, program = %u, colorNumber = %u, index = %u, name = 0x%016" PRIxPTR "",
4288 CID(context), program, colorNumber, index, (uintptr_t)name);
4289
4290 if (context)
4291 {
4292 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4293 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4294 bool isCallValid = (context->skipValidation() ||
4295 ValidateBindFragDataLocationIndexedEXT(
4296 context, angle::EntryPoint::GLBindFragDataLocationIndexedEXT,
4297 programPacked, colorNumber, index, name));
4298 if (isCallValid)
4299 {
4300 context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
4301 }
4302 ANGLE_CAPTURE(BindFragDataLocationIndexedEXT, isCallValid, context, programPacked,
4303 colorNumber, index, name);
4304 }
4305 else
4306 {
4307 GenerateContextLostErrorOnCurrentGlobalContext();
4308 }
4309 }
4310
GL_GetFragDataIndexEXT(GLuint program,const GLchar * name)4311 GLint GL_APIENTRY GL_GetFragDataIndexEXT(GLuint program, const GLchar *name)
4312 {
4313 Context *context = GetValidGlobalContext();
4314 EVENT(context, GLGetFragDataIndexEXT, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
4315 CID(context), program, (uintptr_t)name);
4316
4317 GLint returnValue;
4318 if (context)
4319 {
4320 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4321 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4322 bool isCallValid =
4323 (context->skipValidation() ||
4324 ValidateGetFragDataIndexEXT(context, angle::EntryPoint::GLGetFragDataIndexEXT,
4325 programPacked, name));
4326 if (isCallValid)
4327 {
4328 returnValue = context->getFragDataIndex(programPacked, name);
4329 }
4330 else
4331 {
4332 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>();
4333 }
4334 ANGLE_CAPTURE(GetFragDataIndexEXT, isCallValid, context, programPacked, name, returnValue);
4335 }
4336 else
4337 {
4338 GenerateContextLostErrorOnCurrentGlobalContext();
4339 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>();
4340 }
4341 return returnValue;
4342 }
4343
GL_GetProgramResourceLocationIndexEXT(GLuint program,GLenum programInterface,const GLchar * name)4344 GLint GL_APIENTRY GL_GetProgramResourceLocationIndexEXT(GLuint program,
4345 GLenum programInterface,
4346 const GLchar *name)
4347 {
4348 Context *context = GetValidGlobalContext();
4349 EVENT(context, GLGetProgramResourceLocationIndexEXT,
4350 "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "",
4351 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
4352 (uintptr_t)name);
4353
4354 GLint returnValue;
4355 if (context)
4356 {
4357 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4358 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4359 bool isCallValid = (context->skipValidation() ||
4360 ValidateGetProgramResourceLocationIndexEXT(
4361 context, angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
4362 programPacked, programInterface, name));
4363 if (isCallValid)
4364 {
4365 returnValue =
4366 context->getProgramResourceLocationIndex(programPacked, programInterface, name);
4367 }
4368 else
4369 {
4370 returnValue =
4371 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
4372 GLint>();
4373 }
4374 ANGLE_CAPTURE(GetProgramResourceLocationIndexEXT, isCallValid, context, programPacked,
4375 programInterface, name, returnValue);
4376 }
4377 else
4378 {
4379 GenerateContextLostErrorOnCurrentGlobalContext();
4380 returnValue =
4381 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT, GLint>();
4382 }
4383 return returnValue;
4384 }
4385
4386 // GL_EXT_blend_minmax
4387
4388 // GL_EXT_buffer_storage
GL_BufferStorageEXT(GLenum target,GLsizeiptr size,const void * data,GLbitfield flags)4389 void GL_APIENTRY GL_BufferStorageEXT(GLenum target,
4390 GLsizeiptr size,
4391 const void *data,
4392 GLbitfield flags)
4393 {
4394 Context *context = GetValidGlobalContext();
4395 EVENT(context, GLBufferStorageEXT,
4396 "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", flags = %s",
4397 CID(context), GLenumToString(GLenumGroup::BufferStorageTarget, target),
4398 static_cast<unsigned long long>(size), (uintptr_t)data,
4399 GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str());
4400
4401 if (context)
4402 {
4403 BufferBinding targetPacked = PackParam<BufferBinding>(target);
4404 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4405 bool isCallValid = (context->skipValidation() ||
4406 ValidateBufferStorageEXT(context, angle::EntryPoint::GLBufferStorageEXT,
4407 targetPacked, size, data, flags));
4408 if (isCallValid)
4409 {
4410 context->bufferStorage(targetPacked, size, data, flags);
4411 }
4412 ANGLE_CAPTURE(BufferStorageEXT, isCallValid, context, targetPacked, size, data, flags);
4413 }
4414 else
4415 {
4416 GenerateContextLostErrorOnCurrentGlobalContext();
4417 }
4418 }
4419
4420 // GL_EXT_clip_control
GL_ClipControlEXT(GLenum origin,GLenum depth)4421 void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth)
4422 {
4423 Context *context = GetValidGlobalContext();
4424 EVENT(context, GLClipControlEXT, "context = %d, origin = %s, depth = %s", CID(context),
4425 GLenumToString(GLenumGroup::DefaultGroup, origin),
4426 GLenumToString(GLenumGroup::DefaultGroup, depth));
4427
4428 if (context)
4429 {
4430 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4431 bool isCallValid =
4432 (context->skipValidation() ||
4433 ValidateClipControlEXT(context, angle::EntryPoint::GLClipControlEXT, origin, depth));
4434 if (isCallValid)
4435 {
4436 context->clipControl(origin, depth);
4437 }
4438 ANGLE_CAPTURE(ClipControlEXT, isCallValid, context, origin, depth);
4439 }
4440 else
4441 {
4442 GenerateContextLostErrorOnCurrentGlobalContext();
4443 }
4444 }
4445
4446 // GL_EXT_clip_cull_distance
4447
4448 // GL_EXT_color_buffer_float
4449
4450 // GL_EXT_color_buffer_half_float
4451
4452 // GL_EXT_copy_image
GL_CopyImageSubDataEXT(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)4453 void GL_APIENTRY GL_CopyImageSubDataEXT(GLuint srcName,
4454 GLenum srcTarget,
4455 GLint srcLevel,
4456 GLint srcX,
4457 GLint srcY,
4458 GLint srcZ,
4459 GLuint dstName,
4460 GLenum dstTarget,
4461 GLint dstLevel,
4462 GLint dstX,
4463 GLint dstY,
4464 GLint dstZ,
4465 GLsizei srcWidth,
4466 GLsizei srcHeight,
4467 GLsizei srcDepth)
4468 {
4469 Context *context = GetValidGlobalContext();
4470 EVENT(context, GLCopyImageSubDataEXT,
4471 "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = "
4472 "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, "
4473 "srcWidth = %d, srcHeight = %d, srcDepth = %d",
4474 CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget),
4475 srcLevel, srcX, srcY, srcZ, dstName,
4476 GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY,
4477 dstZ, srcWidth, srcHeight, srcDepth);
4478
4479 if (context)
4480 {
4481 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4482 bool isCallValid = (context->skipValidation() ||
4483 ValidateCopyImageSubDataEXT(
4484 context, angle::EntryPoint::GLCopyImageSubDataEXT, srcName,
4485 srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel,
4486 dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth));
4487 if (isCallValid)
4488 {
4489 context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
4490 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
4491 srcDepth);
4492 }
4493 ANGLE_CAPTURE(CopyImageSubDataEXT, isCallValid, context, srcName, srcTarget, srcLevel, srcX,
4494 srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
4495 srcHeight, srcDepth);
4496 }
4497 else
4498 {
4499 GenerateContextLostErrorOnCurrentGlobalContext();
4500 }
4501 }
4502
4503 // GL_EXT_debug_label
4504 void GL_APIENTRY
GL_GetObjectLabelEXT(GLenum type,GLuint object,GLsizei bufSize,GLsizei * length,GLchar * label)4505 GL_GetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
4506 {
4507 Context *context = GetValidGlobalContext();
4508 EVENT(context, GLGetObjectLabelEXT,
4509 "context = %d, type = %s, object = %u, bufSize = %d, length = 0x%016" PRIxPTR
4510 ", label = 0x%016" PRIxPTR "",
4511 CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), object, bufSize,
4512 (uintptr_t)length, (uintptr_t)label);
4513
4514 if (context)
4515 {
4516 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4517 bool isCallValid =
4518 (context->skipValidation() ||
4519 ValidateGetObjectLabelEXT(context, angle::EntryPoint::GLGetObjectLabelEXT, type,
4520 object, bufSize, length, label));
4521 if (isCallValid)
4522 {
4523 context->getObjectLabel(type, object, bufSize, length, label);
4524 }
4525 ANGLE_CAPTURE(GetObjectLabelEXT, isCallValid, context, type, object, bufSize, length,
4526 label);
4527 }
4528 else
4529 {
4530 GenerateContextLostErrorOnCurrentGlobalContext();
4531 }
4532 }
4533
GL_LabelObjectEXT(GLenum type,GLuint object,GLsizei length,const GLchar * label)4534 void GL_APIENTRY GL_LabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label)
4535 {
4536 Context *context = GetValidGlobalContext();
4537 EVENT(context, GLLabelObjectEXT,
4538 "context = %d, type = %s, object = %u, length = %d, label = 0x%016" PRIxPTR "",
4539 CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), object, length,
4540 (uintptr_t)label);
4541
4542 if (context)
4543 {
4544 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4545 bool isCallValid = (context->skipValidation() ||
4546 ValidateLabelObjectEXT(context, angle::EntryPoint::GLLabelObjectEXT,
4547 type, object, length, label));
4548 if (isCallValid)
4549 {
4550 context->labelObject(type, object, length, label);
4551 }
4552 ANGLE_CAPTURE(LabelObjectEXT, isCallValid, context, type, object, length, label);
4553 }
4554 else
4555 {
4556 GenerateContextLostErrorOnCurrentGlobalContext();
4557 }
4558 }
4559
4560 // GL_EXT_debug_marker
GL_InsertEventMarkerEXT(GLsizei length,const GLchar * marker)4561 void GL_APIENTRY GL_InsertEventMarkerEXT(GLsizei length, const GLchar *marker)
4562 {
4563 Context *context = GetValidGlobalContext();
4564 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
4565 // It can interfere with the debug events being set by the caller.
4566 // EVENT(context, GLInsertEventMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR
4567 // "", CID(context), length, (uintptr_t)marker);
4568
4569 if (context)
4570 {
4571 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4572 bool isCallValid =
4573 (context->skipValidation() ||
4574 ValidateInsertEventMarkerEXT(context, angle::EntryPoint::GLInsertEventMarkerEXT,
4575 length, marker));
4576 if (isCallValid)
4577 {
4578 context->insertEventMarker(length, marker);
4579 }
4580 ANGLE_CAPTURE(InsertEventMarkerEXT, isCallValid, context, length, marker);
4581 }
4582 else
4583 {
4584 GenerateContextLostErrorOnCurrentGlobalContext();
4585 }
4586 }
4587
GL_PopGroupMarkerEXT()4588 void GL_APIENTRY GL_PopGroupMarkerEXT()
4589 {
4590 Context *context = GetValidGlobalContext();
4591 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
4592 // It can interfere with the debug events being set by the caller.
4593 // EVENT(context, GLPopGroupMarkerEXT, "context = %d", CID(context));
4594
4595 if (context)
4596 {
4597 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4598 bool isCallValid =
4599 (context->skipValidation() ||
4600 ValidatePopGroupMarkerEXT(context, angle::EntryPoint::GLPopGroupMarkerEXT));
4601 if (isCallValid)
4602 {
4603 context->popGroupMarker();
4604 }
4605 ANGLE_CAPTURE(PopGroupMarkerEXT, isCallValid, context);
4606 }
4607 else
4608 {
4609 GenerateContextLostErrorOnCurrentGlobalContext();
4610 }
4611 }
4612
GL_PushGroupMarkerEXT(GLsizei length,const GLchar * marker)4613 void GL_APIENTRY GL_PushGroupMarkerEXT(GLsizei length, const GLchar *marker)
4614 {
4615 Context *context = GetValidGlobalContext();
4616 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
4617 // It can interfere with the debug events being set by the caller.
4618 // EVENT(context, GLPushGroupMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR "",
4619 // CID(context), length, (uintptr_t)marker);
4620
4621 if (context)
4622 {
4623 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4624 bool isCallValid = (context->skipValidation() ||
4625 ValidatePushGroupMarkerEXT(
4626 context, angle::EntryPoint::GLPushGroupMarkerEXT, length, marker));
4627 if (isCallValid)
4628 {
4629 context->pushGroupMarker(length, marker);
4630 }
4631 ANGLE_CAPTURE(PushGroupMarkerEXT, isCallValid, context, length, marker);
4632 }
4633 else
4634 {
4635 GenerateContextLostErrorOnCurrentGlobalContext();
4636 }
4637 }
4638
4639 // GL_EXT_discard_framebuffer
GL_DiscardFramebufferEXT(GLenum target,GLsizei numAttachments,const GLenum * attachments)4640 void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target,
4641 GLsizei numAttachments,
4642 const GLenum *attachments)
4643 {
4644 Context *context = GetValidGlobalContext();
4645 EVENT(context, GLDiscardFramebufferEXT,
4646 "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "",
4647 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments,
4648 (uintptr_t)attachments);
4649
4650 if (context)
4651 {
4652 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4653 bool isCallValid =
4654 (context->skipValidation() ||
4655 ValidateDiscardFramebufferEXT(context, angle::EntryPoint::GLDiscardFramebufferEXT,
4656 target, numAttachments, attachments));
4657 if (isCallValid)
4658 {
4659 context->discardFramebuffer(target, numAttachments, attachments);
4660 }
4661 ANGLE_CAPTURE(DiscardFramebufferEXT, isCallValid, context, target, numAttachments,
4662 attachments);
4663 }
4664 else
4665 {
4666 GenerateContextLostErrorOnCurrentGlobalContext();
4667 }
4668 }
4669
4670 // GL_EXT_disjoint_timer_query
GL_BeginQueryEXT(GLenum target,GLuint id)4671 void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id)
4672 {
4673 Context *context = GetValidGlobalContext();
4674 EVENT(context, GLBeginQueryEXT, "context = %d, target = %s, id = %u", CID(context),
4675 GLenumToString(GLenumGroup::QueryTarget, target), id);
4676
4677 if (context)
4678 {
4679 QueryType targetPacked = PackParam<QueryType>(target);
4680 QueryID idPacked = PackParam<QueryID>(id);
4681 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4682 bool isCallValid = (context->skipValidation() ||
4683 ValidateBeginQueryEXT(context, angle::EntryPoint::GLBeginQueryEXT,
4684 targetPacked, idPacked));
4685 if (isCallValid)
4686 {
4687 context->beginQuery(targetPacked, idPacked);
4688 }
4689 ANGLE_CAPTURE(BeginQueryEXT, isCallValid, context, targetPacked, idPacked);
4690 }
4691 else
4692 {
4693 GenerateContextLostErrorOnCurrentGlobalContext();
4694 }
4695 }
4696
GL_DeleteQueriesEXT(GLsizei n,const GLuint * ids)4697 void GL_APIENTRY GL_DeleteQueriesEXT(GLsizei n, const GLuint *ids)
4698 {
4699 Context *context = GetValidGlobalContext();
4700 EVENT(context, GLDeleteQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "",
4701 CID(context), n, (uintptr_t)ids);
4702
4703 if (context)
4704 {
4705 const QueryID *idsPacked = PackParam<const QueryID *>(ids);
4706 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4707 bool isCallValid = (context->skipValidation() ||
4708 ValidateDeleteQueriesEXT(context, angle::EntryPoint::GLDeleteQueriesEXT,
4709 n, idsPacked));
4710 if (isCallValid)
4711 {
4712 context->deleteQueries(n, idsPacked);
4713 }
4714 ANGLE_CAPTURE(DeleteQueriesEXT, isCallValid, context, n, idsPacked);
4715 }
4716 else
4717 {
4718 GenerateContextLostErrorOnCurrentGlobalContext();
4719 }
4720 }
4721
GL_EndQueryEXT(GLenum target)4722 void GL_APIENTRY GL_EndQueryEXT(GLenum target)
4723 {
4724 Context *context = GetValidGlobalContext();
4725 EVENT(context, GLEndQueryEXT, "context = %d, target = %s", CID(context),
4726 GLenumToString(GLenumGroup::QueryTarget, target));
4727
4728 if (context)
4729 {
4730 QueryType targetPacked = PackParam<QueryType>(target);
4731 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4732 bool isCallValid =
4733 (context->skipValidation() ||
4734 ValidateEndQueryEXT(context, angle::EntryPoint::GLEndQueryEXT, targetPacked));
4735 if (isCallValid)
4736 {
4737 context->endQuery(targetPacked);
4738 }
4739 ANGLE_CAPTURE(EndQueryEXT, isCallValid, context, targetPacked);
4740 }
4741 else
4742 {
4743 GenerateContextLostErrorOnCurrentGlobalContext();
4744 }
4745 }
4746
GL_GenQueriesEXT(GLsizei n,GLuint * ids)4747 void GL_APIENTRY GL_GenQueriesEXT(GLsizei n, GLuint *ids)
4748 {
4749 Context *context = GetValidGlobalContext();
4750 EVENT(context, GLGenQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context),
4751 n, (uintptr_t)ids);
4752
4753 if (context)
4754 {
4755 QueryID *idsPacked = PackParam<QueryID *>(ids);
4756 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4757 bool isCallValid =
4758 (context->skipValidation() ||
4759 ValidateGenQueriesEXT(context, angle::EntryPoint::GLGenQueriesEXT, n, idsPacked));
4760 if (isCallValid)
4761 {
4762 context->genQueries(n, idsPacked);
4763 }
4764 ANGLE_CAPTURE(GenQueriesEXT, isCallValid, context, n, idsPacked);
4765 }
4766 else
4767 {
4768 GenerateContextLostErrorOnCurrentGlobalContext();
4769 }
4770 }
4771
GL_GetInteger64vEXT(GLenum pname,GLint64 * data)4772 void GL_APIENTRY GL_GetInteger64vEXT(GLenum pname, GLint64 *data)
4773 {
4774 Context *context = GetValidGlobalContext();
4775 EVENT(context, GLGetInteger64vEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
4776 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
4777
4778 if (context)
4779 {
4780 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4781 bool isCallValid =
4782 (context->skipValidation() ||
4783 ValidateGetInteger64vEXT(context, angle::EntryPoint::GLGetInteger64vEXT, pname, data));
4784 if (isCallValid)
4785 {
4786 context->getInteger64v(pname, data);
4787 }
4788 ANGLE_CAPTURE(GetInteger64vEXT, isCallValid, context, pname, data);
4789 }
4790 else
4791 {
4792 GenerateContextLostErrorOnCurrentGlobalContext();
4793 }
4794 }
4795
GL_GetQueryObjecti64vEXT(GLuint id,GLenum pname,GLint64 * params)4796 void GL_APIENTRY GL_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
4797 {
4798 Context *context = GetGlobalContext();
4799 EVENT(context, GLGetQueryObjecti64vEXT,
4800 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4801 GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4802
4803 if (context)
4804 {
4805 QueryID idPacked = PackParam<QueryID>(id);
4806 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4807 bool isCallValid =
4808 (context->skipValidation() ||
4809 ValidateGetQueryObjecti64vEXT(context, angle::EntryPoint::GLGetQueryObjecti64vEXT,
4810 idPacked, pname, params));
4811 if (isCallValid)
4812 {
4813 context->getQueryObjecti64v(idPacked, pname, params);
4814 }
4815 ANGLE_CAPTURE(GetQueryObjecti64vEXT, isCallValid, context, idPacked, pname, params);
4816 }
4817 else
4818 {}
4819 }
4820
GL_GetQueryObjectivEXT(GLuint id,GLenum pname,GLint * params)4821 void GL_APIENTRY GL_GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
4822 {
4823 Context *context = GetGlobalContext();
4824 EVENT(context, GLGetQueryObjectivEXT,
4825 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4826 GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4827
4828 if (context)
4829 {
4830 QueryID idPacked = PackParam<QueryID>(id);
4831 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4832 bool isCallValid =
4833 (context->skipValidation() ||
4834 ValidateGetQueryObjectivEXT(context, angle::EntryPoint::GLGetQueryObjectivEXT,
4835 idPacked, pname, params));
4836 if (isCallValid)
4837 {
4838 context->getQueryObjectiv(idPacked, pname, params);
4839 }
4840 ANGLE_CAPTURE(GetQueryObjectivEXT, isCallValid, context, idPacked, pname, params);
4841 }
4842 else
4843 {}
4844 }
4845
GL_GetQueryObjectui64vEXT(GLuint id,GLenum pname,GLuint64 * params)4846 void GL_APIENTRY GL_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
4847 {
4848 Context *context = GetValidGlobalContext();
4849 EVENT(context, GLGetQueryObjectui64vEXT,
4850 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4851 GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4852
4853 if (context)
4854 {
4855 QueryID idPacked = PackParam<QueryID>(id);
4856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4857 bool isCallValid =
4858 (context->skipValidation() ||
4859 ValidateGetQueryObjectui64vEXT(context, angle::EntryPoint::GLGetQueryObjectui64vEXT,
4860 idPacked, pname, params));
4861 if (isCallValid)
4862 {
4863 context->getQueryObjectui64v(idPacked, pname, params);
4864 }
4865 ANGLE_CAPTURE(GetQueryObjectui64vEXT, isCallValid, context, idPacked, pname, params);
4866 }
4867 else
4868 {
4869 GenerateContextLostErrorOnCurrentGlobalContext();
4870 }
4871 }
4872
GL_GetQueryObjectuivEXT(GLuint id,GLenum pname,GLuint * params)4873 void GL_APIENTRY GL_GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
4874 {
4875 Context *context = GetValidGlobalContext();
4876 EVENT(context, GLGetQueryObjectuivEXT,
4877 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
4878 GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params);
4879
4880 if (context)
4881 {
4882 QueryID idPacked = PackParam<QueryID>(id);
4883 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4884 bool isCallValid =
4885 (context->skipValidation() ||
4886 ValidateGetQueryObjectuivEXT(context, angle::EntryPoint::GLGetQueryObjectuivEXT,
4887 idPacked, pname, params));
4888 if (isCallValid)
4889 {
4890 context->getQueryObjectuiv(idPacked, pname, params);
4891 }
4892 ANGLE_CAPTURE(GetQueryObjectuivEXT, isCallValid, context, idPacked, pname, params);
4893 }
4894 else
4895 {
4896 GenerateContextLostErrorOnCurrentGlobalContext();
4897 }
4898 }
4899
GL_GetQueryivEXT(GLenum target,GLenum pname,GLint * params)4900 void GL_APIENTRY GL_GetQueryivEXT(GLenum target, GLenum pname, GLint *params)
4901 {
4902 Context *context = GetValidGlobalContext();
4903 EVENT(context, GLGetQueryivEXT,
4904 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
4905 GLenumToString(GLenumGroup::QueryTarget, target),
4906 GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
4907
4908 if (context)
4909 {
4910 QueryType targetPacked = PackParam<QueryType>(target);
4911 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4912 bool isCallValid = (context->skipValidation() ||
4913 ValidateGetQueryivEXT(context, angle::EntryPoint::GLGetQueryivEXT,
4914 targetPacked, pname, params));
4915 if (isCallValid)
4916 {
4917 context->getQueryiv(targetPacked, pname, params);
4918 }
4919 ANGLE_CAPTURE(GetQueryivEXT, isCallValid, context, targetPacked, pname, params);
4920 }
4921 else
4922 {
4923 GenerateContextLostErrorOnCurrentGlobalContext();
4924 }
4925 }
4926
GL_IsQueryEXT(GLuint id)4927 GLboolean GL_APIENTRY GL_IsQueryEXT(GLuint id)
4928 {
4929 Context *context = GetValidGlobalContext();
4930 EVENT(context, GLIsQueryEXT, "context = %d, id = %u", CID(context), id);
4931
4932 GLboolean returnValue;
4933 if (context)
4934 {
4935 QueryID idPacked = PackParam<QueryID>(id);
4936 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4937 bool isCallValid = (context->skipValidation() ||
4938 ValidateIsQueryEXT(context, angle::EntryPoint::GLIsQueryEXT, idPacked));
4939 if (isCallValid)
4940 {
4941 returnValue = context->isQuery(idPacked);
4942 }
4943 else
4944 {
4945 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>();
4946 }
4947 ANGLE_CAPTURE(IsQueryEXT, isCallValid, context, idPacked, returnValue);
4948 }
4949 else
4950 {
4951 GenerateContextLostErrorOnCurrentGlobalContext();
4952 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>();
4953 }
4954 return returnValue;
4955 }
4956
GL_QueryCounterEXT(GLuint id,GLenum target)4957 void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target)
4958 {
4959 Context *context = GetValidGlobalContext();
4960 EVENT(context, GLQueryCounterEXT, "context = %d, id = %u, target = %s", CID(context), id,
4961 GLenumToString(GLenumGroup::QueryTarget, target));
4962
4963 if (context)
4964 {
4965 QueryID idPacked = PackParam<QueryID>(id);
4966 QueryType targetPacked = PackParam<QueryType>(target);
4967 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4968 bool isCallValid = (context->skipValidation() ||
4969 ValidateQueryCounterEXT(context, angle::EntryPoint::GLQueryCounterEXT,
4970 idPacked, targetPacked));
4971 if (isCallValid)
4972 {
4973 context->queryCounter(idPacked, targetPacked);
4974 }
4975 ANGLE_CAPTURE(QueryCounterEXT, isCallValid, context, idPacked, targetPacked);
4976 }
4977 else
4978 {
4979 GenerateContextLostErrorOnCurrentGlobalContext();
4980 }
4981 }
4982
4983 // GL_EXT_draw_buffers
GL_DrawBuffersEXT(GLsizei n,const GLenum * bufs)4984 void GL_APIENTRY GL_DrawBuffersEXT(GLsizei n, const GLenum *bufs)
4985 {
4986 Context *context = GetValidGlobalContext();
4987 EVENT(context, GLDrawBuffersEXT, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context),
4988 n, (uintptr_t)bufs);
4989
4990 if (context)
4991 {
4992 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
4993 bool isCallValid =
4994 (context->skipValidation() ||
4995 ValidateDrawBuffersEXT(context, angle::EntryPoint::GLDrawBuffersEXT, n, bufs));
4996 if (isCallValid)
4997 {
4998 context->drawBuffers(n, bufs);
4999 }
5000 ANGLE_CAPTURE(DrawBuffersEXT, isCallValid, context, n, bufs);
5001 }
5002 else
5003 {
5004 GenerateContextLostErrorOnCurrentGlobalContext();
5005 }
5006 }
5007
5008 // GL_EXT_draw_buffers_indexed
GL_BlendEquationSeparateiEXT(GLuint buf,GLenum modeRGB,GLenum modeAlpha)5009 void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
5010 {
5011 Context *context = GetValidGlobalContext();
5012 EVENT(context, GLBlendEquationSeparateiEXT,
5013 "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf,
5014 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
5015 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
5016
5017 if (context)
5018 {
5019 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5020 bool isCallValid =
5021 (context->skipValidation() ||
5022 ValidateBlendEquationSeparateiEXT(
5023 context, angle::EntryPoint::GLBlendEquationSeparateiEXT, buf, modeRGB, modeAlpha));
5024 if (isCallValid)
5025 {
5026 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
5027 }
5028 ANGLE_CAPTURE(BlendEquationSeparateiEXT, isCallValid, context, buf, modeRGB, modeAlpha);
5029 }
5030 else
5031 {
5032 GenerateContextLostErrorOnCurrentGlobalContext();
5033 }
5034 }
5035
GL_BlendEquationiEXT(GLuint buf,GLenum mode)5036 void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode)
5037 {
5038 Context *context = GetValidGlobalContext();
5039 EVENT(context, GLBlendEquationiEXT, "context = %d, buf = %u, mode = %s", CID(context), buf,
5040 GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
5041
5042 if (context)
5043 {
5044 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5045 bool isCallValid =
5046 (context->skipValidation() ||
5047 ValidateBlendEquationiEXT(context, angle::EntryPoint::GLBlendEquationiEXT, buf, mode));
5048 if (isCallValid)
5049 {
5050 context->blendEquationi(buf, mode);
5051 }
5052 ANGLE_CAPTURE(BlendEquationiEXT, isCallValid, context, buf, mode);
5053 }
5054 else
5055 {
5056 GenerateContextLostErrorOnCurrentGlobalContext();
5057 }
5058 }
5059
5060 void GL_APIENTRY
GL_BlendFuncSeparateiEXT(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)5061 GL_BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
5062 {
5063 Context *context = GetValidGlobalContext();
5064 EVENT(context, GLBlendFuncSeparateiEXT,
5065 "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s",
5066 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
5067 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
5068 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
5069 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
5070
5071 if (context)
5072 {
5073 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5074 bool isCallValid =
5075 (context->skipValidation() ||
5076 ValidateBlendFuncSeparateiEXT(context, angle::EntryPoint::GLBlendFuncSeparateiEXT, buf,
5077 srcRGB, dstRGB, srcAlpha, dstAlpha));
5078 if (isCallValid)
5079 {
5080 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
5081 }
5082 ANGLE_CAPTURE(BlendFuncSeparateiEXT, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
5083 dstAlpha);
5084 }
5085 else
5086 {
5087 GenerateContextLostErrorOnCurrentGlobalContext();
5088 }
5089 }
5090
GL_BlendFunciEXT(GLuint buf,GLenum src,GLenum dst)5091 void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst)
5092 {
5093 Context *context = GetValidGlobalContext();
5094 EVENT(context, GLBlendFunciEXT, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf,
5095 GLenumToString(GLenumGroup::BlendingFactor, src),
5096 GLenumToString(GLenumGroup::BlendingFactor, dst));
5097
5098 if (context)
5099 {
5100 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5101 bool isCallValid =
5102 (context->skipValidation() ||
5103 ValidateBlendFunciEXT(context, angle::EntryPoint::GLBlendFunciEXT, buf, src, dst));
5104 if (isCallValid)
5105 {
5106 context->blendFunci(buf, src, dst);
5107 }
5108 ANGLE_CAPTURE(BlendFunciEXT, isCallValid, context, buf, src, dst);
5109 }
5110 else
5111 {
5112 GenerateContextLostErrorOnCurrentGlobalContext();
5113 }
5114 }
5115
GL_ColorMaskiEXT(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)5116 void GL_APIENTRY GL_ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
5117 {
5118 Context *context = GetValidGlobalContext();
5119 EVENT(context, GLColorMaskiEXT, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s",
5120 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
5121 GLbooleanToString(a));
5122
5123 if (context)
5124 {
5125 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5126 bool isCallValid =
5127 (context->skipValidation() ||
5128 ValidateColorMaskiEXT(context, angle::EntryPoint::GLColorMaskiEXT, index, r, g, b, a));
5129 if (isCallValid)
5130 {
5131 context->colorMaski(index, r, g, b, a);
5132 }
5133 ANGLE_CAPTURE(ColorMaskiEXT, isCallValid, context, index, r, g, b, a);
5134 }
5135 else
5136 {
5137 GenerateContextLostErrorOnCurrentGlobalContext();
5138 }
5139 }
5140
GL_DisableiEXT(GLenum target,GLuint index)5141 void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index)
5142 {
5143 Context *context = GetValidGlobalContext();
5144 EVENT(context, GLDisableiEXT, "context = %d, target = %s, index = %u", CID(context),
5145 GLenumToString(GLenumGroup::EnableCap, target), index);
5146
5147 if (context)
5148 {
5149 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5150 bool isCallValid =
5151 (context->skipValidation() ||
5152 ValidateDisableiEXT(context, angle::EntryPoint::GLDisableiEXT, target, index));
5153 if (isCallValid)
5154 {
5155 context->disablei(target, index);
5156 }
5157 ANGLE_CAPTURE(DisableiEXT, isCallValid, context, target, index);
5158 }
5159 else
5160 {
5161 GenerateContextLostErrorOnCurrentGlobalContext();
5162 }
5163 }
5164
GL_EnableiEXT(GLenum target,GLuint index)5165 void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index)
5166 {
5167 Context *context = GetValidGlobalContext();
5168 EVENT(context, GLEnableiEXT, "context = %d, target = %s, index = %u", CID(context),
5169 GLenumToString(GLenumGroup::EnableCap, target), index);
5170
5171 if (context)
5172 {
5173 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5174 bool isCallValid =
5175 (context->skipValidation() ||
5176 ValidateEnableiEXT(context, angle::EntryPoint::GLEnableiEXT, target, index));
5177 if (isCallValid)
5178 {
5179 context->enablei(target, index);
5180 }
5181 ANGLE_CAPTURE(EnableiEXT, isCallValid, context, target, index);
5182 }
5183 else
5184 {
5185 GenerateContextLostErrorOnCurrentGlobalContext();
5186 }
5187 }
5188
GL_IsEnablediEXT(GLenum target,GLuint index)5189 GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index)
5190 {
5191 Context *context = GetValidGlobalContext();
5192 EVENT(context, GLIsEnablediEXT, "context = %d, target = %s, index = %u", CID(context),
5193 GLenumToString(GLenumGroup::EnableCap, target), index);
5194
5195 GLboolean returnValue;
5196 if (context)
5197 {
5198 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5199 bool isCallValid =
5200 (context->skipValidation() ||
5201 ValidateIsEnablediEXT(context, angle::EntryPoint::GLIsEnablediEXT, target, index));
5202 if (isCallValid)
5203 {
5204 returnValue = context->isEnabledi(target, index);
5205 }
5206 else
5207 {
5208 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>();
5209 }
5210 ANGLE_CAPTURE(IsEnablediEXT, isCallValid, context, target, index, returnValue);
5211 }
5212 else
5213 {
5214 GenerateContextLostErrorOnCurrentGlobalContext();
5215 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>();
5216 }
5217 return returnValue;
5218 }
5219
5220 // GL_EXT_draw_elements_base_vertex
GL_DrawElementsBaseVertexEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)5221 void GL_APIENTRY GL_DrawElementsBaseVertexEXT(GLenum mode,
5222 GLsizei count,
5223 GLenum type,
5224 const void *indices,
5225 GLint basevertex)
5226 {
5227 Context *context = GetValidGlobalContext();
5228 EVENT(context, GLDrawElementsBaseVertexEXT,
5229 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
5230 ", basevertex = %d",
5231 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
5232 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
5233
5234 if (context)
5235 {
5236 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5237 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5238 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5239 bool isCallValid = (context->skipValidation() ||
5240 ValidateDrawElementsBaseVertexEXT(
5241 context, angle::EntryPoint::GLDrawElementsBaseVertexEXT, modePacked,
5242 count, typePacked, indices, basevertex));
5243 if (isCallValid)
5244 {
5245 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
5246 }
5247 ANGLE_CAPTURE(DrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
5248 typePacked, indices, basevertex);
5249 }
5250 else
5251 {
5252 GenerateContextLostErrorOnCurrentGlobalContext();
5253 }
5254 }
5255
GL_DrawElementsInstancedBaseVertexEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)5256 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexEXT(GLenum mode,
5257 GLsizei count,
5258 GLenum type,
5259 const void *indices,
5260 GLsizei instancecount,
5261 GLint basevertex)
5262 {
5263 Context *context = GetValidGlobalContext();
5264 EVENT(context, GLDrawElementsInstancedBaseVertexEXT,
5265 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
5266 ", instancecount = %d, basevertex = %d",
5267 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
5268 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
5269 basevertex);
5270
5271 if (context)
5272 {
5273 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5274 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5275 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5276 bool isCallValid = (context->skipValidation() ||
5277 ValidateDrawElementsInstancedBaseVertexEXT(
5278 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexEXT,
5279 modePacked, count, typePacked, indices, instancecount, basevertex));
5280 if (isCallValid)
5281 {
5282 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
5283 instancecount, basevertex);
5284 }
5285 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexEXT, isCallValid, context, modePacked, count,
5286 typePacked, indices, instancecount, basevertex);
5287 }
5288 else
5289 {
5290 GenerateContextLostErrorOnCurrentGlobalContext();
5291 }
5292 }
5293
GL_DrawRangeElementsBaseVertexEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)5294 void GL_APIENTRY GL_DrawRangeElementsBaseVertexEXT(GLenum mode,
5295 GLuint start,
5296 GLuint end,
5297 GLsizei count,
5298 GLenum type,
5299 const void *indices,
5300 GLint basevertex)
5301 {
5302 Context *context = GetValidGlobalContext();
5303 EVENT(context, GLDrawRangeElementsBaseVertexEXT,
5304 "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
5305 "0x%016" PRIxPTR ", basevertex = %d",
5306 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
5307 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
5308
5309 if (context)
5310 {
5311 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5312 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5313 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5314 bool isCallValid = (context->skipValidation() ||
5315 ValidateDrawRangeElementsBaseVertexEXT(
5316 context, angle::EntryPoint::GLDrawRangeElementsBaseVertexEXT,
5317 modePacked, start, end, count, typePacked, indices, basevertex));
5318 if (isCallValid)
5319 {
5320 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
5321 basevertex);
5322 }
5323 ANGLE_CAPTURE(DrawRangeElementsBaseVertexEXT, isCallValid, context, modePacked, start, end,
5324 count, typePacked, indices, basevertex);
5325 }
5326 else
5327 {
5328 GenerateContextLostErrorOnCurrentGlobalContext();
5329 }
5330 }
5331
GL_MultiDrawElementsBaseVertexEXT(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei primcount,const GLint * basevertex)5332 void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode,
5333 const GLsizei *count,
5334 GLenum type,
5335 const void *const *indices,
5336 GLsizei primcount,
5337 const GLint *basevertex)
5338 {
5339 Context *context = GetValidGlobalContext();
5340 EVENT(context, GLMultiDrawElementsBaseVertexEXT,
5341 "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
5342 ", primcount = %d, basevertex = 0x%016" PRIxPTR "",
5343 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count,
5344 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount,
5345 (uintptr_t)basevertex);
5346
5347 if (context)
5348 {
5349 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5350 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5351 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5352 bool isCallValid = (context->skipValidation() ||
5353 ValidateMultiDrawElementsBaseVertexEXT(
5354 context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT,
5355 modePacked, count, typePacked, indices, primcount, basevertex));
5356 if (isCallValid)
5357 {
5358 context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, primcount,
5359 basevertex);
5360 }
5361 ANGLE_CAPTURE(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
5362 typePacked, indices, primcount, basevertex);
5363 }
5364 else
5365 {
5366 GenerateContextLostErrorOnCurrentGlobalContext();
5367 }
5368 }
5369
5370 // GL_EXT_external_buffer
GL_BufferStorageExternalEXT(GLenum target,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)5371 void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target,
5372 GLintptr offset,
5373 GLsizeiptr size,
5374 GLeglClientBufferEXT clientBuffer,
5375 GLbitfield flags)
5376 {
5377 Context *context = GetValidGlobalContext();
5378 EVENT(context, GLBufferStorageExternalEXT,
5379 "context = %d, target = %s, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR
5380 ", flags = %s",
5381 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target),
5382 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
5383 (uintptr_t)clientBuffer,
5384 GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str());
5385
5386 if (context)
5387 {
5388 BufferBinding targetPacked = PackParam<BufferBinding>(target);
5389 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5390 bool isCallValid = (context->skipValidation() ||
5391 ValidateBufferStorageExternalEXT(
5392 context, angle::EntryPoint::GLBufferStorageExternalEXT,
5393 targetPacked, offset, size, clientBuffer, flags));
5394 if (isCallValid)
5395 {
5396 context->bufferStorageExternal(targetPacked, offset, size, clientBuffer, flags);
5397 }
5398 ANGLE_CAPTURE(BufferStorageExternalEXT, isCallValid, context, targetPacked, offset, size,
5399 clientBuffer, flags);
5400 }
5401 else
5402 {
5403 GenerateContextLostErrorOnCurrentGlobalContext();
5404 }
5405 }
5406
GL_NamedBufferStorageExternalEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)5407 void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer,
5408 GLintptr offset,
5409 GLsizeiptr size,
5410 GLeglClientBufferEXT clientBuffer,
5411 GLbitfield flags)
5412 {
5413 Context *context = GetValidGlobalContext();
5414 EVENT(context, GLNamedBufferStorageExternalEXT,
5415 "context = %d, buffer = %u, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR
5416 ", flags = %s",
5417 CID(context), buffer, static_cast<unsigned long long>(offset),
5418 static_cast<unsigned long long>(size), (uintptr_t)clientBuffer,
5419 GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str());
5420
5421 if (context)
5422 {
5423 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5424 bool isCallValid = (context->skipValidation() ||
5425 ValidateNamedBufferStorageExternalEXT(
5426 context, angle::EntryPoint::GLNamedBufferStorageExternalEXT, buffer,
5427 offset, size, clientBuffer, flags));
5428 if (isCallValid)
5429 {
5430 context->namedBufferStorageExternal(buffer, offset, size, clientBuffer, flags);
5431 }
5432 ANGLE_CAPTURE(NamedBufferStorageExternalEXT, isCallValid, context, buffer, offset, size,
5433 clientBuffer, flags);
5434 }
5435 else
5436 {
5437 GenerateContextLostErrorOnCurrentGlobalContext();
5438 }
5439 }
5440
5441 // GL_EXT_float_blend
5442
5443 // GL_EXT_geometry_shader
GL_FramebufferTextureEXT(GLenum target,GLenum attachment,GLuint texture,GLint level)5444 void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target,
5445 GLenum attachment,
5446 GLuint texture,
5447 GLint level)
5448 {
5449 Context *context = GetValidGlobalContext();
5450 EVENT(context, GLFramebufferTextureEXT,
5451 "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context),
5452 GLenumToString(GLenumGroup::FramebufferTarget, target),
5453 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
5454
5455 if (context)
5456 {
5457 TextureID texturePacked = PackParam<TextureID>(texture);
5458 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5459 bool isCallValid =
5460 (context->skipValidation() ||
5461 ValidateFramebufferTextureEXT(context, angle::EntryPoint::GLFramebufferTextureEXT,
5462 target, attachment, texturePacked, level));
5463 if (isCallValid)
5464 {
5465 context->framebufferTexture(target, attachment, texturePacked, level);
5466 }
5467 ANGLE_CAPTURE(FramebufferTextureEXT, isCallValid, context, target, attachment,
5468 texturePacked, level);
5469 }
5470 else
5471 {
5472 GenerateContextLostErrorOnCurrentGlobalContext();
5473 }
5474 }
5475
5476 // GL_EXT_gpu_shader5
5477
5478 // GL_EXT_instanced_arrays
GL_DrawArraysInstancedEXT(GLenum mode,GLint start,GLsizei count,GLsizei primcount)5479 void GL_APIENTRY GL_DrawArraysInstancedEXT(GLenum mode,
5480 GLint start,
5481 GLsizei count,
5482 GLsizei primcount)
5483 {
5484 Context *context = GetValidGlobalContext();
5485 EVENT(context, GLDrawArraysInstancedEXT,
5486 "context = %d, mode = %s, start = %d, count = %d, primcount = %d", CID(context),
5487 GLenumToString(GLenumGroup::PrimitiveType, mode), start, count, primcount);
5488
5489 if (context)
5490 {
5491 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5492 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5493 bool isCallValid =
5494 (context->skipValidation() ||
5495 ValidateDrawArraysInstancedEXT(context, angle::EntryPoint::GLDrawArraysInstancedEXT,
5496 modePacked, start, count, primcount));
5497 if (isCallValid)
5498 {
5499 context->drawArraysInstanced(modePacked, start, count, primcount);
5500 }
5501 ANGLE_CAPTURE(DrawArraysInstancedEXT, isCallValid, context, modePacked, start, count,
5502 primcount);
5503 }
5504 else
5505 {
5506 GenerateContextLostErrorOnCurrentGlobalContext();
5507 }
5508 }
5509
GL_DrawElementsInstancedEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)5510 void GL_APIENTRY GL_DrawElementsInstancedEXT(GLenum mode,
5511 GLsizei count,
5512 GLenum type,
5513 const void *indices,
5514 GLsizei primcount)
5515 {
5516 Context *context = GetValidGlobalContext();
5517 EVENT(context, GLDrawElementsInstancedEXT,
5518 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
5519 ", primcount = %d",
5520 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
5521 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount);
5522
5523 if (context)
5524 {
5525 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5526 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5527 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5528 bool isCallValid = (context->skipValidation() ||
5529 ValidateDrawElementsInstancedEXT(
5530 context, angle::EntryPoint::GLDrawElementsInstancedEXT, modePacked,
5531 count, typePacked, indices, primcount));
5532 if (isCallValid)
5533 {
5534 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
5535 }
5536 ANGLE_CAPTURE(DrawElementsInstancedEXT, isCallValid, context, modePacked, count, typePacked,
5537 indices, primcount);
5538 }
5539 else
5540 {
5541 GenerateContextLostErrorOnCurrentGlobalContext();
5542 }
5543 }
5544
GL_VertexAttribDivisorEXT(GLuint index,GLuint divisor)5545 void GL_APIENTRY GL_VertexAttribDivisorEXT(GLuint index, GLuint divisor)
5546 {
5547 Context *context = GetValidGlobalContext();
5548 EVENT(context, GLVertexAttribDivisorEXT, "context = %d, index = %u, divisor = %u", CID(context),
5549 index, divisor);
5550
5551 if (context)
5552 {
5553 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5554 bool isCallValid =
5555 (context->skipValidation() ||
5556 ValidateVertexAttribDivisorEXT(context, angle::EntryPoint::GLVertexAttribDivisorEXT,
5557 index, divisor));
5558 if (isCallValid)
5559 {
5560 context->vertexAttribDivisor(index, divisor);
5561 }
5562 ANGLE_CAPTURE(VertexAttribDivisorEXT, isCallValid, context, index, divisor);
5563 }
5564 else
5565 {
5566 GenerateContextLostErrorOnCurrentGlobalContext();
5567 }
5568 }
5569
5570 // GL_EXT_map_buffer_range
GL_FlushMappedBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length)5571 void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
5572 {
5573 Context *context = GetValidGlobalContext();
5574 EVENT(context, GLFlushMappedBufferRangeEXT,
5575 "context = %d, target = %s, offset = %llu, length = %llu", CID(context),
5576 GLenumToString(GLenumGroup::BufferTargetARB, target),
5577 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
5578
5579 if (context)
5580 {
5581 BufferBinding targetPacked = PackParam<BufferBinding>(target);
5582 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5583 bool isCallValid = (context->skipValidation() ||
5584 ValidateFlushMappedBufferRangeEXT(
5585 context, angle::EntryPoint::GLFlushMappedBufferRangeEXT,
5586 targetPacked, offset, length));
5587 if (isCallValid)
5588 {
5589 context->flushMappedBufferRange(targetPacked, offset, length);
5590 }
5591 ANGLE_CAPTURE(FlushMappedBufferRangeEXT, isCallValid, context, targetPacked, offset,
5592 length);
5593 }
5594 else
5595 {
5596 GenerateContextLostErrorOnCurrentGlobalContext();
5597 }
5598 }
5599
GL_MapBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)5600 void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target,
5601 GLintptr offset,
5602 GLsizeiptr length,
5603 GLbitfield access)
5604 {
5605 Context *context = GetValidGlobalContext();
5606 EVENT(context, GLMapBufferRangeEXT,
5607 "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context),
5608 GLenumToString(GLenumGroup::BufferTargetARB, target),
5609 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
5610 GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str());
5611
5612 void *returnValue;
5613 if (context)
5614 {
5615 BufferBinding targetPacked = PackParam<BufferBinding>(target);
5616 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5617 bool isCallValid =
5618 (context->skipValidation() ||
5619 ValidateMapBufferRangeEXT(context, angle::EntryPoint::GLMapBufferRangeEXT,
5620 targetPacked, offset, length, access));
5621 if (isCallValid)
5622 {
5623 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
5624 }
5625 else
5626 {
5627 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>();
5628 }
5629 ANGLE_CAPTURE(MapBufferRangeEXT, isCallValid, context, targetPacked, offset, length, access,
5630 returnValue);
5631 }
5632 else
5633 {
5634 GenerateContextLostErrorOnCurrentGlobalContext();
5635 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>();
5636 }
5637 return returnValue;
5638 }
5639
5640 // GL_EXT_memory_object
GL_BufferStorageMemEXT(GLenum target,GLsizeiptr size,GLuint memory,GLuint64 offset)5641 void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target,
5642 GLsizeiptr size,
5643 GLuint memory,
5644 GLuint64 offset)
5645 {
5646 Context *context = GetValidGlobalContext();
5647 EVENT(context, GLBufferStorageMemEXT,
5648 "context = %d, target = %s, size = %llu, memory = %u, offset = %llu", CID(context),
5649 GLenumToString(GLenumGroup::BufferTargetARB, target),
5650 static_cast<unsigned long long>(size), memory, static_cast<unsigned long long>(offset));
5651
5652 if (context)
5653 {
5654 TextureType targetPacked = PackParam<TextureType>(target);
5655 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
5656 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5657 bool isCallValid =
5658 (context->skipValidation() ||
5659 ValidateBufferStorageMemEXT(context, angle::EntryPoint::GLBufferStorageMemEXT,
5660 targetPacked, size, memoryPacked, offset));
5661 if (isCallValid)
5662 {
5663 context->bufferStorageMem(targetPacked, size, memoryPacked, offset);
5664 }
5665 ANGLE_CAPTURE(BufferStorageMemEXT, isCallValid, context, targetPacked, size, memoryPacked,
5666 offset);
5667 }
5668 else
5669 {
5670 GenerateContextLostErrorOnCurrentGlobalContext();
5671 }
5672 }
5673
GL_CreateMemoryObjectsEXT(GLsizei n,GLuint * memoryObjects)5674 void GL_APIENTRY GL_CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
5675 {
5676 Context *context = GetValidGlobalContext();
5677 EVENT(context, GLCreateMemoryObjectsEXT,
5678 "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n,
5679 (uintptr_t)memoryObjects);
5680
5681 if (context)
5682 {
5683 MemoryObjectID *memoryObjectsPacked = PackParam<MemoryObjectID *>(memoryObjects);
5684 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5685 bool isCallValid =
5686 (context->skipValidation() ||
5687 ValidateCreateMemoryObjectsEXT(context, angle::EntryPoint::GLCreateMemoryObjectsEXT, n,
5688 memoryObjectsPacked));
5689 if (isCallValid)
5690 {
5691 context->createMemoryObjects(n, memoryObjectsPacked);
5692 }
5693 ANGLE_CAPTURE(CreateMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
5694 }
5695 else
5696 {
5697 GenerateContextLostErrorOnCurrentGlobalContext();
5698 }
5699 }
5700
GL_DeleteMemoryObjectsEXT(GLsizei n,const GLuint * memoryObjects)5701 void GL_APIENTRY GL_DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
5702 {
5703 Context *context = GetValidGlobalContext();
5704 EVENT(context, GLDeleteMemoryObjectsEXT,
5705 "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n,
5706 (uintptr_t)memoryObjects);
5707
5708 if (context)
5709 {
5710 const MemoryObjectID *memoryObjectsPacked =
5711 PackParam<const MemoryObjectID *>(memoryObjects);
5712 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5713 bool isCallValid =
5714 (context->skipValidation() ||
5715 ValidateDeleteMemoryObjectsEXT(context, angle::EntryPoint::GLDeleteMemoryObjectsEXT, n,
5716 memoryObjectsPacked));
5717 if (isCallValid)
5718 {
5719 context->deleteMemoryObjects(n, memoryObjectsPacked);
5720 }
5721 ANGLE_CAPTURE(DeleteMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
5722 }
5723 else
5724 {
5725 GenerateContextLostErrorOnCurrentGlobalContext();
5726 }
5727 }
5728
GL_GetMemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,GLint * params)5729 void GL_APIENTRY GL_GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
5730 {
5731 Context *context = GetValidGlobalContext();
5732 EVENT(context, GLGetMemoryObjectParameterivEXT,
5733 "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5734 memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
5735 (uintptr_t)params);
5736
5737 if (context)
5738 {
5739 MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
5740 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5741 bool isCallValid = (context->skipValidation() ||
5742 ValidateGetMemoryObjectParameterivEXT(
5743 context, angle::EntryPoint::GLGetMemoryObjectParameterivEXT,
5744 memoryObjectPacked, pname, params));
5745 if (isCallValid)
5746 {
5747 context->getMemoryObjectParameteriv(memoryObjectPacked, pname, params);
5748 }
5749 ANGLE_CAPTURE(GetMemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked,
5750 pname, params);
5751 }
5752 else
5753 {
5754 GenerateContextLostErrorOnCurrentGlobalContext();
5755 }
5756 }
5757
GL_GetUnsignedBytevEXT(GLenum pname,GLubyte * data)5758 void GL_APIENTRY GL_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
5759 {
5760 Context *context = GetValidGlobalContext();
5761 EVENT(context, GLGetUnsignedBytevEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
5762 CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
5763
5764 if (context)
5765 {
5766 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5767 bool isCallValid = (context->skipValidation() ||
5768 ValidateGetUnsignedBytevEXT(
5769 context, angle::EntryPoint::GLGetUnsignedBytevEXT, pname, data));
5770 if (isCallValid)
5771 {
5772 context->getUnsignedBytev(pname, data);
5773 }
5774 ANGLE_CAPTURE(GetUnsignedBytevEXT, isCallValid, context, pname, data);
5775 }
5776 else
5777 {
5778 GenerateContextLostErrorOnCurrentGlobalContext();
5779 }
5780 }
5781
GL_GetUnsignedBytei_vEXT(GLenum target,GLuint index,GLubyte * data)5782 void GL_APIENTRY GL_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
5783 {
5784 Context *context = GetValidGlobalContext();
5785 EVENT(context, GLGetUnsignedBytei_vEXT,
5786 "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context),
5787 GLenumToString(GLenumGroup::DefaultGroup, target), index, (uintptr_t)data);
5788
5789 if (context)
5790 {
5791 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5792 bool isCallValid =
5793 (context->skipValidation() ||
5794 ValidateGetUnsignedBytei_vEXT(context, angle::EntryPoint::GLGetUnsignedBytei_vEXT,
5795 target, index, data));
5796 if (isCallValid)
5797 {
5798 context->getUnsignedBytei_v(target, index, data);
5799 }
5800 ANGLE_CAPTURE(GetUnsignedBytei_vEXT, isCallValid, context, target, index, data);
5801 }
5802 else
5803 {
5804 GenerateContextLostErrorOnCurrentGlobalContext();
5805 }
5806 }
5807
GL_IsMemoryObjectEXT(GLuint memoryObject)5808 GLboolean GL_APIENTRY GL_IsMemoryObjectEXT(GLuint memoryObject)
5809 {
5810 Context *context = GetValidGlobalContext();
5811 EVENT(context, GLIsMemoryObjectEXT, "context = %d, memoryObject = %u", CID(context),
5812 memoryObject);
5813
5814 GLboolean returnValue;
5815 if (context)
5816 {
5817 MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
5818 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5819 bool isCallValid =
5820 (context->skipValidation() ||
5821 ValidateIsMemoryObjectEXT(context, angle::EntryPoint::GLIsMemoryObjectEXT,
5822 memoryObjectPacked));
5823 if (isCallValid)
5824 {
5825 returnValue = context->isMemoryObject(memoryObjectPacked);
5826 }
5827 else
5828 {
5829 returnValue =
5830 GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>();
5831 }
5832 ANGLE_CAPTURE(IsMemoryObjectEXT, isCallValid, context, memoryObjectPacked, returnValue);
5833 }
5834 else
5835 {
5836 GenerateContextLostErrorOnCurrentGlobalContext();
5837 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>();
5838 }
5839 return returnValue;
5840 }
5841
GL_MemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,const GLint * params)5842 void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject,
5843 GLenum pname,
5844 const GLint *params)
5845 {
5846 Context *context = GetValidGlobalContext();
5847 EVENT(context, GLMemoryObjectParameterivEXT,
5848 "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5849 memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname),
5850 (uintptr_t)params);
5851
5852 if (context)
5853 {
5854 MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
5855 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5856 bool isCallValid = (context->skipValidation() ||
5857 ValidateMemoryObjectParameterivEXT(
5858 context, angle::EntryPoint::GLMemoryObjectParameterivEXT,
5859 memoryObjectPacked, pname, params));
5860 if (isCallValid)
5861 {
5862 context->memoryObjectParameteriv(memoryObjectPacked, pname, params);
5863 }
5864 ANGLE_CAPTURE(MemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked, pname,
5865 params);
5866 }
5867 else
5868 {
5869 GenerateContextLostErrorOnCurrentGlobalContext();
5870 }
5871 }
5872
GL_TexStorageMem2DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset)5873 void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target,
5874 GLsizei levels,
5875 GLenum internalFormat,
5876 GLsizei width,
5877 GLsizei height,
5878 GLuint memory,
5879 GLuint64 offset)
5880 {
5881 Context *context = GetValidGlobalContext();
5882 EVENT(context, GLTexStorageMem2DEXT,
5883 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
5884 "memory = %u, offset = %llu",
5885 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
5886 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory,
5887 static_cast<unsigned long long>(offset));
5888
5889 if (context)
5890 {
5891 TextureType targetPacked = PackParam<TextureType>(target);
5892 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
5893 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5894 bool isCallValid = (context->skipValidation() ||
5895 ValidateTexStorageMem2DEXT(
5896 context, angle::EntryPoint::GLTexStorageMem2DEXT, targetPacked,
5897 levels, internalFormat, width, height, memoryPacked, offset));
5898 if (isCallValid)
5899 {
5900 context->texStorageMem2D(targetPacked, levels, internalFormat, width, height,
5901 memoryPacked, offset);
5902 }
5903 ANGLE_CAPTURE(TexStorageMem2DEXT, isCallValid, context, targetPacked, levels,
5904 internalFormat, width, height, memoryPacked, offset);
5905 }
5906 else
5907 {
5908 GenerateContextLostErrorOnCurrentGlobalContext();
5909 }
5910 }
5911
GL_TexStorageMem2DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)5912 void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target,
5913 GLsizei samples,
5914 GLenum internalFormat,
5915 GLsizei width,
5916 GLsizei height,
5917 GLboolean fixedSampleLocations,
5918 GLuint memory,
5919 GLuint64 offset)
5920 {
5921 Context *context = GetValidGlobalContext();
5922 EVENT(context, GLTexStorageMem2DMultisampleEXT,
5923 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
5924 "fixedSampleLocations = %s, memory = %u, offset = %llu",
5925 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
5926 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height,
5927 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
5928
5929 if (context)
5930 {
5931 TextureType targetPacked = PackParam<TextureType>(target);
5932 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
5933 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5934 bool isCallValid =
5935 (context->skipValidation() ||
5936 ValidateTexStorageMem2DMultisampleEXT(
5937 context, angle::EntryPoint::GLTexStorageMem2DMultisampleEXT, targetPacked, samples,
5938 internalFormat, width, height, fixedSampleLocations, memoryPacked, offset));
5939 if (isCallValid)
5940 {
5941 context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
5942 height, fixedSampleLocations, memoryPacked, offset);
5943 }
5944 ANGLE_CAPTURE(TexStorageMem2DMultisampleEXT, isCallValid, context, targetPacked, samples,
5945 internalFormat, width, height, fixedSampleLocations, memoryPacked, offset);
5946 }
5947 else
5948 {
5949 GenerateContextLostErrorOnCurrentGlobalContext();
5950 }
5951 }
5952
GL_TexStorageMem3DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset)5953 void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target,
5954 GLsizei levels,
5955 GLenum internalFormat,
5956 GLsizei width,
5957 GLsizei height,
5958 GLsizei depth,
5959 GLuint memory,
5960 GLuint64 offset)
5961 {
5962 Context *context = GetValidGlobalContext();
5963 EVENT(context, GLTexStorageMem3DEXT,
5964 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
5965 "depth = %d, memory = %u, offset = %llu",
5966 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
5967 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory,
5968 static_cast<unsigned long long>(offset));
5969
5970 if (context)
5971 {
5972 TextureType targetPacked = PackParam<TextureType>(target);
5973 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
5974 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
5975 bool isCallValid =
5976 (context->skipValidation() ||
5977 ValidateTexStorageMem3DEXT(context, angle::EntryPoint::GLTexStorageMem3DEXT,
5978 targetPacked, levels, internalFormat, width, height, depth,
5979 memoryPacked, offset));
5980 if (isCallValid)
5981 {
5982 context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
5983 memoryPacked, offset);
5984 }
5985 ANGLE_CAPTURE(TexStorageMem3DEXT, isCallValid, context, targetPacked, levels,
5986 internalFormat, width, height, depth, memoryPacked, offset);
5987 }
5988 else
5989 {
5990 GenerateContextLostErrorOnCurrentGlobalContext();
5991 }
5992 }
5993
GL_TexStorageMem3DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)5994 void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target,
5995 GLsizei samples,
5996 GLenum internalFormat,
5997 GLsizei width,
5998 GLsizei height,
5999 GLsizei depth,
6000 GLboolean fixedSampleLocations,
6001 GLuint memory,
6002 GLuint64 offset)
6003 {
6004 Context *context = GetValidGlobalContext();
6005 EVENT(context, GLTexStorageMem3DMultisampleEXT,
6006 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
6007 "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu",
6008 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
6009 GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth,
6010 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
6011
6012 if (context)
6013 {
6014 TextureType targetPacked = PackParam<TextureType>(target);
6015 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
6016 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6017 bool isCallValid =
6018 (context->skipValidation() ||
6019 ValidateTexStorageMem3DMultisampleEXT(
6020 context, angle::EntryPoint::GLTexStorageMem3DMultisampleEXT, targetPacked, samples,
6021 internalFormat, width, height, depth, fixedSampleLocations, memoryPacked, offset));
6022 if (isCallValid)
6023 {
6024 context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
6025 height, depth, fixedSampleLocations, memoryPacked,
6026 offset);
6027 }
6028 ANGLE_CAPTURE(TexStorageMem3DMultisampleEXT, isCallValid, context, targetPacked, samples,
6029 internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
6030 offset);
6031 }
6032 else
6033 {
6034 GenerateContextLostErrorOnCurrentGlobalContext();
6035 }
6036 }
6037
6038 // GL_EXT_memory_object_fd
GL_ImportMemoryFdEXT(GLuint memory,GLuint64 size,GLenum handleType,GLint fd)6039 void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
6040 {
6041 Context *context = GetValidGlobalContext();
6042 EVENT(context, GLImportMemoryFdEXT,
6043 "context = %d, memory = %u, size = %llu, handleType = %s, fd = %d", CID(context), memory,
6044 static_cast<unsigned long long>(size),
6045 GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
6046
6047 if (context)
6048 {
6049 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
6050 HandleType handleTypePacked = PackParam<HandleType>(handleType);
6051 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6052 bool isCallValid =
6053 (context->skipValidation() ||
6054 ValidateImportMemoryFdEXT(context, angle::EntryPoint::GLImportMemoryFdEXT,
6055 memoryPacked, size, handleTypePacked, fd));
6056 if (isCallValid)
6057 {
6058 context->importMemoryFd(memoryPacked, size, handleTypePacked, fd);
6059 }
6060 ANGLE_CAPTURE(ImportMemoryFdEXT, isCallValid, context, memoryPacked, size, handleTypePacked,
6061 fd);
6062 }
6063 else
6064 {
6065 GenerateContextLostErrorOnCurrentGlobalContext();
6066 }
6067 }
6068
6069 // GL_EXT_multi_draw_indirect
GL_MultiDrawArraysIndirectEXT(GLenum mode,const void * indirect,GLsizei drawcount,GLsizei stride)6070 void GL_APIENTRY GL_MultiDrawArraysIndirectEXT(GLenum mode,
6071 const void *indirect,
6072 GLsizei drawcount,
6073 GLsizei stride)
6074 {
6075 Context *context = GetValidGlobalContext();
6076 EVENT(context, GLMultiDrawArraysIndirectEXT,
6077 "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d",
6078 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect,
6079 drawcount, stride);
6080
6081 if (context)
6082 {
6083 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6084 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6085 bool isCallValid = (context->skipValidation() ||
6086 ValidateMultiDrawArraysIndirectEXT(
6087 context, angle::EntryPoint::GLMultiDrawArraysIndirectEXT,
6088 modePacked, indirect, drawcount, stride));
6089 if (isCallValid)
6090 {
6091 context->multiDrawArraysIndirect(modePacked, indirect, drawcount, stride);
6092 }
6093 ANGLE_CAPTURE(MultiDrawArraysIndirectEXT, isCallValid, context, modePacked, indirect,
6094 drawcount, stride);
6095 }
6096 else
6097 {
6098 GenerateContextLostErrorOnCurrentGlobalContext();
6099 }
6100 }
6101
GL_MultiDrawElementsIndirectEXT(GLenum mode,GLenum type,const void * indirect,GLsizei drawcount,GLsizei stride)6102 void GL_APIENTRY GL_MultiDrawElementsIndirectEXT(GLenum mode,
6103 GLenum type,
6104 const void *indirect,
6105 GLsizei drawcount,
6106 GLsizei stride)
6107 {
6108 Context *context = GetValidGlobalContext();
6109 EVENT(context, GLMultiDrawElementsIndirectEXT,
6110 "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR
6111 ", drawcount = %d, stride = %d",
6112 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode),
6113 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect, drawcount,
6114 stride);
6115
6116 if (context)
6117 {
6118 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6119 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
6120 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6121 bool isCallValid = (context->skipValidation() ||
6122 ValidateMultiDrawElementsIndirectEXT(
6123 context, angle::EntryPoint::GLMultiDrawElementsIndirectEXT,
6124 modePacked, typePacked, indirect, drawcount, stride));
6125 if (isCallValid)
6126 {
6127 context->multiDrawElementsIndirect(modePacked, typePacked, indirect, drawcount, stride);
6128 }
6129 ANGLE_CAPTURE(MultiDrawElementsIndirectEXT, isCallValid, context, modePacked, typePacked,
6130 indirect, drawcount, stride);
6131 }
6132 else
6133 {
6134 GenerateContextLostErrorOnCurrentGlobalContext();
6135 }
6136 }
6137
6138 // GL_EXT_multisampled_render_to_texture
GL_FramebufferTexture2DMultisampleEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)6139 void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target,
6140 GLenum attachment,
6141 GLenum textarget,
6142 GLuint texture,
6143 GLint level,
6144 GLsizei samples)
6145 {
6146 Context *context = GetValidGlobalContext();
6147 EVENT(context, GLFramebufferTexture2DMultisampleEXT,
6148 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
6149 "samples = %d",
6150 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
6151 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
6152 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, samples);
6153
6154 if (context)
6155 {
6156 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
6157 TextureID texturePacked = PackParam<TextureID>(texture);
6158 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6159 bool isCallValid =
6160 (context->skipValidation() ||
6161 ValidateFramebufferTexture2DMultisampleEXT(
6162 context, angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT, target,
6163 attachment, textargetPacked, texturePacked, level, samples));
6164 if (isCallValid)
6165 {
6166 context->framebufferTexture2DMultisample(target, attachment, textargetPacked,
6167 texturePacked, level, samples);
6168 }
6169 ANGLE_CAPTURE(FramebufferTexture2DMultisampleEXT, isCallValid, context, target, attachment,
6170 textargetPacked, texturePacked, level, samples);
6171 }
6172 else
6173 {
6174 GenerateContextLostErrorOnCurrentGlobalContext();
6175 }
6176 }
6177
GL_RenderbufferStorageMultisampleEXT(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)6178 void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target,
6179 GLsizei samples,
6180 GLenum internalformat,
6181 GLsizei width,
6182 GLsizei height)
6183 {
6184 Context *context = GetValidGlobalContext();
6185 EVENT(context, GLRenderbufferStorageMultisampleEXT,
6186 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
6187 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples,
6188 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
6189
6190 if (context)
6191 {
6192 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6193 bool isCallValid = (context->skipValidation() ||
6194 ValidateRenderbufferStorageMultisampleEXT(
6195 context, angle::EntryPoint::GLRenderbufferStorageMultisampleEXT,
6196 target, samples, internalformat, width, height));
6197 if (isCallValid)
6198 {
6199 context->renderbufferStorageMultisampleEXT(target, samples, internalformat, width,
6200 height);
6201 }
6202 ANGLE_CAPTURE(RenderbufferStorageMultisampleEXT, isCallValid, context, target, samples,
6203 internalformat, width, height);
6204 }
6205 else
6206 {
6207 GenerateContextLostErrorOnCurrentGlobalContext();
6208 }
6209 }
6210
6211 // GL_EXT_occlusion_query_boolean
6212 // BeginQueryEXT is already defined.
6213
6214 // DeleteQueriesEXT is already defined.
6215
6216 // EndQueryEXT is already defined.
6217
6218 // GenQueriesEXT is already defined.
6219
6220 // GetQueryObjectuivEXT is already defined.
6221
6222 // GetQueryivEXT is already defined.
6223
6224 // IsQueryEXT is already defined.
6225
6226 // GL_EXT_primitive_bounding_box
GL_PrimitiveBoundingBoxEXT(GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)6227 void GL_APIENTRY GL_PrimitiveBoundingBoxEXT(GLfloat minX,
6228 GLfloat minY,
6229 GLfloat minZ,
6230 GLfloat minW,
6231 GLfloat maxX,
6232 GLfloat maxY,
6233 GLfloat maxZ,
6234 GLfloat maxW)
6235 {
6236 Context *context = GetValidGlobalContext();
6237 EVENT(context, GLPrimitiveBoundingBoxEXT,
6238 "context = %d, minX = %f, minY = %f, minZ = %f, minW = %f, maxX = %f, maxY = %f, maxZ = "
6239 "%f, maxW = %f",
6240 CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
6241
6242 if (context)
6243 {
6244 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6245 bool isCallValid =
6246 (context->skipValidation() ||
6247 ValidatePrimitiveBoundingBoxEXT(context, angle::EntryPoint::GLPrimitiveBoundingBoxEXT,
6248 minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
6249 if (isCallValid)
6250 {
6251 context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
6252 }
6253 ANGLE_CAPTURE(PrimitiveBoundingBoxEXT, isCallValid, context, minX, minY, minZ, minW, maxX,
6254 maxY, maxZ, maxW);
6255 }
6256 else
6257 {
6258 GenerateContextLostErrorOnCurrentGlobalContext();
6259 }
6260 }
6261
6262 // GL_EXT_protected_textures
6263
6264 // GL_EXT_pvrtc_sRGB
6265
6266 // GL_EXT_read_format_bgra
6267
6268 // GL_EXT_robustness
GL_GetGraphicsResetStatusEXT()6269 GLenum GL_APIENTRY GL_GetGraphicsResetStatusEXT()
6270 {
6271 Context *context = GetGlobalContext();
6272 EVENT(context, GLGetGraphicsResetStatusEXT, "context = %d", CID(context));
6273
6274 GLenum returnValue;
6275 if (context)
6276 {
6277 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6278 bool isCallValid = (context->skipValidation() ||
6279 ValidateGetGraphicsResetStatusEXT(
6280 context, angle::EntryPoint::GLGetGraphicsResetStatusEXT));
6281 if (isCallValid)
6282 {
6283 returnValue = context->getGraphicsResetStatus();
6284 }
6285 else
6286 {
6287 returnValue =
6288 GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>();
6289 }
6290 ANGLE_CAPTURE(GetGraphicsResetStatusEXT, isCallValid, context, returnValue);
6291 }
6292 else
6293 {
6294
6295 returnValue =
6296 GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>();
6297 }
6298 return returnValue;
6299 }
6300
GL_GetnUniformfvEXT(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)6301 void GL_APIENTRY GL_GetnUniformfvEXT(GLuint program,
6302 GLint location,
6303 GLsizei bufSize,
6304 GLfloat *params)
6305 {
6306 Context *context = GetValidGlobalContext();
6307 EVENT(context, GLGetnUniformfvEXT,
6308 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
6309 CID(context), program, location, bufSize, (uintptr_t)params);
6310
6311 if (context)
6312 {
6313 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6314 UniformLocation locationPacked = PackParam<UniformLocation>(location);
6315 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6316 bool isCallValid =
6317 (context->skipValidation() ||
6318 ValidateGetnUniformfvEXT(context, angle::EntryPoint::GLGetnUniformfvEXT, programPacked,
6319 locationPacked, bufSize, params));
6320 if (isCallValid)
6321 {
6322 context->getnUniformfv(programPacked, locationPacked, bufSize, params);
6323 }
6324 ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
6325 bufSize, params);
6326 }
6327 else
6328 {
6329 GenerateContextLostErrorOnCurrentGlobalContext();
6330 }
6331 }
6332
GL_GetnUniformivEXT(GLuint program,GLint location,GLsizei bufSize,GLint * params)6333 void GL_APIENTRY GL_GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
6334 {
6335 Context *context = GetValidGlobalContext();
6336 EVENT(context, GLGetnUniformivEXT,
6337 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
6338 CID(context), program, location, bufSize, (uintptr_t)params);
6339
6340 if (context)
6341 {
6342 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6343 UniformLocation locationPacked = PackParam<UniformLocation>(location);
6344 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6345 bool isCallValid =
6346 (context->skipValidation() ||
6347 ValidateGetnUniformivEXT(context, angle::EntryPoint::GLGetnUniformivEXT, programPacked,
6348 locationPacked, bufSize, params));
6349 if (isCallValid)
6350 {
6351 context->getnUniformiv(programPacked, locationPacked, bufSize, params);
6352 }
6353 ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
6354 bufSize, params);
6355 }
6356 else
6357 {
6358 GenerateContextLostErrorOnCurrentGlobalContext();
6359 }
6360 }
6361
GL_ReadnPixelsEXT(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)6362 void GL_APIENTRY GL_ReadnPixelsEXT(GLint x,
6363 GLint y,
6364 GLsizei width,
6365 GLsizei height,
6366 GLenum format,
6367 GLenum type,
6368 GLsizei bufSize,
6369 void *data)
6370 {
6371 Context *context = GetValidGlobalContext();
6372 EVENT(context, GLReadnPixelsEXT,
6373 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
6374 "= %d, data = 0x%016" PRIxPTR "",
6375 CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
6376 GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data);
6377
6378 if (context)
6379 {
6380 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6381 bool isCallValid = (context->skipValidation() ||
6382 ValidateReadnPixelsEXT(context, angle::EntryPoint::GLReadnPixelsEXT, x,
6383 y, width, height, format, type, bufSize, data));
6384 if (isCallValid)
6385 {
6386 context->readnPixels(x, y, width, height, format, type, bufSize, data);
6387 }
6388 ANGLE_CAPTURE(ReadnPixelsEXT, isCallValid, context, x, y, width, height, format, type,
6389 bufSize, data);
6390 }
6391 else
6392 {
6393 GenerateContextLostErrorOnCurrentGlobalContext();
6394 }
6395 }
6396
6397 // GL_EXT_sRGB
6398
6399 // GL_EXT_sRGB_write_control
6400
6401 // GL_EXT_semaphore
GL_DeleteSemaphoresEXT(GLsizei n,const GLuint * semaphores)6402 void GL_APIENTRY GL_DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
6403 {
6404 Context *context = GetValidGlobalContext();
6405 EVENT(context, GLDeleteSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "",
6406 CID(context), n, (uintptr_t)semaphores);
6407
6408 if (context)
6409 {
6410 const SemaphoreID *semaphoresPacked = PackParam<const SemaphoreID *>(semaphores);
6411 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6412 bool isCallValid =
6413 (context->skipValidation() ||
6414 ValidateDeleteSemaphoresEXT(context, angle::EntryPoint::GLDeleteSemaphoresEXT, n,
6415 semaphoresPacked));
6416 if (isCallValid)
6417 {
6418 context->deleteSemaphores(n, semaphoresPacked);
6419 }
6420 ANGLE_CAPTURE(DeleteSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
6421 }
6422 else
6423 {
6424 GenerateContextLostErrorOnCurrentGlobalContext();
6425 }
6426 }
6427
GL_GenSemaphoresEXT(GLsizei n,GLuint * semaphores)6428 void GL_APIENTRY GL_GenSemaphoresEXT(GLsizei n, GLuint *semaphores)
6429 {
6430 Context *context = GetValidGlobalContext();
6431 EVENT(context, GLGenSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "",
6432 CID(context), n, (uintptr_t)semaphores);
6433
6434 if (context)
6435 {
6436 SemaphoreID *semaphoresPacked = PackParam<SemaphoreID *>(semaphores);
6437 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6438 bool isCallValid = (context->skipValidation() ||
6439 ValidateGenSemaphoresEXT(context, angle::EntryPoint::GLGenSemaphoresEXT,
6440 n, semaphoresPacked));
6441 if (isCallValid)
6442 {
6443 context->genSemaphores(n, semaphoresPacked);
6444 }
6445 ANGLE_CAPTURE(GenSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
6446 }
6447 else
6448 {
6449 GenerateContextLostErrorOnCurrentGlobalContext();
6450 }
6451 }
6452
GL_GetSemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,GLuint64 * params)6453 void GL_APIENTRY GL_GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
6454 {
6455 Context *context = GetValidGlobalContext();
6456 EVENT(context, GLGetSemaphoreParameterui64vEXT,
6457 "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
6458 semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname), (uintptr_t)params);
6459
6460 if (context)
6461 {
6462 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
6463 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6464 bool isCallValid = (context->skipValidation() ||
6465 ValidateGetSemaphoreParameterui64vEXT(
6466 context, angle::EntryPoint::GLGetSemaphoreParameterui64vEXT,
6467 semaphorePacked, pname, params));
6468 if (isCallValid)
6469 {
6470 context->getSemaphoreParameterui64v(semaphorePacked, pname, params);
6471 }
6472 ANGLE_CAPTURE(GetSemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
6473 params);
6474 }
6475 else
6476 {
6477 GenerateContextLostErrorOnCurrentGlobalContext();
6478 }
6479 }
6480
GL_IsSemaphoreEXT(GLuint semaphore)6481 GLboolean GL_APIENTRY GL_IsSemaphoreEXT(GLuint semaphore)
6482 {
6483 Context *context = GetValidGlobalContext();
6484 EVENT(context, GLIsSemaphoreEXT, "context = %d, semaphore = %u", CID(context), semaphore);
6485
6486 GLboolean returnValue;
6487 if (context)
6488 {
6489 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
6490 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6491 bool isCallValid =
6492 (context->skipValidation() ||
6493 ValidateIsSemaphoreEXT(context, angle::EntryPoint::GLIsSemaphoreEXT, semaphorePacked));
6494 if (isCallValid)
6495 {
6496 returnValue = context->isSemaphore(semaphorePacked);
6497 }
6498 else
6499 {
6500 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>();
6501 }
6502 ANGLE_CAPTURE(IsSemaphoreEXT, isCallValid, context, semaphorePacked, returnValue);
6503 }
6504 else
6505 {
6506 GenerateContextLostErrorOnCurrentGlobalContext();
6507 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>();
6508 }
6509 return returnValue;
6510 }
6511
GL_SemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,const GLuint64 * params)6512 void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore,
6513 GLenum pname,
6514 const GLuint64 *params)
6515 {
6516 Context *context = GetValidGlobalContext();
6517 EVENT(context, GLSemaphoreParameterui64vEXT,
6518 "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
6519 semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname), (uintptr_t)params);
6520
6521 if (context)
6522 {
6523 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
6524 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6525 bool isCallValid = (context->skipValidation() ||
6526 ValidateSemaphoreParameterui64vEXT(
6527 context, angle::EntryPoint::GLSemaphoreParameterui64vEXT,
6528 semaphorePacked, pname, params));
6529 if (isCallValid)
6530 {
6531 context->semaphoreParameterui64v(semaphorePacked, pname, params);
6532 }
6533 ANGLE_CAPTURE(SemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
6534 params);
6535 }
6536 else
6537 {
6538 GenerateContextLostErrorOnCurrentGlobalContext();
6539 }
6540 }
6541
GL_SignalSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * dstLayouts)6542 void GL_APIENTRY GL_SignalSemaphoreEXT(GLuint semaphore,
6543 GLuint numBufferBarriers,
6544 const GLuint *buffers,
6545 GLuint numTextureBarriers,
6546 const GLuint *textures,
6547 const GLenum *dstLayouts)
6548 {
6549 Context *context = GetValidGlobalContext();
6550 EVENT(context, GLSignalSemaphoreEXT,
6551 "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR
6552 ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", dstLayouts = 0x%016" PRIxPTR "",
6553 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
6554 (uintptr_t)textures, (uintptr_t)dstLayouts);
6555
6556 if (context)
6557 {
6558 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
6559 const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
6560 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
6561 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6562 bool isCallValid =
6563 (context->skipValidation() ||
6564 ValidateSignalSemaphoreEXT(context, angle::EntryPoint::GLSignalSemaphoreEXT,
6565 semaphorePacked, numBufferBarriers, buffersPacked,
6566 numTextureBarriers, texturesPacked, dstLayouts));
6567 if (isCallValid)
6568 {
6569 context->signalSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
6570 numTextureBarriers, texturesPacked, dstLayouts);
6571 }
6572 ANGLE_CAPTURE(SignalSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
6573 buffersPacked, numTextureBarriers, texturesPacked, dstLayouts);
6574 }
6575 else
6576 {
6577 GenerateContextLostErrorOnCurrentGlobalContext();
6578 }
6579 }
6580
GL_WaitSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * srcLayouts)6581 void GL_APIENTRY GL_WaitSemaphoreEXT(GLuint semaphore,
6582 GLuint numBufferBarriers,
6583 const GLuint *buffers,
6584 GLuint numTextureBarriers,
6585 const GLuint *textures,
6586 const GLenum *srcLayouts)
6587 {
6588 Context *context = GetValidGlobalContext();
6589 EVENT(context, GLWaitSemaphoreEXT,
6590 "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR
6591 ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", srcLayouts = 0x%016" PRIxPTR "",
6592 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
6593 (uintptr_t)textures, (uintptr_t)srcLayouts);
6594
6595 if (context)
6596 {
6597 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
6598 const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
6599 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
6600 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6601 bool isCallValid =
6602 (context->skipValidation() ||
6603 ValidateWaitSemaphoreEXT(context, angle::EntryPoint::GLWaitSemaphoreEXT,
6604 semaphorePacked, numBufferBarriers, buffersPacked,
6605 numTextureBarriers, texturesPacked, srcLayouts));
6606 if (isCallValid)
6607 {
6608 context->waitSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
6609 numTextureBarriers, texturesPacked, srcLayouts);
6610 }
6611 ANGLE_CAPTURE(WaitSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
6612 buffersPacked, numTextureBarriers, texturesPacked, srcLayouts);
6613 }
6614 else
6615 {
6616 GenerateContextLostErrorOnCurrentGlobalContext();
6617 }
6618 }
6619
6620 // GetUnsignedBytei_vEXT is already defined.
6621
6622 // GetUnsignedBytevEXT is already defined.
6623
6624 // GL_EXT_semaphore_fd
GL_ImportSemaphoreFdEXT(GLuint semaphore,GLenum handleType,GLint fd)6625 void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
6626 {
6627 Context *context = GetValidGlobalContext();
6628 EVENT(context, GLImportSemaphoreFdEXT, "context = %d, semaphore = %u, handleType = %s, fd = %d",
6629 CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd);
6630
6631 if (context)
6632 {
6633 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
6634 HandleType handleTypePacked = PackParam<HandleType>(handleType);
6635 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6636 bool isCallValid =
6637 (context->skipValidation() ||
6638 ValidateImportSemaphoreFdEXT(context, angle::EntryPoint::GLImportSemaphoreFdEXT,
6639 semaphorePacked, handleTypePacked, fd));
6640 if (isCallValid)
6641 {
6642 context->importSemaphoreFd(semaphorePacked, handleTypePacked, fd);
6643 }
6644 ANGLE_CAPTURE(ImportSemaphoreFdEXT, isCallValid, context, semaphorePacked, handleTypePacked,
6645 fd);
6646 }
6647 else
6648 {
6649 GenerateContextLostErrorOnCurrentGlobalContext();
6650 }
6651 }
6652
6653 // GL_EXT_separate_shader_objects
GL_ActiveShaderProgramEXT(GLuint pipeline,GLuint program)6654 void GL_APIENTRY GL_ActiveShaderProgramEXT(GLuint pipeline, GLuint program)
6655 {
6656 Context *context = GetValidGlobalContext();
6657 EVENT(context, GLActiveShaderProgramEXT, "context = %d, pipeline = %u, program = %u",
6658 CID(context), pipeline, program);
6659
6660 if (context)
6661 {
6662 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6663 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6664 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6665 bool isCallValid =
6666 (context->skipValidation() ||
6667 ValidateActiveShaderProgramEXT(context, angle::EntryPoint::GLActiveShaderProgramEXT,
6668 pipelinePacked, programPacked));
6669 if (isCallValid)
6670 {
6671 context->activeShaderProgram(pipelinePacked, programPacked);
6672 }
6673 ANGLE_CAPTURE(ActiveShaderProgramEXT, isCallValid, context, pipelinePacked, programPacked);
6674 }
6675 else
6676 {
6677 GenerateContextLostErrorOnCurrentGlobalContext();
6678 }
6679 }
6680
GL_BindProgramPipelineEXT(GLuint pipeline)6681 void GL_APIENTRY GL_BindProgramPipelineEXT(GLuint pipeline)
6682 {
6683 Context *context = GetValidGlobalContext();
6684 EVENT(context, GLBindProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline);
6685
6686 if (context)
6687 {
6688 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6689 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6690 bool isCallValid =
6691 (context->skipValidation() ||
6692 ValidateBindProgramPipelineEXT(context, angle::EntryPoint::GLBindProgramPipelineEXT,
6693 pipelinePacked));
6694 if (isCallValid)
6695 {
6696 context->bindProgramPipeline(pipelinePacked);
6697 }
6698 ANGLE_CAPTURE(BindProgramPipelineEXT, isCallValid, context, pipelinePacked);
6699 }
6700 else
6701 {
6702 GenerateContextLostErrorOnCurrentGlobalContext();
6703 }
6704 }
6705
GL_CreateShaderProgramvEXT(GLenum type,GLsizei count,const GLchar ** strings)6706 GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings)
6707 {
6708 Context *context = GetValidGlobalContext();
6709 EVENT(context, GLCreateShaderProgramvEXT,
6710 "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context),
6711 GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings);
6712
6713 GLuint returnValue;
6714 if (context)
6715 {
6716 ShaderType typePacked = PackParam<ShaderType>(type);
6717 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6718 bool isCallValid =
6719 (context->skipValidation() ||
6720 ValidateCreateShaderProgramvEXT(context, angle::EntryPoint::GLCreateShaderProgramvEXT,
6721 typePacked, count, strings));
6722 if (isCallValid)
6723 {
6724 returnValue = context->createShaderProgramv(typePacked, count, strings);
6725 }
6726 else
6727 {
6728 returnValue =
6729 GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>();
6730 }
6731 ANGLE_CAPTURE(CreateShaderProgramvEXT, isCallValid, context, typePacked, count, strings,
6732 returnValue);
6733 }
6734 else
6735 {
6736 GenerateContextLostErrorOnCurrentGlobalContext();
6737 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>();
6738 }
6739 return returnValue;
6740 }
6741
GL_DeleteProgramPipelinesEXT(GLsizei n,const GLuint * pipelines)6742 void GL_APIENTRY GL_DeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
6743 {
6744 Context *context = GetValidGlobalContext();
6745 EVENT(context, GLDeleteProgramPipelinesEXT,
6746 "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", CID(context), n,
6747 (uintptr_t)pipelines);
6748
6749 if (context)
6750 {
6751 const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines);
6752 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6753 bool isCallValid =
6754 (context->skipValidation() ||
6755 ValidateDeleteProgramPipelinesEXT(
6756 context, angle::EntryPoint::GLDeleteProgramPipelinesEXT, n, pipelinesPacked));
6757 if (isCallValid)
6758 {
6759 context->deleteProgramPipelines(n, pipelinesPacked);
6760 }
6761 ANGLE_CAPTURE(DeleteProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked);
6762 }
6763 else
6764 {
6765 GenerateContextLostErrorOnCurrentGlobalContext();
6766 }
6767 }
6768
GL_GenProgramPipelinesEXT(GLsizei n,GLuint * pipelines)6769 void GL_APIENTRY GL_GenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
6770 {
6771 Context *context = GetValidGlobalContext();
6772 EVENT(context, GLGenProgramPipelinesEXT, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "",
6773 CID(context), n, (uintptr_t)pipelines);
6774
6775 if (context)
6776 {
6777 ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines);
6778 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6779 bool isCallValid =
6780 (context->skipValidation() ||
6781 ValidateGenProgramPipelinesEXT(context, angle::EntryPoint::GLGenProgramPipelinesEXT, n,
6782 pipelinesPacked));
6783 if (isCallValid)
6784 {
6785 context->genProgramPipelines(n, pipelinesPacked);
6786 }
6787 ANGLE_CAPTURE(GenProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked);
6788 }
6789 else
6790 {
6791 GenerateContextLostErrorOnCurrentGlobalContext();
6792 }
6793 }
6794
GL_GetProgramPipelineInfoLogEXT(GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)6795 void GL_APIENTRY GL_GetProgramPipelineInfoLogEXT(GLuint pipeline,
6796 GLsizei bufSize,
6797 GLsizei *length,
6798 GLchar *infoLog)
6799 {
6800 Context *context = GetValidGlobalContext();
6801 EVENT(context, GLGetProgramPipelineInfoLogEXT,
6802 "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR
6803 ", infoLog = 0x%016" PRIxPTR "",
6804 CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
6805
6806 if (context)
6807 {
6808 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6809 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6810 bool isCallValid = (context->skipValidation() ||
6811 ValidateGetProgramPipelineInfoLogEXT(
6812 context, angle::EntryPoint::GLGetProgramPipelineInfoLogEXT,
6813 pipelinePacked, bufSize, length, infoLog));
6814 if (isCallValid)
6815 {
6816 context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog);
6817 }
6818 ANGLE_CAPTURE(GetProgramPipelineInfoLogEXT, isCallValid, context, pipelinePacked, bufSize,
6819 length, infoLog);
6820 }
6821 else
6822 {
6823 GenerateContextLostErrorOnCurrentGlobalContext();
6824 }
6825 }
6826
GL_GetProgramPipelineivEXT(GLuint pipeline,GLenum pname,GLint * params)6827 void GL_APIENTRY GL_GetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params)
6828 {
6829 Context *context = GetValidGlobalContext();
6830 EVENT(context, GLGetProgramPipelineivEXT,
6831 "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
6832 pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname), (uintptr_t)params);
6833
6834 if (context)
6835 {
6836 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6837 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6838 bool isCallValid =
6839 (context->skipValidation() ||
6840 ValidateGetProgramPipelineivEXT(context, angle::EntryPoint::GLGetProgramPipelineivEXT,
6841 pipelinePacked, pname, params));
6842 if (isCallValid)
6843 {
6844 context->getProgramPipelineiv(pipelinePacked, pname, params);
6845 }
6846 ANGLE_CAPTURE(GetProgramPipelineivEXT, isCallValid, context, pipelinePacked, pname, params);
6847 }
6848 else
6849 {
6850 GenerateContextLostErrorOnCurrentGlobalContext();
6851 }
6852 }
6853
GL_IsProgramPipelineEXT(GLuint pipeline)6854 GLboolean GL_APIENTRY GL_IsProgramPipelineEXT(GLuint pipeline)
6855 {
6856 Context *context = GetValidGlobalContext();
6857 EVENT(context, GLIsProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline);
6858
6859 GLboolean returnValue;
6860 if (context)
6861 {
6862 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
6863 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6864 bool isCallValid =
6865 (context->skipValidation() ||
6866 ValidateIsProgramPipelineEXT(context, angle::EntryPoint::GLIsProgramPipelineEXT,
6867 pipelinePacked));
6868 if (isCallValid)
6869 {
6870 returnValue = context->isProgramPipeline(pipelinePacked);
6871 }
6872 else
6873 {
6874 returnValue =
6875 GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>();
6876 }
6877 ANGLE_CAPTURE(IsProgramPipelineEXT, isCallValid, context, pipelinePacked, returnValue);
6878 }
6879 else
6880 {
6881 GenerateContextLostErrorOnCurrentGlobalContext();
6882 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>();
6883 }
6884 return returnValue;
6885 }
6886
GL_ProgramParameteriEXT(GLuint program,GLenum pname,GLint value)6887 void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
6888 {
6889 Context *context = GetValidGlobalContext();
6890 EVENT(context, GLProgramParameteriEXT, "context = %d, program = %u, pname = %s, value = %d",
6891 CID(context), program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value);
6892
6893 if (context)
6894 {
6895 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6896 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6897 bool isCallValid =
6898 (context->skipValidation() ||
6899 ValidateProgramParameteriEXT(context, angle::EntryPoint::GLProgramParameteriEXT,
6900 programPacked, pname, value));
6901 if (isCallValid)
6902 {
6903 context->programParameteri(programPacked, pname, value);
6904 }
6905 ANGLE_CAPTURE(ProgramParameteriEXT, isCallValid, context, programPacked, pname, value);
6906 }
6907 else
6908 {
6909 GenerateContextLostErrorOnCurrentGlobalContext();
6910 }
6911 }
6912
GL_ProgramUniform1fEXT(GLuint program,GLint location,GLfloat v0)6913 void GL_APIENTRY GL_ProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)
6914 {
6915 Context *context = GetValidGlobalContext();
6916 EVENT(context, GLProgramUniform1fEXT, "context = %d, program = %u, location = %d, v0 = %f",
6917 CID(context), program, location, v0);
6918
6919 if (context)
6920 {
6921 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6922 UniformLocation locationPacked = PackParam<UniformLocation>(location);
6923 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6924 bool isCallValid =
6925 (context->skipValidation() ||
6926 ValidateProgramUniform1fEXT(context, angle::EntryPoint::GLProgramUniform1fEXT,
6927 programPacked, locationPacked, v0));
6928 if (isCallValid)
6929 {
6930 context->programUniform1f(programPacked, locationPacked, v0);
6931 }
6932 ANGLE_CAPTURE(ProgramUniform1fEXT, isCallValid, context, programPacked, locationPacked, v0);
6933 }
6934 else
6935 {
6936 GenerateContextLostErrorOnCurrentGlobalContext();
6937 }
6938 }
6939
GL_ProgramUniform1fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)6940 void GL_APIENTRY GL_ProgramUniform1fvEXT(GLuint program,
6941 GLint location,
6942 GLsizei count,
6943 const GLfloat *value)
6944 {
6945 Context *context = GetValidGlobalContext();
6946 EVENT(context, GLProgramUniform1fvEXT,
6947 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
6948 CID(context), program, location, count, (uintptr_t)value);
6949
6950 if (context)
6951 {
6952 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6953 UniformLocation locationPacked = PackParam<UniformLocation>(location);
6954 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6955 bool isCallValid =
6956 (context->skipValidation() ||
6957 ValidateProgramUniform1fvEXT(context, angle::EntryPoint::GLProgramUniform1fvEXT,
6958 programPacked, locationPacked, count, value));
6959 if (isCallValid)
6960 {
6961 context->programUniform1fv(programPacked, locationPacked, count, value);
6962 }
6963 ANGLE_CAPTURE(ProgramUniform1fvEXT, isCallValid, context, programPacked, locationPacked,
6964 count, value);
6965 }
6966 else
6967 {
6968 GenerateContextLostErrorOnCurrentGlobalContext();
6969 }
6970 }
6971
GL_ProgramUniform1iEXT(GLuint program,GLint location,GLint v0)6972 void GL_APIENTRY GL_ProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
6973 {
6974 Context *context = GetValidGlobalContext();
6975 EVENT(context, GLProgramUniform1iEXT, "context = %d, program = %u, location = %d, v0 = %d",
6976 CID(context), program, location, v0);
6977
6978 if (context)
6979 {
6980 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
6981 UniformLocation locationPacked = PackParam<UniformLocation>(location);
6982 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
6983 bool isCallValid =
6984 (context->skipValidation() ||
6985 ValidateProgramUniform1iEXT(context, angle::EntryPoint::GLProgramUniform1iEXT,
6986 programPacked, locationPacked, v0));
6987 if (isCallValid)
6988 {
6989 context->programUniform1i(programPacked, locationPacked, v0);
6990 }
6991 ANGLE_CAPTURE(ProgramUniform1iEXT, isCallValid, context, programPacked, locationPacked, v0);
6992 }
6993 else
6994 {
6995 GenerateContextLostErrorOnCurrentGlobalContext();
6996 }
6997 }
6998
GL_ProgramUniform1ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)6999 void GL_APIENTRY GL_ProgramUniform1ivEXT(GLuint program,
7000 GLint location,
7001 GLsizei count,
7002 const GLint *value)
7003 {
7004 Context *context = GetValidGlobalContext();
7005 EVENT(context, GLProgramUniform1ivEXT,
7006 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7007 CID(context), program, location, count, (uintptr_t)value);
7008
7009 if (context)
7010 {
7011 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7012 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7013 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7014 bool isCallValid =
7015 (context->skipValidation() ||
7016 ValidateProgramUniform1ivEXT(context, angle::EntryPoint::GLProgramUniform1ivEXT,
7017 programPacked, locationPacked, count, value));
7018 if (isCallValid)
7019 {
7020 context->programUniform1iv(programPacked, locationPacked, count, value);
7021 }
7022 ANGLE_CAPTURE(ProgramUniform1ivEXT, isCallValid, context, programPacked, locationPacked,
7023 count, value);
7024 }
7025 else
7026 {
7027 GenerateContextLostErrorOnCurrentGlobalContext();
7028 }
7029 }
7030
GL_ProgramUniform1uiEXT(GLuint program,GLint location,GLuint v0)7031 void GL_APIENTRY GL_ProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
7032 {
7033 Context *context = GetValidGlobalContext();
7034 EVENT(context, GLProgramUniform1uiEXT, "context = %d, program = %u, location = %d, v0 = %u",
7035 CID(context), program, location, v0);
7036
7037 if (context)
7038 {
7039 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7040 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7041 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7042 bool isCallValid =
7043 (context->skipValidation() ||
7044 ValidateProgramUniform1uiEXT(context, angle::EntryPoint::GLProgramUniform1uiEXT,
7045 programPacked, locationPacked, v0));
7046 if (isCallValid)
7047 {
7048 context->programUniform1ui(programPacked, locationPacked, v0);
7049 }
7050 ANGLE_CAPTURE(ProgramUniform1uiEXT, isCallValid, context, programPacked, locationPacked,
7051 v0);
7052 }
7053 else
7054 {
7055 GenerateContextLostErrorOnCurrentGlobalContext();
7056 }
7057 }
7058
GL_ProgramUniform1uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)7059 void GL_APIENTRY GL_ProgramUniform1uivEXT(GLuint program,
7060 GLint location,
7061 GLsizei count,
7062 const GLuint *value)
7063 {
7064 Context *context = GetValidGlobalContext();
7065 EVENT(context, GLProgramUniform1uivEXT,
7066 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7067 CID(context), program, location, count, (uintptr_t)value);
7068
7069 if (context)
7070 {
7071 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7072 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7073 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7074 bool isCallValid =
7075 (context->skipValidation() ||
7076 ValidateProgramUniform1uivEXT(context, angle::EntryPoint::GLProgramUniform1uivEXT,
7077 programPacked, locationPacked, count, value));
7078 if (isCallValid)
7079 {
7080 context->programUniform1uiv(programPacked, locationPacked, count, value);
7081 }
7082 ANGLE_CAPTURE(ProgramUniform1uivEXT, isCallValid, context, programPacked, locationPacked,
7083 count, value);
7084 }
7085 else
7086 {
7087 GenerateContextLostErrorOnCurrentGlobalContext();
7088 }
7089 }
7090
GL_ProgramUniform2fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1)7091 void GL_APIENTRY GL_ProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)
7092 {
7093 Context *context = GetValidGlobalContext();
7094 EVENT(context, GLProgramUniform2fEXT,
7095 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program,
7096 location, v0, v1);
7097
7098 if (context)
7099 {
7100 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7101 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7102 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7103 bool isCallValid =
7104 (context->skipValidation() ||
7105 ValidateProgramUniform2fEXT(context, angle::EntryPoint::GLProgramUniform2fEXT,
7106 programPacked, locationPacked, v0, v1));
7107 if (isCallValid)
7108 {
7109 context->programUniform2f(programPacked, locationPacked, v0, v1);
7110 }
7111 ANGLE_CAPTURE(ProgramUniform2fEXT, isCallValid, context, programPacked, locationPacked, v0,
7112 v1);
7113 }
7114 else
7115 {
7116 GenerateContextLostErrorOnCurrentGlobalContext();
7117 }
7118 }
7119
GL_ProgramUniform2fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)7120 void GL_APIENTRY GL_ProgramUniform2fvEXT(GLuint program,
7121 GLint location,
7122 GLsizei count,
7123 const GLfloat *value)
7124 {
7125 Context *context = GetValidGlobalContext();
7126 EVENT(context, GLProgramUniform2fvEXT,
7127 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7128 CID(context), program, location, count, (uintptr_t)value);
7129
7130 if (context)
7131 {
7132 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7133 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7134 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7135 bool isCallValid =
7136 (context->skipValidation() ||
7137 ValidateProgramUniform2fvEXT(context, angle::EntryPoint::GLProgramUniform2fvEXT,
7138 programPacked, locationPacked, count, value));
7139 if (isCallValid)
7140 {
7141 context->programUniform2fv(programPacked, locationPacked, count, value);
7142 }
7143 ANGLE_CAPTURE(ProgramUniform2fvEXT, isCallValid, context, programPacked, locationPacked,
7144 count, value);
7145 }
7146 else
7147 {
7148 GenerateContextLostErrorOnCurrentGlobalContext();
7149 }
7150 }
7151
GL_ProgramUniform2iEXT(GLuint program,GLint location,GLint v0,GLint v1)7152 void GL_APIENTRY GL_ProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)
7153 {
7154 Context *context = GetValidGlobalContext();
7155 EVENT(context, GLProgramUniform2iEXT,
7156 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program,
7157 location, v0, v1);
7158
7159 if (context)
7160 {
7161 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7162 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7163 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7164 bool isCallValid =
7165 (context->skipValidation() ||
7166 ValidateProgramUniform2iEXT(context, angle::EntryPoint::GLProgramUniform2iEXT,
7167 programPacked, locationPacked, v0, v1));
7168 if (isCallValid)
7169 {
7170 context->programUniform2i(programPacked, locationPacked, v0, v1);
7171 }
7172 ANGLE_CAPTURE(ProgramUniform2iEXT, isCallValid, context, programPacked, locationPacked, v0,
7173 v1);
7174 }
7175 else
7176 {
7177 GenerateContextLostErrorOnCurrentGlobalContext();
7178 }
7179 }
7180
GL_ProgramUniform2ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)7181 void GL_APIENTRY GL_ProgramUniform2ivEXT(GLuint program,
7182 GLint location,
7183 GLsizei count,
7184 const GLint *value)
7185 {
7186 Context *context = GetValidGlobalContext();
7187 EVENT(context, GLProgramUniform2ivEXT,
7188 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7189 CID(context), program, location, count, (uintptr_t)value);
7190
7191 if (context)
7192 {
7193 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7194 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7195 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7196 bool isCallValid =
7197 (context->skipValidation() ||
7198 ValidateProgramUniform2ivEXT(context, angle::EntryPoint::GLProgramUniform2ivEXT,
7199 programPacked, locationPacked, count, value));
7200 if (isCallValid)
7201 {
7202 context->programUniform2iv(programPacked, locationPacked, count, value);
7203 }
7204 ANGLE_CAPTURE(ProgramUniform2ivEXT, isCallValid, context, programPacked, locationPacked,
7205 count, value);
7206 }
7207 else
7208 {
7209 GenerateContextLostErrorOnCurrentGlobalContext();
7210 }
7211 }
7212
GL_ProgramUniform2uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1)7213 void GL_APIENTRY GL_ProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1)
7214 {
7215 Context *context = GetValidGlobalContext();
7216 EVENT(context, GLProgramUniform2uiEXT,
7217 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program,
7218 location, v0, v1);
7219
7220 if (context)
7221 {
7222 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7223 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7224 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7225 bool isCallValid =
7226 (context->skipValidation() ||
7227 ValidateProgramUniform2uiEXT(context, angle::EntryPoint::GLProgramUniform2uiEXT,
7228 programPacked, locationPacked, v0, v1));
7229 if (isCallValid)
7230 {
7231 context->programUniform2ui(programPacked, locationPacked, v0, v1);
7232 }
7233 ANGLE_CAPTURE(ProgramUniform2uiEXT, isCallValid, context, programPacked, locationPacked, v0,
7234 v1);
7235 }
7236 else
7237 {
7238 GenerateContextLostErrorOnCurrentGlobalContext();
7239 }
7240 }
7241
GL_ProgramUniform2uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)7242 void GL_APIENTRY GL_ProgramUniform2uivEXT(GLuint program,
7243 GLint location,
7244 GLsizei count,
7245 const GLuint *value)
7246 {
7247 Context *context = GetValidGlobalContext();
7248 EVENT(context, GLProgramUniform2uivEXT,
7249 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7250 CID(context), program, location, count, (uintptr_t)value);
7251
7252 if (context)
7253 {
7254 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7255 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7256 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7257 bool isCallValid =
7258 (context->skipValidation() ||
7259 ValidateProgramUniform2uivEXT(context, angle::EntryPoint::GLProgramUniform2uivEXT,
7260 programPacked, locationPacked, count, value));
7261 if (isCallValid)
7262 {
7263 context->programUniform2uiv(programPacked, locationPacked, count, value);
7264 }
7265 ANGLE_CAPTURE(ProgramUniform2uivEXT, isCallValid, context, programPacked, locationPacked,
7266 count, value);
7267 }
7268 else
7269 {
7270 GenerateContextLostErrorOnCurrentGlobalContext();
7271 }
7272 }
7273
7274 void GL_APIENTRY
GL_ProgramUniform3fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)7275 GL_ProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
7276 {
7277 Context *context = GetValidGlobalContext();
7278 EVENT(context, GLProgramUniform3fEXT,
7279 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context),
7280 program, location, v0, v1, v2);
7281
7282 if (context)
7283 {
7284 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7285 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7286 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7287 bool isCallValid =
7288 (context->skipValidation() ||
7289 ValidateProgramUniform3fEXT(context, angle::EntryPoint::GLProgramUniform3fEXT,
7290 programPacked, locationPacked, v0, v1, v2));
7291 if (isCallValid)
7292 {
7293 context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
7294 }
7295 ANGLE_CAPTURE(ProgramUniform3fEXT, isCallValid, context, programPacked, locationPacked, v0,
7296 v1, v2);
7297 }
7298 else
7299 {
7300 GenerateContextLostErrorOnCurrentGlobalContext();
7301 }
7302 }
7303
GL_ProgramUniform3fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)7304 void GL_APIENTRY GL_ProgramUniform3fvEXT(GLuint program,
7305 GLint location,
7306 GLsizei count,
7307 const GLfloat *value)
7308 {
7309 Context *context = GetValidGlobalContext();
7310 EVENT(context, GLProgramUniform3fvEXT,
7311 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7312 CID(context), program, location, count, (uintptr_t)value);
7313
7314 if (context)
7315 {
7316 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7317 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7318 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7319 bool isCallValid =
7320 (context->skipValidation() ||
7321 ValidateProgramUniform3fvEXT(context, angle::EntryPoint::GLProgramUniform3fvEXT,
7322 programPacked, locationPacked, count, value));
7323 if (isCallValid)
7324 {
7325 context->programUniform3fv(programPacked, locationPacked, count, value);
7326 }
7327 ANGLE_CAPTURE(ProgramUniform3fvEXT, isCallValid, context, programPacked, locationPacked,
7328 count, value);
7329 }
7330 else
7331 {
7332 GenerateContextLostErrorOnCurrentGlobalContext();
7333 }
7334 }
7335
7336 void GL_APIENTRY
GL_ProgramUniform3iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)7337 GL_ProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
7338 {
7339 Context *context = GetValidGlobalContext();
7340 EVENT(context, GLProgramUniform3iEXT,
7341 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context),
7342 program, location, v0, v1, v2);
7343
7344 if (context)
7345 {
7346 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7347 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7348 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7349 bool isCallValid =
7350 (context->skipValidation() ||
7351 ValidateProgramUniform3iEXT(context, angle::EntryPoint::GLProgramUniform3iEXT,
7352 programPacked, locationPacked, v0, v1, v2));
7353 if (isCallValid)
7354 {
7355 context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
7356 }
7357 ANGLE_CAPTURE(ProgramUniform3iEXT, isCallValid, context, programPacked, locationPacked, v0,
7358 v1, v2);
7359 }
7360 else
7361 {
7362 GenerateContextLostErrorOnCurrentGlobalContext();
7363 }
7364 }
7365
GL_ProgramUniform3ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)7366 void GL_APIENTRY GL_ProgramUniform3ivEXT(GLuint program,
7367 GLint location,
7368 GLsizei count,
7369 const GLint *value)
7370 {
7371 Context *context = GetValidGlobalContext();
7372 EVENT(context, GLProgramUniform3ivEXT,
7373 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7374 CID(context), program, location, count, (uintptr_t)value);
7375
7376 if (context)
7377 {
7378 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7379 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7380 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7381 bool isCallValid =
7382 (context->skipValidation() ||
7383 ValidateProgramUniform3ivEXT(context, angle::EntryPoint::GLProgramUniform3ivEXT,
7384 programPacked, locationPacked, count, value));
7385 if (isCallValid)
7386 {
7387 context->programUniform3iv(programPacked, locationPacked, count, value);
7388 }
7389 ANGLE_CAPTURE(ProgramUniform3ivEXT, isCallValid, context, programPacked, locationPacked,
7390 count, value);
7391 }
7392 else
7393 {
7394 GenerateContextLostErrorOnCurrentGlobalContext();
7395 }
7396 }
7397
7398 void GL_APIENTRY
GL_ProgramUniform3uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)7399 GL_ProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
7400 {
7401 Context *context = GetValidGlobalContext();
7402 EVENT(context, GLProgramUniform3uiEXT,
7403 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context),
7404 program, location, v0, v1, v2);
7405
7406 if (context)
7407 {
7408 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7409 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7410 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7411 bool isCallValid =
7412 (context->skipValidation() ||
7413 ValidateProgramUniform3uiEXT(context, angle::EntryPoint::GLProgramUniform3uiEXT,
7414 programPacked, locationPacked, v0, v1, v2));
7415 if (isCallValid)
7416 {
7417 context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
7418 }
7419 ANGLE_CAPTURE(ProgramUniform3uiEXT, isCallValid, context, programPacked, locationPacked, v0,
7420 v1, v2);
7421 }
7422 else
7423 {
7424 GenerateContextLostErrorOnCurrentGlobalContext();
7425 }
7426 }
7427
GL_ProgramUniform3uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)7428 void GL_APIENTRY GL_ProgramUniform3uivEXT(GLuint program,
7429 GLint location,
7430 GLsizei count,
7431 const GLuint *value)
7432 {
7433 Context *context = GetValidGlobalContext();
7434 EVENT(context, GLProgramUniform3uivEXT,
7435 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7436 CID(context), program, location, count, (uintptr_t)value);
7437
7438 if (context)
7439 {
7440 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7441 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7442 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7443 bool isCallValid =
7444 (context->skipValidation() ||
7445 ValidateProgramUniform3uivEXT(context, angle::EntryPoint::GLProgramUniform3uivEXT,
7446 programPacked, locationPacked, count, value));
7447 if (isCallValid)
7448 {
7449 context->programUniform3uiv(programPacked, locationPacked, count, value);
7450 }
7451 ANGLE_CAPTURE(ProgramUniform3uivEXT, isCallValid, context, programPacked, locationPacked,
7452 count, value);
7453 }
7454 else
7455 {
7456 GenerateContextLostErrorOnCurrentGlobalContext();
7457 }
7458 }
7459
GL_ProgramUniform4fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)7460 void GL_APIENTRY GL_ProgramUniform4fEXT(GLuint program,
7461 GLint location,
7462 GLfloat v0,
7463 GLfloat v1,
7464 GLfloat v2,
7465 GLfloat v3)
7466 {
7467 Context *context = GetValidGlobalContext();
7468 EVENT(context, GLProgramUniform4fEXT,
7469 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
7470 CID(context), program, location, v0, v1, v2, v3);
7471
7472 if (context)
7473 {
7474 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7475 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7476 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7477 bool isCallValid =
7478 (context->skipValidation() ||
7479 ValidateProgramUniform4fEXT(context, angle::EntryPoint::GLProgramUniform4fEXT,
7480 programPacked, locationPacked, v0, v1, v2, v3));
7481 if (isCallValid)
7482 {
7483 context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
7484 }
7485 ANGLE_CAPTURE(ProgramUniform4fEXT, isCallValid, context, programPacked, locationPacked, v0,
7486 v1, v2, v3);
7487 }
7488 else
7489 {
7490 GenerateContextLostErrorOnCurrentGlobalContext();
7491 }
7492 }
7493
GL_ProgramUniform4fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)7494 void GL_APIENTRY GL_ProgramUniform4fvEXT(GLuint program,
7495 GLint location,
7496 GLsizei count,
7497 const GLfloat *value)
7498 {
7499 Context *context = GetValidGlobalContext();
7500 EVENT(context, GLProgramUniform4fvEXT,
7501 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7502 CID(context), program, location, count, (uintptr_t)value);
7503
7504 if (context)
7505 {
7506 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7507 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7508 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7509 bool isCallValid =
7510 (context->skipValidation() ||
7511 ValidateProgramUniform4fvEXT(context, angle::EntryPoint::GLProgramUniform4fvEXT,
7512 programPacked, locationPacked, count, value));
7513 if (isCallValid)
7514 {
7515 context->programUniform4fv(programPacked, locationPacked, count, value);
7516 }
7517 ANGLE_CAPTURE(ProgramUniform4fvEXT, isCallValid, context, programPacked, locationPacked,
7518 count, value);
7519 }
7520 else
7521 {
7522 GenerateContextLostErrorOnCurrentGlobalContext();
7523 }
7524 }
7525
7526 void GL_APIENTRY
GL_ProgramUniform4iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)7527 GL_ProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
7528 {
7529 Context *context = GetValidGlobalContext();
7530 EVENT(context, GLProgramUniform4iEXT,
7531 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
7532 CID(context), program, location, v0, v1, v2, v3);
7533
7534 if (context)
7535 {
7536 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7537 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7538 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7539 bool isCallValid =
7540 (context->skipValidation() ||
7541 ValidateProgramUniform4iEXT(context, angle::EntryPoint::GLProgramUniform4iEXT,
7542 programPacked, locationPacked, v0, v1, v2, v3));
7543 if (isCallValid)
7544 {
7545 context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
7546 }
7547 ANGLE_CAPTURE(ProgramUniform4iEXT, isCallValid, context, programPacked, locationPacked, v0,
7548 v1, v2, v3);
7549 }
7550 else
7551 {
7552 GenerateContextLostErrorOnCurrentGlobalContext();
7553 }
7554 }
7555
GL_ProgramUniform4ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)7556 void GL_APIENTRY GL_ProgramUniform4ivEXT(GLuint program,
7557 GLint location,
7558 GLsizei count,
7559 const GLint *value)
7560 {
7561 Context *context = GetValidGlobalContext();
7562 EVENT(context, GLProgramUniform4ivEXT,
7563 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7564 CID(context), program, location, count, (uintptr_t)value);
7565
7566 if (context)
7567 {
7568 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7569 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7570 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7571 bool isCallValid =
7572 (context->skipValidation() ||
7573 ValidateProgramUniform4ivEXT(context, angle::EntryPoint::GLProgramUniform4ivEXT,
7574 programPacked, locationPacked, count, value));
7575 if (isCallValid)
7576 {
7577 context->programUniform4iv(programPacked, locationPacked, count, value);
7578 }
7579 ANGLE_CAPTURE(ProgramUniform4ivEXT, isCallValid, context, programPacked, locationPacked,
7580 count, value);
7581 }
7582 else
7583 {
7584 GenerateContextLostErrorOnCurrentGlobalContext();
7585 }
7586 }
7587
7588 void GL_APIENTRY
GL_ProgramUniform4uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)7589 GL_ProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
7590 {
7591 Context *context = GetValidGlobalContext();
7592 EVENT(context, GLProgramUniform4uiEXT,
7593 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u",
7594 CID(context), program, location, v0, v1, v2, v3);
7595
7596 if (context)
7597 {
7598 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7599 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7600 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7601 bool isCallValid =
7602 (context->skipValidation() ||
7603 ValidateProgramUniform4uiEXT(context, angle::EntryPoint::GLProgramUniform4uiEXT,
7604 programPacked, locationPacked, v0, v1, v2, v3));
7605 if (isCallValid)
7606 {
7607 context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
7608 }
7609 ANGLE_CAPTURE(ProgramUniform4uiEXT, isCallValid, context, programPacked, locationPacked, v0,
7610 v1, v2, v3);
7611 }
7612 else
7613 {
7614 GenerateContextLostErrorOnCurrentGlobalContext();
7615 }
7616 }
7617
GL_ProgramUniform4uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)7618 void GL_APIENTRY GL_ProgramUniform4uivEXT(GLuint program,
7619 GLint location,
7620 GLsizei count,
7621 const GLuint *value)
7622 {
7623 Context *context = GetValidGlobalContext();
7624 EVENT(context, GLProgramUniform4uivEXT,
7625 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
7626 CID(context), program, location, count, (uintptr_t)value);
7627
7628 if (context)
7629 {
7630 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7631 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7632 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7633 bool isCallValid =
7634 (context->skipValidation() ||
7635 ValidateProgramUniform4uivEXT(context, angle::EntryPoint::GLProgramUniform4uivEXT,
7636 programPacked, locationPacked, count, value));
7637 if (isCallValid)
7638 {
7639 context->programUniform4uiv(programPacked, locationPacked, count, value);
7640 }
7641 ANGLE_CAPTURE(ProgramUniform4uivEXT, isCallValid, context, programPacked, locationPacked,
7642 count, value);
7643 }
7644 else
7645 {
7646 GenerateContextLostErrorOnCurrentGlobalContext();
7647 }
7648 }
7649
GL_ProgramUniformMatrix2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7650 void GL_APIENTRY GL_ProgramUniformMatrix2fvEXT(GLuint program,
7651 GLint location,
7652 GLsizei count,
7653 GLboolean transpose,
7654 const GLfloat *value)
7655 {
7656 Context *context = GetValidGlobalContext();
7657 EVENT(context, GLProgramUniformMatrix2fvEXT,
7658 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7659 "0x%016" PRIxPTR "",
7660 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7661
7662 if (context)
7663 {
7664 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7665 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7666 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7667 bool isCallValid = (context->skipValidation() ||
7668 ValidateProgramUniformMatrix2fvEXT(
7669 context, angle::EntryPoint::GLProgramUniformMatrix2fvEXT,
7670 programPacked, locationPacked, count, transpose, value));
7671 if (isCallValid)
7672 {
7673 context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
7674 value);
7675 }
7676 ANGLE_CAPTURE(ProgramUniformMatrix2fvEXT, isCallValid, context, programPacked,
7677 locationPacked, count, transpose, value);
7678 }
7679 else
7680 {
7681 GenerateContextLostErrorOnCurrentGlobalContext();
7682 }
7683 }
7684
GL_ProgramUniformMatrix2x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7685 void GL_APIENTRY GL_ProgramUniformMatrix2x3fvEXT(GLuint program,
7686 GLint location,
7687 GLsizei count,
7688 GLboolean transpose,
7689 const GLfloat *value)
7690 {
7691 Context *context = GetValidGlobalContext();
7692 EVENT(context, GLProgramUniformMatrix2x3fvEXT,
7693 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7694 "0x%016" PRIxPTR "",
7695 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7696
7697 if (context)
7698 {
7699 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7700 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7701 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7702 bool isCallValid = (context->skipValidation() ||
7703 ValidateProgramUniformMatrix2x3fvEXT(
7704 context, angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT,
7705 programPacked, locationPacked, count, transpose, value));
7706 if (isCallValid)
7707 {
7708 context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
7709 value);
7710 }
7711 ANGLE_CAPTURE(ProgramUniformMatrix2x3fvEXT, isCallValid, context, programPacked,
7712 locationPacked, count, transpose, value);
7713 }
7714 else
7715 {
7716 GenerateContextLostErrorOnCurrentGlobalContext();
7717 }
7718 }
7719
GL_ProgramUniformMatrix2x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7720 void GL_APIENTRY GL_ProgramUniformMatrix2x4fvEXT(GLuint program,
7721 GLint location,
7722 GLsizei count,
7723 GLboolean transpose,
7724 const GLfloat *value)
7725 {
7726 Context *context = GetValidGlobalContext();
7727 EVENT(context, GLProgramUniformMatrix2x4fvEXT,
7728 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7729 "0x%016" PRIxPTR "",
7730 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7731
7732 if (context)
7733 {
7734 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7735 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7736 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7737 bool isCallValid = (context->skipValidation() ||
7738 ValidateProgramUniformMatrix2x4fvEXT(
7739 context, angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT,
7740 programPacked, locationPacked, count, transpose, value));
7741 if (isCallValid)
7742 {
7743 context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
7744 value);
7745 }
7746 ANGLE_CAPTURE(ProgramUniformMatrix2x4fvEXT, isCallValid, context, programPacked,
7747 locationPacked, count, transpose, value);
7748 }
7749 else
7750 {
7751 GenerateContextLostErrorOnCurrentGlobalContext();
7752 }
7753 }
7754
GL_ProgramUniformMatrix3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7755 void GL_APIENTRY GL_ProgramUniformMatrix3fvEXT(GLuint program,
7756 GLint location,
7757 GLsizei count,
7758 GLboolean transpose,
7759 const GLfloat *value)
7760 {
7761 Context *context = GetValidGlobalContext();
7762 EVENT(context, GLProgramUniformMatrix3fvEXT,
7763 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7764 "0x%016" PRIxPTR "",
7765 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7766
7767 if (context)
7768 {
7769 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7770 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7771 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7772 bool isCallValid = (context->skipValidation() ||
7773 ValidateProgramUniformMatrix3fvEXT(
7774 context, angle::EntryPoint::GLProgramUniformMatrix3fvEXT,
7775 programPacked, locationPacked, count, transpose, value));
7776 if (isCallValid)
7777 {
7778 context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
7779 value);
7780 }
7781 ANGLE_CAPTURE(ProgramUniformMatrix3fvEXT, isCallValid, context, programPacked,
7782 locationPacked, count, transpose, value);
7783 }
7784 else
7785 {
7786 GenerateContextLostErrorOnCurrentGlobalContext();
7787 }
7788 }
7789
GL_ProgramUniformMatrix3x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7790 void GL_APIENTRY GL_ProgramUniformMatrix3x2fvEXT(GLuint program,
7791 GLint location,
7792 GLsizei count,
7793 GLboolean transpose,
7794 const GLfloat *value)
7795 {
7796 Context *context = GetValidGlobalContext();
7797 EVENT(context, GLProgramUniformMatrix3x2fvEXT,
7798 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7799 "0x%016" PRIxPTR "",
7800 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7801
7802 if (context)
7803 {
7804 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7805 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7806 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7807 bool isCallValid = (context->skipValidation() ||
7808 ValidateProgramUniformMatrix3x2fvEXT(
7809 context, angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT,
7810 programPacked, locationPacked, count, transpose, value));
7811 if (isCallValid)
7812 {
7813 context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
7814 value);
7815 }
7816 ANGLE_CAPTURE(ProgramUniformMatrix3x2fvEXT, isCallValid, context, programPacked,
7817 locationPacked, count, transpose, value);
7818 }
7819 else
7820 {
7821 GenerateContextLostErrorOnCurrentGlobalContext();
7822 }
7823 }
7824
GL_ProgramUniformMatrix3x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7825 void GL_APIENTRY GL_ProgramUniformMatrix3x4fvEXT(GLuint program,
7826 GLint location,
7827 GLsizei count,
7828 GLboolean transpose,
7829 const GLfloat *value)
7830 {
7831 Context *context = GetValidGlobalContext();
7832 EVENT(context, GLProgramUniformMatrix3x4fvEXT,
7833 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7834 "0x%016" PRIxPTR "",
7835 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7836
7837 if (context)
7838 {
7839 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7840 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7841 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7842 bool isCallValid = (context->skipValidation() ||
7843 ValidateProgramUniformMatrix3x4fvEXT(
7844 context, angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT,
7845 programPacked, locationPacked, count, transpose, value));
7846 if (isCallValid)
7847 {
7848 context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
7849 value);
7850 }
7851 ANGLE_CAPTURE(ProgramUniformMatrix3x4fvEXT, isCallValid, context, programPacked,
7852 locationPacked, count, transpose, value);
7853 }
7854 else
7855 {
7856 GenerateContextLostErrorOnCurrentGlobalContext();
7857 }
7858 }
7859
GL_ProgramUniformMatrix4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7860 void GL_APIENTRY GL_ProgramUniformMatrix4fvEXT(GLuint program,
7861 GLint location,
7862 GLsizei count,
7863 GLboolean transpose,
7864 const GLfloat *value)
7865 {
7866 Context *context = GetValidGlobalContext();
7867 EVENT(context, GLProgramUniformMatrix4fvEXT,
7868 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7869 "0x%016" PRIxPTR "",
7870 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7871
7872 if (context)
7873 {
7874 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7875 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7876 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7877 bool isCallValid = (context->skipValidation() ||
7878 ValidateProgramUniformMatrix4fvEXT(
7879 context, angle::EntryPoint::GLProgramUniformMatrix4fvEXT,
7880 programPacked, locationPacked, count, transpose, value));
7881 if (isCallValid)
7882 {
7883 context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
7884 value);
7885 }
7886 ANGLE_CAPTURE(ProgramUniformMatrix4fvEXT, isCallValid, context, programPacked,
7887 locationPacked, count, transpose, value);
7888 }
7889 else
7890 {
7891 GenerateContextLostErrorOnCurrentGlobalContext();
7892 }
7893 }
7894
GL_ProgramUniformMatrix4x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7895 void GL_APIENTRY GL_ProgramUniformMatrix4x2fvEXT(GLuint program,
7896 GLint location,
7897 GLsizei count,
7898 GLboolean transpose,
7899 const GLfloat *value)
7900 {
7901 Context *context = GetValidGlobalContext();
7902 EVENT(context, GLProgramUniformMatrix4x2fvEXT,
7903 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7904 "0x%016" PRIxPTR "",
7905 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7906
7907 if (context)
7908 {
7909 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7910 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7911 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7912 bool isCallValid = (context->skipValidation() ||
7913 ValidateProgramUniformMatrix4x2fvEXT(
7914 context, angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT,
7915 programPacked, locationPacked, count, transpose, value));
7916 if (isCallValid)
7917 {
7918 context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
7919 value);
7920 }
7921 ANGLE_CAPTURE(ProgramUniformMatrix4x2fvEXT, isCallValid, context, programPacked,
7922 locationPacked, count, transpose, value);
7923 }
7924 else
7925 {
7926 GenerateContextLostErrorOnCurrentGlobalContext();
7927 }
7928 }
7929
GL_ProgramUniformMatrix4x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7930 void GL_APIENTRY GL_ProgramUniformMatrix4x3fvEXT(GLuint program,
7931 GLint location,
7932 GLsizei count,
7933 GLboolean transpose,
7934 const GLfloat *value)
7935 {
7936 Context *context = GetValidGlobalContext();
7937 EVENT(context, GLProgramUniformMatrix4x3fvEXT,
7938 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
7939 "0x%016" PRIxPTR "",
7940 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
7941
7942 if (context)
7943 {
7944 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7945 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7946 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7947 bool isCallValid = (context->skipValidation() ||
7948 ValidateProgramUniformMatrix4x3fvEXT(
7949 context, angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT,
7950 programPacked, locationPacked, count, transpose, value));
7951 if (isCallValid)
7952 {
7953 context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
7954 value);
7955 }
7956 ANGLE_CAPTURE(ProgramUniformMatrix4x3fvEXT, isCallValid, context, programPacked,
7957 locationPacked, count, transpose, value);
7958 }
7959 else
7960 {
7961 GenerateContextLostErrorOnCurrentGlobalContext();
7962 }
7963 }
7964
GL_UseProgramStagesEXT(GLuint pipeline,GLbitfield stages,GLuint program)7965 void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program)
7966 {
7967 Context *context = GetValidGlobalContext();
7968 EVENT(context, GLUseProgramStagesEXT, "context = %d, pipeline = %u, stages = %s, program = %u",
7969 CID(context), pipeline,
7970 GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program);
7971
7972 if (context)
7973 {
7974 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
7975 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7976 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
7977 bool isCallValid =
7978 (context->skipValidation() ||
7979 ValidateUseProgramStagesEXT(context, angle::EntryPoint::GLUseProgramStagesEXT,
7980 pipelinePacked, stages, programPacked));
7981 if (isCallValid)
7982 {
7983 context->useProgramStages(pipelinePacked, stages, programPacked);
7984 }
7985 ANGLE_CAPTURE(UseProgramStagesEXT, isCallValid, context, pipelinePacked, stages,
7986 programPacked);
7987 }
7988 else
7989 {
7990 GenerateContextLostErrorOnCurrentGlobalContext();
7991 }
7992 }
7993
GL_ValidateProgramPipelineEXT(GLuint pipeline)7994 void GL_APIENTRY GL_ValidateProgramPipelineEXT(GLuint pipeline)
7995 {
7996 Context *context = GetValidGlobalContext();
7997 EVENT(context, GLValidateProgramPipelineEXT, "context = %d, pipeline = %u", CID(context),
7998 pipeline);
7999
8000 if (context)
8001 {
8002 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
8003 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8004 bool isCallValid =
8005 (context->skipValidation() ||
8006 ValidateValidateProgramPipelineEXT(
8007 context, angle::EntryPoint::GLValidateProgramPipelineEXT, pipelinePacked));
8008 if (isCallValid)
8009 {
8010 context->validateProgramPipeline(pipelinePacked);
8011 }
8012 ANGLE_CAPTURE(ValidateProgramPipelineEXT, isCallValid, context, pipelinePacked);
8013 }
8014 else
8015 {
8016 GenerateContextLostErrorOnCurrentGlobalContext();
8017 }
8018 }
8019
8020 // GL_EXT_shader_framebuffer_fetch
8021
8022 // GL_EXT_shader_framebuffer_fetch_non_coherent
GL_FramebufferFetchBarrierEXT()8023 void GL_APIENTRY GL_FramebufferFetchBarrierEXT()
8024 {
8025 Context *context = GetValidGlobalContext();
8026 EVENT(context, GLFramebufferFetchBarrierEXT, "context = %d", CID(context));
8027
8028 if (context)
8029 {
8030 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8031 bool isCallValid = (context->skipValidation() ||
8032 ValidateFramebufferFetchBarrierEXT(
8033 context, angle::EntryPoint::GLFramebufferFetchBarrierEXT));
8034 if (isCallValid)
8035 {
8036 context->framebufferFetchBarrier();
8037 }
8038 ANGLE_CAPTURE(FramebufferFetchBarrierEXT, isCallValid, context);
8039 }
8040 else
8041 {
8042 GenerateContextLostErrorOnCurrentGlobalContext();
8043 }
8044 }
8045
8046 // GL_EXT_shader_io_blocks
8047
8048 // GL_EXT_shader_non_constant_global_initializers
8049
8050 // GL_EXT_shader_texture_lod
8051
8052 // GL_EXT_shadow_samplers
8053
8054 // GL_EXT_tessellation_shader
GL_PatchParameteriEXT(GLenum pname,GLint value)8055 void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value)
8056 {
8057 Context *context = GetValidGlobalContext();
8058 EVENT(context, GLPatchParameteriEXT, "context = %d, pname = %s, value = %d", CID(context),
8059 GLenumToString(GLenumGroup::PatchParameterName, pname), value);
8060
8061 if (context)
8062 {
8063 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8064 bool isCallValid = (context->skipValidation() ||
8065 ValidatePatchParameteriEXT(
8066 context, angle::EntryPoint::GLPatchParameteriEXT, pname, value));
8067 if (isCallValid)
8068 {
8069 context->patchParameteri(pname, value);
8070 }
8071 ANGLE_CAPTURE(PatchParameteriEXT, isCallValid, context, pname, value);
8072 }
8073 else
8074 {
8075 GenerateContextLostErrorOnCurrentGlobalContext();
8076 }
8077 }
8078
8079 // GL_EXT_texture_border_clamp
GL_GetSamplerParameterIivEXT(GLuint sampler,GLenum pname,GLint * params)8080 void GL_APIENTRY GL_GetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params)
8081 {
8082 Context *context = GetValidGlobalContext();
8083 EVENT(context, GLGetSamplerParameterIivEXT,
8084 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8085 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
8086
8087 if (context)
8088 {
8089 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
8090 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8091 bool isCallValid = (context->skipValidation() ||
8092 ValidateGetSamplerParameterIivEXT(
8093 context, angle::EntryPoint::GLGetSamplerParameterIivEXT,
8094 samplerPacked, pname, params));
8095 if (isCallValid)
8096 {
8097 context->getSamplerParameterIiv(samplerPacked, pname, params);
8098 }
8099 ANGLE_CAPTURE(GetSamplerParameterIivEXT, isCallValid, context, samplerPacked, pname,
8100 params);
8101 }
8102 else
8103 {
8104 GenerateContextLostErrorOnCurrentGlobalContext();
8105 }
8106 }
8107
GL_GetSamplerParameterIuivEXT(GLuint sampler,GLenum pname,GLuint * params)8108 void GL_APIENTRY GL_GetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params)
8109 {
8110 Context *context = GetValidGlobalContext();
8111 EVENT(context, GLGetSamplerParameterIuivEXT,
8112 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8113 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
8114
8115 if (context)
8116 {
8117 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
8118 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8119 bool isCallValid = (context->skipValidation() ||
8120 ValidateGetSamplerParameterIuivEXT(
8121 context, angle::EntryPoint::GLGetSamplerParameterIuivEXT,
8122 samplerPacked, pname, params));
8123 if (isCallValid)
8124 {
8125 context->getSamplerParameterIuiv(samplerPacked, pname, params);
8126 }
8127 ANGLE_CAPTURE(GetSamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname,
8128 params);
8129 }
8130 else
8131 {
8132 GenerateContextLostErrorOnCurrentGlobalContext();
8133 }
8134 }
8135
GL_GetTexParameterIivEXT(GLenum target,GLenum pname,GLint * params)8136 void GL_APIENTRY GL_GetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
8137 {
8138 Context *context = GetValidGlobalContext();
8139 EVENT(context, GLGetTexParameterIivEXT,
8140 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8141 GLenumToString(GLenumGroup::TextureTarget, target),
8142 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
8143
8144 if (context)
8145 {
8146 TextureType targetPacked = PackParam<TextureType>(target);
8147 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8148 bool isCallValid =
8149 (context->skipValidation() ||
8150 ValidateGetTexParameterIivEXT(context, angle::EntryPoint::GLGetTexParameterIivEXT,
8151 targetPacked, pname, params));
8152 if (isCallValid)
8153 {
8154 context->getTexParameterIiv(targetPacked, pname, params);
8155 }
8156 ANGLE_CAPTURE(GetTexParameterIivEXT, isCallValid, context, targetPacked, pname, params);
8157 }
8158 else
8159 {
8160 GenerateContextLostErrorOnCurrentGlobalContext();
8161 }
8162 }
8163
GL_GetTexParameterIuivEXT(GLenum target,GLenum pname,GLuint * params)8164 void GL_APIENTRY GL_GetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
8165 {
8166 Context *context = GetValidGlobalContext();
8167 EVENT(context, GLGetTexParameterIuivEXT,
8168 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8169 GLenumToString(GLenumGroup::TextureTarget, target),
8170 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
8171
8172 if (context)
8173 {
8174 TextureType targetPacked = PackParam<TextureType>(target);
8175 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8176 bool isCallValid =
8177 (context->skipValidation() ||
8178 ValidateGetTexParameterIuivEXT(context, angle::EntryPoint::GLGetTexParameterIuivEXT,
8179 targetPacked, pname, params));
8180 if (isCallValid)
8181 {
8182 context->getTexParameterIuiv(targetPacked, pname, params);
8183 }
8184 ANGLE_CAPTURE(GetTexParameterIuivEXT, isCallValid, context, targetPacked, pname, params);
8185 }
8186 else
8187 {
8188 GenerateContextLostErrorOnCurrentGlobalContext();
8189 }
8190 }
8191
GL_SamplerParameterIivEXT(GLuint sampler,GLenum pname,const GLint * param)8192 void GL_APIENTRY GL_SamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param)
8193 {
8194 Context *context = GetValidGlobalContext();
8195 EVENT(context, GLSamplerParameterIivEXT,
8196 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
8197 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
8198
8199 if (context)
8200 {
8201 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
8202 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8203 bool isCallValid =
8204 (context->skipValidation() ||
8205 ValidateSamplerParameterIivEXT(context, angle::EntryPoint::GLSamplerParameterIivEXT,
8206 samplerPacked, pname, param));
8207 if (isCallValid)
8208 {
8209 context->samplerParameterIiv(samplerPacked, pname, param);
8210 }
8211 ANGLE_CAPTURE(SamplerParameterIivEXT, isCallValid, context, samplerPacked, pname, param);
8212 }
8213 else
8214 {
8215 GenerateContextLostErrorOnCurrentGlobalContext();
8216 }
8217 }
8218
GL_SamplerParameterIuivEXT(GLuint sampler,GLenum pname,const GLuint * param)8219 void GL_APIENTRY GL_SamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param)
8220 {
8221 Context *context = GetValidGlobalContext();
8222 EVENT(context, GLSamplerParameterIuivEXT,
8223 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
8224 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
8225
8226 if (context)
8227 {
8228 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
8229 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8230 bool isCallValid =
8231 (context->skipValidation() ||
8232 ValidateSamplerParameterIuivEXT(context, angle::EntryPoint::GLSamplerParameterIuivEXT,
8233 samplerPacked, pname, param));
8234 if (isCallValid)
8235 {
8236 context->samplerParameterIuiv(samplerPacked, pname, param);
8237 }
8238 ANGLE_CAPTURE(SamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname, param);
8239 }
8240 else
8241 {
8242 GenerateContextLostErrorOnCurrentGlobalContext();
8243 }
8244 }
8245
GL_TexParameterIivEXT(GLenum target,GLenum pname,const GLint * params)8246 void GL_APIENTRY GL_TexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
8247 {
8248 Context *context = GetValidGlobalContext();
8249 EVENT(context, GLTexParameterIivEXT,
8250 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8251 GLenumToString(GLenumGroup::TextureTarget, target),
8252 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
8253
8254 if (context)
8255 {
8256 TextureType targetPacked = PackParam<TextureType>(target);
8257 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8258 bool isCallValid =
8259 (context->skipValidation() ||
8260 ValidateTexParameterIivEXT(context, angle::EntryPoint::GLTexParameterIivEXT,
8261 targetPacked, pname, params));
8262 if (isCallValid)
8263 {
8264 context->texParameterIiv(targetPacked, pname, params);
8265 }
8266 ANGLE_CAPTURE(TexParameterIivEXT, isCallValid, context, targetPacked, pname, params);
8267 }
8268 else
8269 {
8270 GenerateContextLostErrorOnCurrentGlobalContext();
8271 }
8272 }
8273
GL_TexParameterIuivEXT(GLenum target,GLenum pname,const GLuint * params)8274 void GL_APIENTRY GL_TexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
8275 {
8276 Context *context = GetValidGlobalContext();
8277 EVENT(context, GLTexParameterIuivEXT,
8278 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8279 GLenumToString(GLenumGroup::TextureTarget, target),
8280 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
8281
8282 if (context)
8283 {
8284 TextureType targetPacked = PackParam<TextureType>(target);
8285 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8286 bool isCallValid =
8287 (context->skipValidation() ||
8288 ValidateTexParameterIuivEXT(context, angle::EntryPoint::GLTexParameterIuivEXT,
8289 targetPacked, pname, params));
8290 if (isCallValid)
8291 {
8292 context->texParameterIuiv(targetPacked, pname, params);
8293 }
8294 ANGLE_CAPTURE(TexParameterIuivEXT, isCallValid, context, targetPacked, pname, params);
8295 }
8296 else
8297 {
8298 GenerateContextLostErrorOnCurrentGlobalContext();
8299 }
8300 }
8301
8302 // GL_EXT_texture_buffer
GL_TexBufferEXT(GLenum target,GLenum internalformat,GLuint buffer)8303 void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
8304 {
8305 Context *context = GetValidGlobalContext();
8306 EVENT(context, GLTexBufferEXT, "context = %d, target = %s, internalformat = %s, buffer = %u",
8307 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
8308 GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer);
8309
8310 if (context)
8311 {
8312 TextureType targetPacked = PackParam<TextureType>(target);
8313 BufferID bufferPacked = PackParam<BufferID>(buffer);
8314 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8315 bool isCallValid = (context->skipValidation() ||
8316 ValidateTexBufferEXT(context, angle::EntryPoint::GLTexBufferEXT,
8317 targetPacked, internalformat, bufferPacked));
8318 if (isCallValid)
8319 {
8320 context->texBuffer(targetPacked, internalformat, bufferPacked);
8321 }
8322 ANGLE_CAPTURE(TexBufferEXT, isCallValid, context, targetPacked, internalformat,
8323 bufferPacked);
8324 }
8325 else
8326 {
8327 GenerateContextLostErrorOnCurrentGlobalContext();
8328 }
8329 }
8330
GL_TexBufferRangeEXT(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)8331 void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target,
8332 GLenum internalformat,
8333 GLuint buffer,
8334 GLintptr offset,
8335 GLsizeiptr size)
8336 {
8337 Context *context = GetValidGlobalContext();
8338 EVENT(context, GLTexBufferRangeEXT,
8339 "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu",
8340 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
8341 GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer,
8342 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
8343
8344 if (context)
8345 {
8346 TextureType targetPacked = PackParam<TextureType>(target);
8347 BufferID bufferPacked = PackParam<BufferID>(buffer);
8348 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8349 bool isCallValid =
8350 (context->skipValidation() ||
8351 ValidateTexBufferRangeEXT(context, angle::EntryPoint::GLTexBufferRangeEXT,
8352 targetPacked, internalformat, bufferPacked, offset, size));
8353 if (isCallValid)
8354 {
8355 context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size);
8356 }
8357 ANGLE_CAPTURE(TexBufferRangeEXT, isCallValid, context, targetPacked, internalformat,
8358 bufferPacked, offset, size);
8359 }
8360 else
8361 {
8362 GenerateContextLostErrorOnCurrentGlobalContext();
8363 }
8364 }
8365
8366 // GL_EXT_texture_compression_bptc
8367
8368 // GL_EXT_texture_compression_dxt1
8369
8370 // GL_EXT_texture_compression_rgtc
8371
8372 // GL_EXT_texture_compression_s3tc
8373
8374 // GL_EXT_texture_compression_s3tc_srgb
8375
8376 // GL_EXT_texture_cube_map_array
8377
8378 // GL_EXT_texture_filter_anisotropic
8379
8380 // GL_EXT_texture_format_BGRA8888
8381
8382 // GL_EXT_texture_format_sRGB_override
8383
8384 // GL_EXT_texture_norm16
8385
8386 // GL_EXT_texture_rg
8387
8388 // GL_EXT_texture_sRGB_R8
8389
8390 // GL_EXT_texture_sRGB_RG8
8391
8392 // GL_EXT_texture_sRGB_decode
8393
8394 // GL_EXT_texture_storage
GL_TexStorage1DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)8395 void GL_APIENTRY GL_TexStorage1DEXT(GLenum target,
8396 GLsizei levels,
8397 GLenum internalformat,
8398 GLsizei width)
8399 {
8400 Context *context = GetValidGlobalContext();
8401 EVENT(context, GLTexStorage1DEXT,
8402 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d", CID(context),
8403 GLenumToString(GLenumGroup::TextureTarget, target), levels,
8404 GLenumToString(GLenumGroup::InternalFormat, internalformat), width);
8405
8406 if (context)
8407 {
8408 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8409 bool isCallValid = (context->skipValidation() ||
8410 ValidateTexStorage1DEXT(context, angle::EntryPoint::GLTexStorage1DEXT,
8411 target, levels, internalformat, width));
8412 if (isCallValid)
8413 {
8414 context->texStorage1D(target, levels, internalformat, width);
8415 }
8416 ANGLE_CAPTURE(TexStorage1DEXT, isCallValid, context, target, levels, internalformat, width);
8417 }
8418 else
8419 {
8420 GenerateContextLostErrorOnCurrentGlobalContext();
8421 }
8422 }
8423
GL_TexStorage2DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)8424 void GL_APIENTRY GL_TexStorage2DEXT(GLenum target,
8425 GLsizei levels,
8426 GLenum internalformat,
8427 GLsizei width,
8428 GLsizei height)
8429 {
8430 Context *context = GetValidGlobalContext();
8431 EVENT(context, GLTexStorage2DEXT,
8432 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d",
8433 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
8434 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
8435
8436 if (context)
8437 {
8438 TextureType targetPacked = PackParam<TextureType>(target);
8439 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8440 bool isCallValid =
8441 (context->skipValidation() ||
8442 ValidateTexStorage2DEXT(context, angle::EntryPoint::GLTexStorage2DEXT, targetPacked,
8443 levels, internalformat, width, height));
8444 if (isCallValid)
8445 {
8446 context->texStorage2D(targetPacked, levels, internalformat, width, height);
8447 }
8448 ANGLE_CAPTURE(TexStorage2DEXT, isCallValid, context, targetPacked, levels, internalformat,
8449 width, height);
8450 }
8451 else
8452 {
8453 GenerateContextLostErrorOnCurrentGlobalContext();
8454 }
8455 }
8456
GL_TexStorage3DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)8457 void GL_APIENTRY GL_TexStorage3DEXT(GLenum target,
8458 GLsizei levels,
8459 GLenum internalformat,
8460 GLsizei width,
8461 GLsizei height,
8462 GLsizei depth)
8463 {
8464 Context *context = GetValidGlobalContext();
8465 EVENT(context, GLTexStorage3DEXT,
8466 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, "
8467 "depth = %d",
8468 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels,
8469 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth);
8470
8471 if (context)
8472 {
8473 TextureType targetPacked = PackParam<TextureType>(target);
8474 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8475 bool isCallValid =
8476 (context->skipValidation() ||
8477 ValidateTexStorage3DEXT(context, angle::EntryPoint::GLTexStorage3DEXT, targetPacked,
8478 levels, internalformat, width, height, depth));
8479 if (isCallValid)
8480 {
8481 context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
8482 }
8483 ANGLE_CAPTURE(TexStorage3DEXT, isCallValid, context, targetPacked, levels, internalformat,
8484 width, height, depth);
8485 }
8486 else
8487 {
8488 GenerateContextLostErrorOnCurrentGlobalContext();
8489 }
8490 }
8491
8492 // GL_EXT_texture_type_2_10_10_10_REV
8493
8494 // GL_EXT_unpack_subimage
8495
8496 // GL_IMG_texture_compression_pvrtc
8497
8498 // GL_IMG_texture_compression_pvrtc2
8499
8500 // GL_KHR_blend_equation_advanced
GL_BlendBarrierKHR()8501 void GL_APIENTRY GL_BlendBarrierKHR()
8502 {
8503 Context *context = GetValidGlobalContext();
8504 EVENT(context, GLBlendBarrierKHR, "context = %d", CID(context));
8505
8506 if (context)
8507 {
8508 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8509 bool isCallValid = (context->skipValidation() ||
8510 ValidateBlendBarrierKHR(context, angle::EntryPoint::GLBlendBarrierKHR));
8511 if (isCallValid)
8512 {
8513 context->blendBarrier();
8514 }
8515 ANGLE_CAPTURE(BlendBarrierKHR, isCallValid, context);
8516 }
8517 else
8518 {
8519 GenerateContextLostErrorOnCurrentGlobalContext();
8520 }
8521 }
8522
8523 // GL_KHR_debug
GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback,const void * userParam)8524 void GL_APIENTRY GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
8525 {
8526 Context *context = GetValidGlobalContext();
8527 EVENT(context, GLDebugMessageCallbackKHR,
8528 "context = %d, callback = 0x%016" PRIxPTR ", userParam = 0x%016" PRIxPTR "", CID(context),
8529 (uintptr_t)callback, (uintptr_t)userParam);
8530
8531 if (context)
8532 {
8533 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8534 bool isCallValid =
8535 (context->skipValidation() ||
8536 ValidateDebugMessageCallbackKHR(context, angle::EntryPoint::GLDebugMessageCallbackKHR,
8537 callback, userParam));
8538 if (isCallValid)
8539 {
8540 context->debugMessageCallback(callback, userParam);
8541 }
8542 ANGLE_CAPTURE(DebugMessageCallbackKHR, isCallValid, context, callback, userParam);
8543 }
8544 else
8545 {
8546 GenerateContextLostErrorOnCurrentGlobalContext();
8547 }
8548 }
8549
GL_DebugMessageControlKHR(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)8550 void GL_APIENTRY GL_DebugMessageControlKHR(GLenum source,
8551 GLenum type,
8552 GLenum severity,
8553 GLsizei count,
8554 const GLuint *ids,
8555 GLboolean enabled)
8556 {
8557 Context *context = GetValidGlobalContext();
8558 EVENT(context, GLDebugMessageControlKHR,
8559 "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR
8560 ", enabled = %s",
8561 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
8562 GLenumToString(GLenumGroup::DebugType, type),
8563 GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids,
8564 GLbooleanToString(enabled));
8565
8566 if (context)
8567 {
8568 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8569 bool isCallValid =
8570 (context->skipValidation() ||
8571 ValidateDebugMessageControlKHR(context, angle::EntryPoint::GLDebugMessageControlKHR,
8572 source, type, severity, count, ids, enabled));
8573 if (isCallValid)
8574 {
8575 context->debugMessageControl(source, type, severity, count, ids, enabled);
8576 }
8577 ANGLE_CAPTURE(DebugMessageControlKHR, isCallValid, context, source, type, severity, count,
8578 ids, enabled);
8579 }
8580 else
8581 {
8582 GenerateContextLostErrorOnCurrentGlobalContext();
8583 }
8584 }
8585
GL_DebugMessageInsertKHR(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)8586 void GL_APIENTRY GL_DebugMessageInsertKHR(GLenum source,
8587 GLenum type,
8588 GLuint id,
8589 GLenum severity,
8590 GLsizei length,
8591 const GLchar *buf)
8592 {
8593 Context *context = GetValidGlobalContext();
8594 EVENT(context, GLDebugMessageInsertKHR,
8595 "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = "
8596 "0x%016" PRIxPTR "",
8597 CID(context), GLenumToString(GLenumGroup::DebugSource, source),
8598 GLenumToString(GLenumGroup::DebugType, type), id,
8599 GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf);
8600
8601 if (context)
8602 {
8603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8604 bool isCallValid =
8605 (context->skipValidation() ||
8606 ValidateDebugMessageInsertKHR(context, angle::EntryPoint::GLDebugMessageInsertKHR,
8607 source, type, id, severity, length, buf));
8608 if (isCallValid)
8609 {
8610 context->debugMessageInsert(source, type, id, severity, length, buf);
8611 }
8612 ANGLE_CAPTURE(DebugMessageInsertKHR, isCallValid, context, source, type, id, severity,
8613 length, buf);
8614 }
8615 else
8616 {
8617 GenerateContextLostErrorOnCurrentGlobalContext();
8618 }
8619 }
8620
GL_GetDebugMessageLogKHR(GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)8621 GLuint GL_APIENTRY GL_GetDebugMessageLogKHR(GLuint count,
8622 GLsizei bufSize,
8623 GLenum *sources,
8624 GLenum *types,
8625 GLuint *ids,
8626 GLenum *severities,
8627 GLsizei *lengths,
8628 GLchar *messageLog)
8629 {
8630 Context *context = GetValidGlobalContext();
8631 EVENT(context, GLGetDebugMessageLogKHR,
8632 "context = %d, count = %u, bufSize = %d, sources = 0x%016" PRIxPTR
8633 ", types = 0x%016" PRIxPTR ", ids = 0x%016" PRIxPTR ", severities = 0x%016" PRIxPTR
8634 ", lengths = 0x%016" PRIxPTR ", messageLog = 0x%016" PRIxPTR "",
8635 CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
8636 (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
8637
8638 GLuint returnValue;
8639 if (context)
8640 {
8641 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8642 bool isCallValid = (context->skipValidation() ||
8643 ValidateGetDebugMessageLogKHR(
8644 context, angle::EntryPoint::GLGetDebugMessageLogKHR, count, bufSize,
8645 sources, types, ids, severities, lengths, messageLog));
8646 if (isCallValid)
8647 {
8648 returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
8649 severities, lengths, messageLog);
8650 }
8651 else
8652 {
8653 returnValue =
8654 GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>();
8655 }
8656 ANGLE_CAPTURE(GetDebugMessageLogKHR, isCallValid, context, count, bufSize, sources, types,
8657 ids, severities, lengths, messageLog, returnValue);
8658 }
8659 else
8660 {
8661 GenerateContextLostErrorOnCurrentGlobalContext();
8662 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>();
8663 }
8664 return returnValue;
8665 }
8666
GL_GetObjectLabelKHR(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)8667 void GL_APIENTRY GL_GetObjectLabelKHR(GLenum identifier,
8668 GLuint name,
8669 GLsizei bufSize,
8670 GLsizei *length,
8671 GLchar *label)
8672 {
8673 Context *context = GetValidGlobalContext();
8674 EVENT(context, GLGetObjectLabelKHR,
8675 "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR
8676 ", label = 0x%016" PRIxPTR "",
8677 CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize,
8678 (uintptr_t)length, (uintptr_t)label);
8679
8680 if (context)
8681 {
8682 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8683 bool isCallValid =
8684 (context->skipValidation() ||
8685 ValidateGetObjectLabelKHR(context, angle::EntryPoint::GLGetObjectLabelKHR, identifier,
8686 name, bufSize, length, label));
8687 if (isCallValid)
8688 {
8689 context->getObjectLabel(identifier, name, bufSize, length, label);
8690 }
8691 ANGLE_CAPTURE(GetObjectLabelKHR, isCallValid, context, identifier, name, bufSize, length,
8692 label);
8693 }
8694 else
8695 {
8696 GenerateContextLostErrorOnCurrentGlobalContext();
8697 }
8698 }
8699
GL_GetObjectPtrLabelKHR(const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)8700 void GL_APIENTRY GL_GetObjectPtrLabelKHR(const void *ptr,
8701 GLsizei bufSize,
8702 GLsizei *length,
8703 GLchar *label)
8704 {
8705 Context *context = GetValidGlobalContext();
8706 EVENT(context, GLGetObjectPtrLabelKHR,
8707 "context = %d, ptr = 0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR
8708 ", label = 0x%016" PRIxPTR "",
8709 CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
8710
8711 if (context)
8712 {
8713 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8714 bool isCallValid =
8715 (context->skipValidation() ||
8716 ValidateGetObjectPtrLabelKHR(context, angle::EntryPoint::GLGetObjectPtrLabelKHR, ptr,
8717 bufSize, length, label));
8718 if (isCallValid)
8719 {
8720 context->getObjectPtrLabel(ptr, bufSize, length, label);
8721 }
8722 ANGLE_CAPTURE(GetObjectPtrLabelKHR, isCallValid, context, ptr, bufSize, length, label);
8723 }
8724 else
8725 {
8726 GenerateContextLostErrorOnCurrentGlobalContext();
8727 }
8728 }
8729
GL_GetPointervKHR(GLenum pname,void ** params)8730 void GL_APIENTRY GL_GetPointervKHR(GLenum pname, void **params)
8731 {
8732 Context *context = GetValidGlobalContext();
8733 EVENT(context, GLGetPointervKHR, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
8734 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
8735
8736 if (context)
8737 {
8738 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8739 bool isCallValid =
8740 (context->skipValidation() ||
8741 ValidateGetPointervKHR(context, angle::EntryPoint::GLGetPointervKHR, pname, params));
8742 if (isCallValid)
8743 {
8744 context->getPointerv(pname, params);
8745 }
8746 ANGLE_CAPTURE(GetPointervKHR, isCallValid, context, pname, params);
8747 }
8748 else
8749 {
8750 GenerateContextLostErrorOnCurrentGlobalContext();
8751 }
8752 }
8753
GL_ObjectLabelKHR(GLenum identifier,GLuint name,GLsizei length,const GLchar * label)8754 void GL_APIENTRY GL_ObjectLabelKHR(GLenum identifier,
8755 GLuint name,
8756 GLsizei length,
8757 const GLchar *label)
8758 {
8759 Context *context = GetValidGlobalContext();
8760 EVENT(context, GLObjectLabelKHR,
8761 "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "",
8762 CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length,
8763 (uintptr_t)label);
8764
8765 if (context)
8766 {
8767 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8768 bool isCallValid = (context->skipValidation() ||
8769 ValidateObjectLabelKHR(context, angle::EntryPoint::GLObjectLabelKHR,
8770 identifier, name, length, label));
8771 if (isCallValid)
8772 {
8773 context->objectLabel(identifier, name, length, label);
8774 }
8775 ANGLE_CAPTURE(ObjectLabelKHR, isCallValid, context, identifier, name, length, label);
8776 }
8777 else
8778 {
8779 GenerateContextLostErrorOnCurrentGlobalContext();
8780 }
8781 }
8782
GL_ObjectPtrLabelKHR(const void * ptr,GLsizei length,const GLchar * label)8783 void GL_APIENTRY GL_ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
8784 {
8785 Context *context = GetValidGlobalContext();
8786 EVENT(context, GLObjectPtrLabelKHR,
8787 "context = %d, ptr = 0x%016" PRIxPTR ", length = %d, label = 0x%016" PRIxPTR "",
8788 CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
8789
8790 if (context)
8791 {
8792 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8793 bool isCallValid =
8794 (context->skipValidation() ||
8795 ValidateObjectPtrLabelKHR(context, angle::EntryPoint::GLObjectPtrLabelKHR, ptr, length,
8796 label));
8797 if (isCallValid)
8798 {
8799 context->objectPtrLabel(ptr, length, label);
8800 }
8801 ANGLE_CAPTURE(ObjectPtrLabelKHR, isCallValid, context, ptr, length, label);
8802 }
8803 else
8804 {
8805 GenerateContextLostErrorOnCurrentGlobalContext();
8806 }
8807 }
8808
GL_PopDebugGroupKHR()8809 void GL_APIENTRY GL_PopDebugGroupKHR()
8810 {
8811 Context *context = GetValidGlobalContext();
8812 EVENT(context, GLPopDebugGroupKHR, "context = %d", CID(context));
8813
8814 if (context)
8815 {
8816 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8817 bool isCallValid =
8818 (context->skipValidation() ||
8819 ValidatePopDebugGroupKHR(context, angle::EntryPoint::GLPopDebugGroupKHR));
8820 if (isCallValid)
8821 {
8822 context->popDebugGroup();
8823 }
8824 ANGLE_CAPTURE(PopDebugGroupKHR, isCallValid, context);
8825 }
8826 else
8827 {
8828 GenerateContextLostErrorOnCurrentGlobalContext();
8829 }
8830 }
8831
GL_PushDebugGroupKHR(GLenum source,GLuint id,GLsizei length,const GLchar * message)8832 void GL_APIENTRY GL_PushDebugGroupKHR(GLenum source,
8833 GLuint id,
8834 GLsizei length,
8835 const GLchar *message)
8836 {
8837 Context *context = GetValidGlobalContext();
8838 EVENT(context, GLPushDebugGroupKHR,
8839 "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "",
8840 CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length,
8841 (uintptr_t)message);
8842
8843 if (context)
8844 {
8845 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8846 bool isCallValid =
8847 (context->skipValidation() ||
8848 ValidatePushDebugGroupKHR(context, angle::EntryPoint::GLPushDebugGroupKHR, source, id,
8849 length, message));
8850 if (isCallValid)
8851 {
8852 context->pushDebugGroup(source, id, length, message);
8853 }
8854 ANGLE_CAPTURE(PushDebugGroupKHR, isCallValid, context, source, id, length, message);
8855 }
8856 else
8857 {
8858 GenerateContextLostErrorOnCurrentGlobalContext();
8859 }
8860 }
8861
8862 // GL_KHR_no_error
8863
8864 // GL_KHR_parallel_shader_compile
GL_MaxShaderCompilerThreadsKHR(GLuint count)8865 void GL_APIENTRY GL_MaxShaderCompilerThreadsKHR(GLuint count)
8866 {
8867 Context *context = GetValidGlobalContext();
8868 EVENT(context, GLMaxShaderCompilerThreadsKHR, "context = %d, count = %u", CID(context), count);
8869
8870 if (context)
8871 {
8872 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8873 bool isCallValid = (context->skipValidation() ||
8874 ValidateMaxShaderCompilerThreadsKHR(
8875 context, angle::EntryPoint::GLMaxShaderCompilerThreadsKHR, count));
8876 if (isCallValid)
8877 {
8878 context->maxShaderCompilerThreads(count);
8879 }
8880 ANGLE_CAPTURE(MaxShaderCompilerThreadsKHR, isCallValid, context, count);
8881 }
8882 else
8883 {
8884 GenerateContextLostErrorOnCurrentGlobalContext();
8885 }
8886 }
8887
8888 // GL_KHR_robust_buffer_access_behavior
8889
8890 // GL_KHR_texture_compression_astc_hdr
8891
8892 // GL_KHR_texture_compression_astc_ldr
8893
8894 // GL_KHR_texture_compression_astc_sliced_3d
8895
8896 // GL_MESA_framebuffer_flip_y
GL_FramebufferParameteriMESA(GLenum target,GLenum pname,GLint param)8897 void GL_APIENTRY GL_FramebufferParameteriMESA(GLenum target, GLenum pname, GLint param)
8898 {
8899 Context *context = GetValidGlobalContext();
8900 EVENT(context, GLFramebufferParameteriMESA, "context = %d, target = %s, pname = %s, param = %d",
8901 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
8902 GLenumToString(GLenumGroup::FramebufferParameterName, pname), param);
8903
8904 if (context)
8905 {
8906 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8907 bool isCallValid =
8908 (context->skipValidation() ||
8909 ValidateFramebufferParameteriMESA(
8910 context, angle::EntryPoint::GLFramebufferParameteriMESA, target, pname, param));
8911 if (isCallValid)
8912 {
8913 context->framebufferParameteriMESA(target, pname, param);
8914 }
8915 ANGLE_CAPTURE(FramebufferParameteriMESA, isCallValid, context, target, pname, param);
8916 }
8917 else
8918 {
8919 GenerateContextLostErrorOnCurrentGlobalContext();
8920 }
8921 }
8922
GL_GetFramebufferParameterivMESA(GLenum target,GLenum pname,GLint * params)8923 void GL_APIENTRY GL_GetFramebufferParameterivMESA(GLenum target, GLenum pname, GLint *params)
8924 {
8925 Context *context = GetValidGlobalContext();
8926 EVENT(context, GLGetFramebufferParameterivMESA,
8927 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8928 GLenumToString(GLenumGroup::FramebufferTarget, target),
8929 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
8930 (uintptr_t)params);
8931
8932 if (context)
8933 {
8934 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8935 bool isCallValid = (context->skipValidation() ||
8936 ValidateGetFramebufferParameterivMESA(
8937 context, angle::EntryPoint::GLGetFramebufferParameterivMESA, target,
8938 pname, params));
8939 if (isCallValid)
8940 {
8941 context->getFramebufferParameterivMESA(target, pname, params);
8942 }
8943 ANGLE_CAPTURE(GetFramebufferParameterivMESA, isCallValid, context, target, pname, params);
8944 }
8945 else
8946 {
8947 GenerateContextLostErrorOnCurrentGlobalContext();
8948 }
8949 }
8950
8951 // GL_NV_fence
GL_DeleteFencesNV(GLsizei n,const GLuint * fences)8952 void GL_APIENTRY GL_DeleteFencesNV(GLsizei n, const GLuint *fences)
8953 {
8954 Context *context = GetValidGlobalContext();
8955 EVENT(context, GLDeleteFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "",
8956 CID(context), n, (uintptr_t)fences);
8957
8958 if (context)
8959 {
8960 const FenceNVID *fencesPacked = PackParam<const FenceNVID *>(fences);
8961 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8962 bool isCallValid =
8963 (context->skipValidation() ||
8964 ValidateDeleteFencesNV(context, angle::EntryPoint::GLDeleteFencesNV, n, fencesPacked));
8965 if (isCallValid)
8966 {
8967 context->deleteFencesNV(n, fencesPacked);
8968 }
8969 ANGLE_CAPTURE(DeleteFencesNV, isCallValid, context, n, fencesPacked);
8970 }
8971 else
8972 {
8973 GenerateContextLostErrorOnCurrentGlobalContext();
8974 }
8975 }
8976
GL_FinishFenceNV(GLuint fence)8977 void GL_APIENTRY GL_FinishFenceNV(GLuint fence)
8978 {
8979 Context *context = GetValidGlobalContext();
8980 EVENT(context, GLFinishFenceNV, "context = %d, fence = %u", CID(context), fence);
8981
8982 if (context)
8983 {
8984 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
8985 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
8986 bool isCallValid =
8987 (context->skipValidation() ||
8988 ValidateFinishFenceNV(context, angle::EntryPoint::GLFinishFenceNV, fencePacked));
8989 if (isCallValid)
8990 {
8991 context->finishFenceNV(fencePacked);
8992 }
8993 ANGLE_CAPTURE(FinishFenceNV, isCallValid, context, fencePacked);
8994 }
8995 else
8996 {
8997 GenerateContextLostErrorOnCurrentGlobalContext();
8998 }
8999 }
9000
GL_GenFencesNV(GLsizei n,GLuint * fences)9001 void GL_APIENTRY GL_GenFencesNV(GLsizei n, GLuint *fences)
9002 {
9003 Context *context = GetValidGlobalContext();
9004 EVENT(context, GLGenFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "", CID(context),
9005 n, (uintptr_t)fences);
9006
9007 if (context)
9008 {
9009 FenceNVID *fencesPacked = PackParam<FenceNVID *>(fences);
9010 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9011 bool isCallValid =
9012 (context->skipValidation() ||
9013 ValidateGenFencesNV(context, angle::EntryPoint::GLGenFencesNV, n, fencesPacked));
9014 if (isCallValid)
9015 {
9016 context->genFencesNV(n, fencesPacked);
9017 }
9018 ANGLE_CAPTURE(GenFencesNV, isCallValid, context, n, fencesPacked);
9019 }
9020 else
9021 {
9022 GenerateContextLostErrorOnCurrentGlobalContext();
9023 }
9024 }
9025
GL_GetFenceivNV(GLuint fence,GLenum pname,GLint * params)9026 void GL_APIENTRY GL_GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
9027 {
9028 Context *context = GetValidGlobalContext();
9029 EVENT(context, GLGetFenceivNV,
9030 "context = %d, fence = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), fence,
9031 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
9032
9033 if (context)
9034 {
9035 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
9036 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9037 bool isCallValid = (context->skipValidation() ||
9038 ValidateGetFenceivNV(context, angle::EntryPoint::GLGetFenceivNV,
9039 fencePacked, pname, params));
9040 if (isCallValid)
9041 {
9042 context->getFenceivNV(fencePacked, pname, params);
9043 }
9044 ANGLE_CAPTURE(GetFenceivNV, isCallValid, context, fencePacked, pname, params);
9045 }
9046 else
9047 {
9048 GenerateContextLostErrorOnCurrentGlobalContext();
9049 }
9050 }
9051
GL_IsFenceNV(GLuint fence)9052 GLboolean GL_APIENTRY GL_IsFenceNV(GLuint fence)
9053 {
9054 Context *context = GetValidGlobalContext();
9055 EVENT(context, GLIsFenceNV, "context = %d, fence = %u", CID(context), fence);
9056
9057 GLboolean returnValue;
9058 if (context)
9059 {
9060 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
9061 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9062 bool isCallValid =
9063 (context->skipValidation() ||
9064 ValidateIsFenceNV(context, angle::EntryPoint::GLIsFenceNV, fencePacked));
9065 if (isCallValid)
9066 {
9067 returnValue = context->isFenceNV(fencePacked);
9068 }
9069 else
9070 {
9071 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>();
9072 }
9073 ANGLE_CAPTURE(IsFenceNV, isCallValid, context, fencePacked, returnValue);
9074 }
9075 else
9076 {
9077 GenerateContextLostErrorOnCurrentGlobalContext();
9078 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>();
9079 }
9080 return returnValue;
9081 }
9082
GL_SetFenceNV(GLuint fence,GLenum condition)9083 void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition)
9084 {
9085 Context *context = GetValidGlobalContext();
9086 EVENT(context, GLSetFenceNV, "context = %d, fence = %u, condition = %s", CID(context), fence,
9087 GLenumToString(GLenumGroup::DefaultGroup, condition));
9088
9089 if (context)
9090 {
9091 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
9092 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9093 bool isCallValid =
9094 (context->skipValidation() ||
9095 ValidateSetFenceNV(context, angle::EntryPoint::GLSetFenceNV, fencePacked, condition));
9096 if (isCallValid)
9097 {
9098 context->setFenceNV(fencePacked, condition);
9099 }
9100 ANGLE_CAPTURE(SetFenceNV, isCallValid, context, fencePacked, condition);
9101 }
9102 else
9103 {
9104 GenerateContextLostErrorOnCurrentGlobalContext();
9105 }
9106 }
9107
GL_TestFenceNV(GLuint fence)9108 GLboolean GL_APIENTRY GL_TestFenceNV(GLuint fence)
9109 {
9110 Context *context = GetValidGlobalContext();
9111 EVENT(context, GLTestFenceNV, "context = %d, fence = %u", CID(context), fence);
9112
9113 GLboolean returnValue;
9114 if (context)
9115 {
9116 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
9117 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9118 bool isCallValid =
9119 (context->skipValidation() ||
9120 ValidateTestFenceNV(context, angle::EntryPoint::GLTestFenceNV, fencePacked));
9121 if (isCallValid)
9122 {
9123 returnValue = context->testFenceNV(fencePacked);
9124 }
9125 else
9126 {
9127 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>();
9128 }
9129 ANGLE_CAPTURE(TestFenceNV, isCallValid, context, fencePacked, returnValue);
9130 }
9131 else
9132 {
9133 GenerateContextLostErrorOnCurrentGlobalContext();
9134 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>();
9135 }
9136 return returnValue;
9137 }
9138
9139 // GL_NV_framebuffer_blit
GL_BlitFramebufferNV(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)9140 void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0,
9141 GLint srcY0,
9142 GLint srcX1,
9143 GLint srcY1,
9144 GLint dstX0,
9145 GLint dstY0,
9146 GLint dstX1,
9147 GLint dstY1,
9148 GLbitfield mask,
9149 GLenum filter)
9150 {
9151 Context *context = GetValidGlobalContext();
9152 EVENT(context, GLBlitFramebufferNV,
9153 "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
9154 "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
9155 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
9156 GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(),
9157 GLenumToString(GLenumGroup::BlitFramebufferFilter, filter));
9158
9159 if (context)
9160 {
9161 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9162 bool isCallValid = (context->skipValidation() ||
9163 ValidateBlitFramebufferNV(
9164 context, angle::EntryPoint::GLBlitFramebufferNV, srcX0, srcY0,
9165 srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
9166 if (isCallValid)
9167 {
9168 context->blitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
9169 filter);
9170 }
9171 ANGLE_CAPTURE(BlitFramebufferNV, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
9172 dstY0, dstX1, dstY1, mask, filter);
9173 }
9174 else
9175 {
9176 GenerateContextLostErrorOnCurrentGlobalContext();
9177 }
9178 }
9179
9180 // GL_NV_pixel_buffer_object
9181
9182 // GL_NV_read_depth
9183
9184 // GL_NV_read_stencil
9185
9186 // GL_NV_robustness_video_memory_purge
9187
9188 // GL_NV_shader_noperspective_interpolation
9189
9190 // GL_OES_EGL_image
GL_EGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image)9191 void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
9192 {
9193 Context *context = GetValidGlobalContext();
9194 EVENT(context, GLEGLImageTargetRenderbufferStorageOES,
9195 "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context),
9196 GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
9197
9198 if (context)
9199 {
9200 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9201 bool isCallValid = (context->skipValidation() ||
9202 ValidateEGLImageTargetRenderbufferStorageOES(
9203 context, angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES,
9204 target, image));
9205 if (isCallValid)
9206 {
9207 context->eGLImageTargetRenderbufferStorage(target, image);
9208 }
9209 ANGLE_CAPTURE(EGLImageTargetRenderbufferStorageOES, isCallValid, context, target, image);
9210 }
9211 else
9212 {
9213 GenerateContextLostErrorOnCurrentGlobalContext();
9214 }
9215 }
9216
GL_EGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image)9217 void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
9218 {
9219 Context *context = GetValidGlobalContext();
9220 EVENT(context, GLEGLImageTargetTexture2DOES,
9221 "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context),
9222 GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image);
9223
9224 if (context)
9225 {
9226 TextureType targetPacked = PackParam<TextureType>(target);
9227 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9228 bool isCallValid =
9229 (context->skipValidation() ||
9230 ValidateEGLImageTargetTexture2DOES(
9231 context, angle::EntryPoint::GLEGLImageTargetTexture2DOES, targetPacked, image));
9232 if (isCallValid)
9233 {
9234 context->eGLImageTargetTexture2D(targetPacked, image);
9235 }
9236 ANGLE_CAPTURE(EGLImageTargetTexture2DOES, isCallValid, context, targetPacked, image);
9237 }
9238 else
9239 {
9240 GenerateContextLostErrorOnCurrentGlobalContext();
9241 }
9242 }
9243
9244 // GL_OES_EGL_image_external
9245
9246 // GL_OES_EGL_image_external_essl3
9247
9248 // GL_OES_compressed_ETC1_RGB8_texture
9249
9250 // GL_OES_copy_image
GL_CopyImageSubDataOES(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)9251 void GL_APIENTRY GL_CopyImageSubDataOES(GLuint srcName,
9252 GLenum srcTarget,
9253 GLint srcLevel,
9254 GLint srcX,
9255 GLint srcY,
9256 GLint srcZ,
9257 GLuint dstName,
9258 GLenum dstTarget,
9259 GLint dstLevel,
9260 GLint dstX,
9261 GLint dstY,
9262 GLint dstZ,
9263 GLsizei srcWidth,
9264 GLsizei srcHeight,
9265 GLsizei srcDepth)
9266 {
9267 Context *context = GetValidGlobalContext();
9268 EVENT(context, GLCopyImageSubDataOES,
9269 "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = "
9270 "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, "
9271 "srcWidth = %d, srcHeight = %d, srcDepth = %d",
9272 CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget),
9273 srcLevel, srcX, srcY, srcZ, dstName,
9274 GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY,
9275 dstZ, srcWidth, srcHeight, srcDepth);
9276
9277 if (context)
9278 {
9279 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9280 bool isCallValid = (context->skipValidation() ||
9281 ValidateCopyImageSubDataOES(
9282 context, angle::EntryPoint::GLCopyImageSubDataOES, srcName,
9283 srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel,
9284 dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth));
9285 if (isCallValid)
9286 {
9287 context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
9288 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
9289 srcDepth);
9290 }
9291 ANGLE_CAPTURE(CopyImageSubDataOES, isCallValid, context, srcName, srcTarget, srcLevel, srcX,
9292 srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
9293 srcHeight, srcDepth);
9294 }
9295 else
9296 {
9297 GenerateContextLostErrorOnCurrentGlobalContext();
9298 }
9299 }
9300
9301 // GL_OES_depth24
9302
9303 // GL_OES_depth32
9304
9305 // GL_OES_depth_texture
9306
9307 // GL_OES_draw_buffers_indexed
GL_BlendEquationSeparateiOES(GLuint buf,GLenum modeRGB,GLenum modeAlpha)9308 void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
9309 {
9310 Context *context = GetValidGlobalContext();
9311 EVENT(context, GLBlendEquationSeparateiOES,
9312 "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf,
9313 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
9314 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
9315
9316 if (context)
9317 {
9318 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9319 bool isCallValid =
9320 (context->skipValidation() ||
9321 ValidateBlendEquationSeparateiOES(
9322 context, angle::EntryPoint::GLBlendEquationSeparateiOES, buf, modeRGB, modeAlpha));
9323 if (isCallValid)
9324 {
9325 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
9326 }
9327 ANGLE_CAPTURE(BlendEquationSeparateiOES, isCallValid, context, buf, modeRGB, modeAlpha);
9328 }
9329 else
9330 {
9331 GenerateContextLostErrorOnCurrentGlobalContext();
9332 }
9333 }
9334
GL_BlendEquationiOES(GLuint buf,GLenum mode)9335 void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode)
9336 {
9337 Context *context = GetValidGlobalContext();
9338 EVENT(context, GLBlendEquationiOES, "context = %d, buf = %u, mode = %s", CID(context), buf,
9339 GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
9340
9341 if (context)
9342 {
9343 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9344 bool isCallValid =
9345 (context->skipValidation() ||
9346 ValidateBlendEquationiOES(context, angle::EntryPoint::GLBlendEquationiOES, buf, mode));
9347 if (isCallValid)
9348 {
9349 context->blendEquationi(buf, mode);
9350 }
9351 ANGLE_CAPTURE(BlendEquationiOES, isCallValid, context, buf, mode);
9352 }
9353 else
9354 {
9355 GenerateContextLostErrorOnCurrentGlobalContext();
9356 }
9357 }
9358
9359 void GL_APIENTRY
GL_BlendFuncSeparateiOES(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)9360 GL_BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
9361 {
9362 Context *context = GetValidGlobalContext();
9363 EVENT(context, GLBlendFuncSeparateiOES,
9364 "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s",
9365 CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
9366 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
9367 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
9368 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
9369
9370 if (context)
9371 {
9372 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9373 bool isCallValid =
9374 (context->skipValidation() ||
9375 ValidateBlendFuncSeparateiOES(context, angle::EntryPoint::GLBlendFuncSeparateiOES, buf,
9376 srcRGB, dstRGB, srcAlpha, dstAlpha));
9377 if (isCallValid)
9378 {
9379 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
9380 }
9381 ANGLE_CAPTURE(BlendFuncSeparateiOES, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
9382 dstAlpha);
9383 }
9384 else
9385 {
9386 GenerateContextLostErrorOnCurrentGlobalContext();
9387 }
9388 }
9389
GL_BlendFunciOES(GLuint buf,GLenum src,GLenum dst)9390 void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst)
9391 {
9392 Context *context = GetValidGlobalContext();
9393 EVENT(context, GLBlendFunciOES, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf,
9394 GLenumToString(GLenumGroup::BlendingFactor, src),
9395 GLenumToString(GLenumGroup::BlendingFactor, dst));
9396
9397 if (context)
9398 {
9399 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9400 bool isCallValid =
9401 (context->skipValidation() ||
9402 ValidateBlendFunciOES(context, angle::EntryPoint::GLBlendFunciOES, buf, src, dst));
9403 if (isCallValid)
9404 {
9405 context->blendFunci(buf, src, dst);
9406 }
9407 ANGLE_CAPTURE(BlendFunciOES, isCallValid, context, buf, src, dst);
9408 }
9409 else
9410 {
9411 GenerateContextLostErrorOnCurrentGlobalContext();
9412 }
9413 }
9414
GL_ColorMaskiOES(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)9415 void GL_APIENTRY GL_ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
9416 {
9417 Context *context = GetValidGlobalContext();
9418 EVENT(context, GLColorMaskiOES, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s",
9419 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
9420 GLbooleanToString(a));
9421
9422 if (context)
9423 {
9424 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9425 bool isCallValid =
9426 (context->skipValidation() ||
9427 ValidateColorMaskiOES(context, angle::EntryPoint::GLColorMaskiOES, index, r, g, b, a));
9428 if (isCallValid)
9429 {
9430 context->colorMaski(index, r, g, b, a);
9431 }
9432 ANGLE_CAPTURE(ColorMaskiOES, isCallValid, context, index, r, g, b, a);
9433 }
9434 else
9435 {
9436 GenerateContextLostErrorOnCurrentGlobalContext();
9437 }
9438 }
9439
GL_DisableiOES(GLenum target,GLuint index)9440 void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index)
9441 {
9442 Context *context = GetValidGlobalContext();
9443 EVENT(context, GLDisableiOES, "context = %d, target = %s, index = %u", CID(context),
9444 GLenumToString(GLenumGroup::EnableCap, target), index);
9445
9446 if (context)
9447 {
9448 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9449 bool isCallValid =
9450 (context->skipValidation() ||
9451 ValidateDisableiOES(context, angle::EntryPoint::GLDisableiOES, target, index));
9452 if (isCallValid)
9453 {
9454 context->disablei(target, index);
9455 }
9456 ANGLE_CAPTURE(DisableiOES, isCallValid, context, target, index);
9457 }
9458 else
9459 {
9460 GenerateContextLostErrorOnCurrentGlobalContext();
9461 }
9462 }
9463
GL_EnableiOES(GLenum target,GLuint index)9464 void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index)
9465 {
9466 Context *context = GetValidGlobalContext();
9467 EVENT(context, GLEnableiOES, "context = %d, target = %s, index = %u", CID(context),
9468 GLenumToString(GLenumGroup::EnableCap, target), index);
9469
9470 if (context)
9471 {
9472 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9473 bool isCallValid =
9474 (context->skipValidation() ||
9475 ValidateEnableiOES(context, angle::EntryPoint::GLEnableiOES, target, index));
9476 if (isCallValid)
9477 {
9478 context->enablei(target, index);
9479 }
9480 ANGLE_CAPTURE(EnableiOES, isCallValid, context, target, index);
9481 }
9482 else
9483 {
9484 GenerateContextLostErrorOnCurrentGlobalContext();
9485 }
9486 }
9487
GL_IsEnablediOES(GLenum target,GLuint index)9488 GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index)
9489 {
9490 Context *context = GetValidGlobalContext();
9491 EVENT(context, GLIsEnablediOES, "context = %d, target = %s, index = %u", CID(context),
9492 GLenumToString(GLenumGroup::EnableCap, target), index);
9493
9494 GLboolean returnValue;
9495 if (context)
9496 {
9497 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9498 bool isCallValid =
9499 (context->skipValidation() ||
9500 ValidateIsEnablediOES(context, angle::EntryPoint::GLIsEnablediOES, target, index));
9501 if (isCallValid)
9502 {
9503 returnValue = context->isEnabledi(target, index);
9504 }
9505 else
9506 {
9507 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>();
9508 }
9509 ANGLE_CAPTURE(IsEnablediOES, isCallValid, context, target, index, returnValue);
9510 }
9511 else
9512 {
9513 GenerateContextLostErrorOnCurrentGlobalContext();
9514 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>();
9515 }
9516 return returnValue;
9517 }
9518
9519 // GL_OES_draw_elements_base_vertex
GL_DrawElementsBaseVertexOES(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)9520 void GL_APIENTRY GL_DrawElementsBaseVertexOES(GLenum mode,
9521 GLsizei count,
9522 GLenum type,
9523 const void *indices,
9524 GLint basevertex)
9525 {
9526 Context *context = GetValidGlobalContext();
9527 EVENT(context, GLDrawElementsBaseVertexOES,
9528 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
9529 ", basevertex = %d",
9530 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
9531 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
9532
9533 if (context)
9534 {
9535 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
9536 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
9537 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9538 bool isCallValid = (context->skipValidation() ||
9539 ValidateDrawElementsBaseVertexOES(
9540 context, angle::EntryPoint::GLDrawElementsBaseVertexOES, modePacked,
9541 count, typePacked, indices, basevertex));
9542 if (isCallValid)
9543 {
9544 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
9545 }
9546 ANGLE_CAPTURE(DrawElementsBaseVertexOES, isCallValid, context, modePacked, count,
9547 typePacked, indices, basevertex);
9548 }
9549 else
9550 {
9551 GenerateContextLostErrorOnCurrentGlobalContext();
9552 }
9553 }
9554
GL_DrawElementsInstancedBaseVertexOES(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)9555 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexOES(GLenum mode,
9556 GLsizei count,
9557 GLenum type,
9558 const void *indices,
9559 GLsizei instancecount,
9560 GLint basevertex)
9561 {
9562 Context *context = GetValidGlobalContext();
9563 EVENT(context, GLDrawElementsInstancedBaseVertexOES,
9564 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
9565 ", instancecount = %d, basevertex = %d",
9566 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
9567 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
9568 basevertex);
9569
9570 if (context)
9571 {
9572 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
9573 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
9574 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9575 bool isCallValid = (context->skipValidation() ||
9576 ValidateDrawElementsInstancedBaseVertexOES(
9577 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexOES,
9578 modePacked, count, typePacked, indices, instancecount, basevertex));
9579 if (isCallValid)
9580 {
9581 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
9582 instancecount, basevertex);
9583 }
9584 ANGLE_CAPTURE(DrawElementsInstancedBaseVertexOES, isCallValid, context, modePacked, count,
9585 typePacked, indices, instancecount, basevertex);
9586 }
9587 else
9588 {
9589 GenerateContextLostErrorOnCurrentGlobalContext();
9590 }
9591 }
9592
GL_DrawRangeElementsBaseVertexOES(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)9593 void GL_APIENTRY GL_DrawRangeElementsBaseVertexOES(GLenum mode,
9594 GLuint start,
9595 GLuint end,
9596 GLsizei count,
9597 GLenum type,
9598 const void *indices,
9599 GLint basevertex)
9600 {
9601 Context *context = GetValidGlobalContext();
9602 EVENT(context, GLDrawRangeElementsBaseVertexOES,
9603 "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
9604 "0x%016" PRIxPTR ", basevertex = %d",
9605 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
9606 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
9607
9608 if (context)
9609 {
9610 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
9611 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
9612 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9613 bool isCallValid = (context->skipValidation() ||
9614 ValidateDrawRangeElementsBaseVertexOES(
9615 context, angle::EntryPoint::GLDrawRangeElementsBaseVertexOES,
9616 modePacked, start, end, count, typePacked, indices, basevertex));
9617 if (isCallValid)
9618 {
9619 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
9620 basevertex);
9621 }
9622 ANGLE_CAPTURE(DrawRangeElementsBaseVertexOES, isCallValid, context, modePacked, start, end,
9623 count, typePacked, indices, basevertex);
9624 }
9625 else
9626 {
9627 GenerateContextLostErrorOnCurrentGlobalContext();
9628 }
9629 }
9630
9631 // MultiDrawElementsBaseVertexEXT is already defined.
9632
9633 // GL_OES_draw_texture
GL_DrawTexfOES(GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)9634 void GL_APIENTRY GL_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
9635 {
9636 Context *context = GetValidGlobalContext();
9637 EVENT(context, GLDrawTexfOES, "context = %d, x = %f, y = %f, z = %f, width = %f, height = %f",
9638 CID(context), x, y, z, width, height);
9639
9640 if (context)
9641 {
9642 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9643 bool isCallValid = (context->skipValidation() ||
9644 ValidateDrawTexfOES(context, angle::EntryPoint::GLDrawTexfOES, x, y, z,
9645 width, height));
9646 if (isCallValid)
9647 {
9648 context->drawTexf(x, y, z, width, height);
9649 }
9650 ANGLE_CAPTURE(DrawTexfOES, isCallValid, context, x, y, z, width, height);
9651 }
9652 else
9653 {
9654 GenerateContextLostErrorOnCurrentGlobalContext();
9655 }
9656 }
9657
GL_DrawTexfvOES(const GLfloat * coords)9658 void GL_APIENTRY GL_DrawTexfvOES(const GLfloat *coords)
9659 {
9660 Context *context = GetValidGlobalContext();
9661 EVENT(context, GLDrawTexfvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
9662 (uintptr_t)coords);
9663
9664 if (context)
9665 {
9666 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9667 bool isCallValid =
9668 (context->skipValidation() ||
9669 ValidateDrawTexfvOES(context, angle::EntryPoint::GLDrawTexfvOES, coords));
9670 if (isCallValid)
9671 {
9672 context->drawTexfv(coords);
9673 }
9674 ANGLE_CAPTURE(DrawTexfvOES, isCallValid, context, coords);
9675 }
9676 else
9677 {
9678 GenerateContextLostErrorOnCurrentGlobalContext();
9679 }
9680 }
9681
GL_DrawTexiOES(GLint x,GLint y,GLint z,GLint width,GLint height)9682 void GL_APIENTRY GL_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
9683 {
9684 Context *context = GetValidGlobalContext();
9685 EVENT(context, GLDrawTexiOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d",
9686 CID(context), x, y, z, width, height);
9687
9688 if (context)
9689 {
9690 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9691 bool isCallValid = (context->skipValidation() ||
9692 ValidateDrawTexiOES(context, angle::EntryPoint::GLDrawTexiOES, x, y, z,
9693 width, height));
9694 if (isCallValid)
9695 {
9696 context->drawTexi(x, y, z, width, height);
9697 }
9698 ANGLE_CAPTURE(DrawTexiOES, isCallValid, context, x, y, z, width, height);
9699 }
9700 else
9701 {
9702 GenerateContextLostErrorOnCurrentGlobalContext();
9703 }
9704 }
9705
GL_DrawTexivOES(const GLint * coords)9706 void GL_APIENTRY GL_DrawTexivOES(const GLint *coords)
9707 {
9708 Context *context = GetValidGlobalContext();
9709 EVENT(context, GLDrawTexivOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
9710 (uintptr_t)coords);
9711
9712 if (context)
9713 {
9714 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9715 bool isCallValid =
9716 (context->skipValidation() ||
9717 ValidateDrawTexivOES(context, angle::EntryPoint::GLDrawTexivOES, coords));
9718 if (isCallValid)
9719 {
9720 context->drawTexiv(coords);
9721 }
9722 ANGLE_CAPTURE(DrawTexivOES, isCallValid, context, coords);
9723 }
9724 else
9725 {
9726 GenerateContextLostErrorOnCurrentGlobalContext();
9727 }
9728 }
9729
GL_DrawTexsOES(GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)9730 void GL_APIENTRY GL_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
9731 {
9732 Context *context = GetValidGlobalContext();
9733 EVENT(context, GLDrawTexsOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d",
9734 CID(context), x, y, z, width, height);
9735
9736 if (context)
9737 {
9738 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9739 bool isCallValid = (context->skipValidation() ||
9740 ValidateDrawTexsOES(context, angle::EntryPoint::GLDrawTexsOES, x, y, z,
9741 width, height));
9742 if (isCallValid)
9743 {
9744 context->drawTexs(x, y, z, width, height);
9745 }
9746 ANGLE_CAPTURE(DrawTexsOES, isCallValid, context, x, y, z, width, height);
9747 }
9748 else
9749 {
9750 GenerateContextLostErrorOnCurrentGlobalContext();
9751 }
9752 }
9753
GL_DrawTexsvOES(const GLshort * coords)9754 void GL_APIENTRY GL_DrawTexsvOES(const GLshort *coords)
9755 {
9756 Context *context = GetValidGlobalContext();
9757 EVENT(context, GLDrawTexsvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
9758 (uintptr_t)coords);
9759
9760 if (context)
9761 {
9762 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9763 bool isCallValid =
9764 (context->skipValidation() ||
9765 ValidateDrawTexsvOES(context, angle::EntryPoint::GLDrawTexsvOES, coords));
9766 if (isCallValid)
9767 {
9768 context->drawTexsv(coords);
9769 }
9770 ANGLE_CAPTURE(DrawTexsvOES, isCallValid, context, coords);
9771 }
9772 else
9773 {
9774 GenerateContextLostErrorOnCurrentGlobalContext();
9775 }
9776 }
9777
GL_DrawTexxOES(GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)9778 void GL_APIENTRY GL_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
9779 {
9780 Context *context = GetValidGlobalContext();
9781 EVENT(context, GLDrawTexxOES,
9782 "context = %d, x = 0x%X, y = 0x%X, z = 0x%X, width = 0x%X, height = 0x%X", CID(context),
9783 x, y, z, width, height);
9784
9785 if (context)
9786 {
9787 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9788 bool isCallValid = (context->skipValidation() ||
9789 ValidateDrawTexxOES(context, angle::EntryPoint::GLDrawTexxOES, x, y, z,
9790 width, height));
9791 if (isCallValid)
9792 {
9793 context->drawTexx(x, y, z, width, height);
9794 }
9795 ANGLE_CAPTURE(DrawTexxOES, isCallValid, context, x, y, z, width, height);
9796 }
9797 else
9798 {
9799 GenerateContextLostErrorOnCurrentGlobalContext();
9800 }
9801 }
9802
GL_DrawTexxvOES(const GLfixed * coords)9803 void GL_APIENTRY GL_DrawTexxvOES(const GLfixed *coords)
9804 {
9805 Context *context = GetValidGlobalContext();
9806 EVENT(context, GLDrawTexxvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
9807 (uintptr_t)coords);
9808
9809 if (context)
9810 {
9811 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9812 bool isCallValid =
9813 (context->skipValidation() ||
9814 ValidateDrawTexxvOES(context, angle::EntryPoint::GLDrawTexxvOES, coords));
9815 if (isCallValid)
9816 {
9817 context->drawTexxv(coords);
9818 }
9819 ANGLE_CAPTURE(DrawTexxvOES, isCallValid, context, coords);
9820 }
9821 else
9822 {
9823 GenerateContextLostErrorOnCurrentGlobalContext();
9824 }
9825 }
9826
9827 // GL_OES_element_index_uint
9828
9829 // GL_OES_fbo_render_mipmap
9830
9831 // GL_OES_framebuffer_object
GL_BindFramebufferOES(GLenum target,GLuint framebuffer)9832 void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer)
9833 {
9834 Context *context = GetValidGlobalContext();
9835 EVENT(context, GLBindFramebufferOES, "context = %d, target = %s, framebuffer = %u",
9836 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer);
9837
9838 if (context)
9839 {
9840 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
9841 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9842 bool isCallValid =
9843 (context->skipValidation() ||
9844 ValidateBindFramebufferOES(context, angle::EntryPoint::GLBindFramebufferOES, target,
9845 framebufferPacked));
9846 if (isCallValid)
9847 {
9848 context->bindFramebuffer(target, framebufferPacked);
9849 }
9850 ANGLE_CAPTURE(BindFramebufferOES, isCallValid, context, target, framebufferPacked);
9851 }
9852 else
9853 {
9854 GenerateContextLostErrorOnCurrentGlobalContext();
9855 }
9856 }
9857
GL_BindRenderbufferOES(GLenum target,GLuint renderbuffer)9858 void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer)
9859 {
9860 Context *context = GetValidGlobalContext();
9861 EVENT(context, GLBindRenderbufferOES, "context = %d, target = %s, renderbuffer = %u",
9862 CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer);
9863
9864 if (context)
9865 {
9866 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
9867 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9868 bool isCallValid =
9869 (context->skipValidation() ||
9870 ValidateBindRenderbufferOES(context, angle::EntryPoint::GLBindRenderbufferOES, target,
9871 renderbufferPacked));
9872 if (isCallValid)
9873 {
9874 context->bindRenderbuffer(target, renderbufferPacked);
9875 }
9876 ANGLE_CAPTURE(BindRenderbufferOES, isCallValid, context, target, renderbufferPacked);
9877 }
9878 else
9879 {
9880 GenerateContextLostErrorOnCurrentGlobalContext();
9881 }
9882 }
9883
GL_CheckFramebufferStatusOES(GLenum target)9884 GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target)
9885 {
9886 Context *context = GetValidGlobalContext();
9887 EVENT(context, GLCheckFramebufferStatusOES, "context = %d, target = %s", CID(context),
9888 GLenumToString(GLenumGroup::FramebufferTarget, target));
9889
9890 GLenum returnValue;
9891 if (context)
9892 {
9893 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9894 bool isCallValid = (context->skipValidation() ||
9895 ValidateCheckFramebufferStatusOES(
9896 context, angle::EntryPoint::GLCheckFramebufferStatusOES, target));
9897 if (isCallValid)
9898 {
9899 returnValue = context->checkFramebufferStatus(target);
9900 }
9901 else
9902 {
9903 returnValue =
9904 GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>();
9905 }
9906 ANGLE_CAPTURE(CheckFramebufferStatusOES, isCallValid, context, target, returnValue);
9907 }
9908 else
9909 {
9910 GenerateContextLostErrorOnCurrentGlobalContext();
9911 returnValue =
9912 GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>();
9913 }
9914 return returnValue;
9915 }
9916
GL_DeleteFramebuffersOES(GLsizei n,const GLuint * framebuffers)9917 void GL_APIENTRY GL_DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
9918 {
9919 Context *context = GetValidGlobalContext();
9920 EVENT(context, GLDeleteFramebuffersOES,
9921 "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "", CID(context), n,
9922 (uintptr_t)framebuffers);
9923
9924 if (context)
9925 {
9926 const FramebufferID *framebuffersPacked = PackParam<const FramebufferID *>(framebuffers);
9927 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9928 bool isCallValid =
9929 (context->skipValidation() ||
9930 ValidateDeleteFramebuffersOES(context, angle::EntryPoint::GLDeleteFramebuffersOES, n,
9931 framebuffersPacked));
9932 if (isCallValid)
9933 {
9934 context->deleteFramebuffers(n, framebuffersPacked);
9935 }
9936 ANGLE_CAPTURE(DeleteFramebuffersOES, isCallValid, context, n, framebuffersPacked);
9937 }
9938 else
9939 {
9940 GenerateContextLostErrorOnCurrentGlobalContext();
9941 }
9942 }
9943
GL_DeleteRenderbuffersOES(GLsizei n,const GLuint * renderbuffers)9944 void GL_APIENTRY GL_DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
9945 {
9946 Context *context = GetValidGlobalContext();
9947 EVENT(context, GLDeleteRenderbuffersOES,
9948 "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "", CID(context), n,
9949 (uintptr_t)renderbuffers);
9950
9951 if (context)
9952 {
9953 const RenderbufferID *renderbuffersPacked =
9954 PackParam<const RenderbufferID *>(renderbuffers);
9955 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9956 bool isCallValid =
9957 (context->skipValidation() ||
9958 ValidateDeleteRenderbuffersOES(context, angle::EntryPoint::GLDeleteRenderbuffersOES, n,
9959 renderbuffersPacked));
9960 if (isCallValid)
9961 {
9962 context->deleteRenderbuffers(n, renderbuffersPacked);
9963 }
9964 ANGLE_CAPTURE(DeleteRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
9965 }
9966 else
9967 {
9968 GenerateContextLostErrorOnCurrentGlobalContext();
9969 }
9970 }
9971
GL_FramebufferRenderbufferOES(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)9972 void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target,
9973 GLenum attachment,
9974 GLenum renderbuffertarget,
9975 GLuint renderbuffer)
9976 {
9977 Context *context = GetValidGlobalContext();
9978 EVENT(context, GLFramebufferRenderbufferOES,
9979 "context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u",
9980 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
9981 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
9982 GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer);
9983
9984 if (context)
9985 {
9986 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
9987 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
9988 bool isCallValid = (context->skipValidation() ||
9989 ValidateFramebufferRenderbufferOES(
9990 context, angle::EntryPoint::GLFramebufferRenderbufferOES, target,
9991 attachment, renderbuffertarget, renderbufferPacked));
9992 if (isCallValid)
9993 {
9994 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
9995 renderbufferPacked);
9996 }
9997 ANGLE_CAPTURE(FramebufferRenderbufferOES, isCallValid, context, target, attachment,
9998 renderbuffertarget, renderbufferPacked);
9999 }
10000 else
10001 {
10002 GenerateContextLostErrorOnCurrentGlobalContext();
10003 }
10004 }
10005
GL_FramebufferTexture2DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)10006 void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target,
10007 GLenum attachment,
10008 GLenum textarget,
10009 GLuint texture,
10010 GLint level)
10011 {
10012 Context *context = GetValidGlobalContext();
10013 EVENT(context, GLFramebufferTexture2DOES,
10014 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
10015 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
10016 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
10017 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level);
10018
10019 if (context)
10020 {
10021 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
10022 TextureID texturePacked = PackParam<TextureID>(texture);
10023 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10024 bool isCallValid = (context->skipValidation() ||
10025 ValidateFramebufferTexture2DOES(
10026 context, angle::EntryPoint::GLFramebufferTexture2DOES, target,
10027 attachment, textargetPacked, texturePacked, level));
10028 if (isCallValid)
10029 {
10030 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
10031 level);
10032 }
10033 ANGLE_CAPTURE(FramebufferTexture2DOES, isCallValid, context, target, attachment,
10034 textargetPacked, texturePacked, level);
10035 }
10036 else
10037 {
10038 GenerateContextLostErrorOnCurrentGlobalContext();
10039 }
10040 }
10041
GL_GenFramebuffersOES(GLsizei n,GLuint * framebuffers)10042 void GL_APIENTRY GL_GenFramebuffersOES(GLsizei n, GLuint *framebuffers)
10043 {
10044 Context *context = GetValidGlobalContext();
10045 EVENT(context, GLGenFramebuffersOES, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
10046 CID(context), n, (uintptr_t)framebuffers);
10047
10048 if (context)
10049 {
10050 FramebufferID *framebuffersPacked = PackParam<FramebufferID *>(framebuffers);
10051 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10052 bool isCallValid =
10053 (context->skipValidation() ||
10054 ValidateGenFramebuffersOES(context, angle::EntryPoint::GLGenFramebuffersOES, n,
10055 framebuffersPacked));
10056 if (isCallValid)
10057 {
10058 context->genFramebuffers(n, framebuffersPacked);
10059 }
10060 ANGLE_CAPTURE(GenFramebuffersOES, isCallValid, context, n, framebuffersPacked);
10061 }
10062 else
10063 {
10064 GenerateContextLostErrorOnCurrentGlobalContext();
10065 }
10066 }
10067
GL_GenRenderbuffersOES(GLsizei n,GLuint * renderbuffers)10068 void GL_APIENTRY GL_GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
10069 {
10070 Context *context = GetValidGlobalContext();
10071 EVENT(context, GLGenRenderbuffersOES, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
10072 CID(context), n, (uintptr_t)renderbuffers);
10073
10074 if (context)
10075 {
10076 RenderbufferID *renderbuffersPacked = PackParam<RenderbufferID *>(renderbuffers);
10077 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10078 bool isCallValid =
10079 (context->skipValidation() ||
10080 ValidateGenRenderbuffersOES(context, angle::EntryPoint::GLGenRenderbuffersOES, n,
10081 renderbuffersPacked));
10082 if (isCallValid)
10083 {
10084 context->genRenderbuffers(n, renderbuffersPacked);
10085 }
10086 ANGLE_CAPTURE(GenRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
10087 }
10088 else
10089 {
10090 GenerateContextLostErrorOnCurrentGlobalContext();
10091 }
10092 }
10093
GL_GenerateMipmapOES(GLenum target)10094 void GL_APIENTRY GL_GenerateMipmapOES(GLenum target)
10095 {
10096 Context *context = GetValidGlobalContext();
10097 EVENT(context, GLGenerateMipmapOES, "context = %d, target = %s", CID(context),
10098 GLenumToString(GLenumGroup::TextureTarget, target));
10099
10100 if (context)
10101 {
10102 TextureType targetPacked = PackParam<TextureType>(target);
10103 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10104 bool isCallValid = (context->skipValidation() ||
10105 ValidateGenerateMipmapOES(
10106 context, angle::EntryPoint::GLGenerateMipmapOES, targetPacked));
10107 if (isCallValid)
10108 {
10109 context->generateMipmap(targetPacked);
10110 }
10111 ANGLE_CAPTURE(GenerateMipmapOES, isCallValid, context, targetPacked);
10112 }
10113 else
10114 {
10115 GenerateContextLostErrorOnCurrentGlobalContext();
10116 }
10117 }
10118
GL_GetFramebufferAttachmentParameterivOES(GLenum target,GLenum attachment,GLenum pname,GLint * params)10119 void GL_APIENTRY GL_GetFramebufferAttachmentParameterivOES(GLenum target,
10120 GLenum attachment,
10121 GLenum pname,
10122 GLint *params)
10123 {
10124 Context *context = GetValidGlobalContext();
10125 EVENT(context, GLGetFramebufferAttachmentParameterivOES,
10126 "context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "",
10127 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
10128 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
10129 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
10130 (uintptr_t)params);
10131
10132 if (context)
10133 {
10134 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10135 bool isCallValid =
10136 (context->skipValidation() ||
10137 ValidateGetFramebufferAttachmentParameterivOES(
10138 context, angle::EntryPoint::GLGetFramebufferAttachmentParameterivOES, target,
10139 attachment, pname, params));
10140 if (isCallValid)
10141 {
10142 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
10143 }
10144 ANGLE_CAPTURE(GetFramebufferAttachmentParameterivOES, isCallValid, context, target,
10145 attachment, pname, params);
10146 }
10147 else
10148 {
10149 GenerateContextLostErrorOnCurrentGlobalContext();
10150 }
10151 }
10152
GL_GetRenderbufferParameterivOES(GLenum target,GLenum pname,GLint * params)10153 void GL_APIENTRY GL_GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
10154 {
10155 Context *context = GetValidGlobalContext();
10156 EVENT(context, GLGetRenderbufferParameterivOES,
10157 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10158 GLenumToString(GLenumGroup::RenderbufferTarget, target),
10159 GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params);
10160
10161 if (context)
10162 {
10163 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10164 bool isCallValid = (context->skipValidation() ||
10165 ValidateGetRenderbufferParameterivOES(
10166 context, angle::EntryPoint::GLGetRenderbufferParameterivOES, target,
10167 pname, params));
10168 if (isCallValid)
10169 {
10170 context->getRenderbufferParameteriv(target, pname, params);
10171 }
10172 ANGLE_CAPTURE(GetRenderbufferParameterivOES, isCallValid, context, target, pname, params);
10173 }
10174 else
10175 {
10176 GenerateContextLostErrorOnCurrentGlobalContext();
10177 }
10178 }
10179
GL_IsFramebufferOES(GLuint framebuffer)10180 GLboolean GL_APIENTRY GL_IsFramebufferOES(GLuint framebuffer)
10181 {
10182 Context *context = GetValidGlobalContext();
10183 EVENT(context, GLIsFramebufferOES, "context = %d, framebuffer = %u", CID(context), framebuffer);
10184
10185 GLboolean returnValue;
10186 if (context)
10187 {
10188 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
10189 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10190 bool isCallValid = (context->skipValidation() ||
10191 ValidateIsFramebufferOES(context, angle::EntryPoint::GLIsFramebufferOES,
10192 framebufferPacked));
10193 if (isCallValid)
10194 {
10195 returnValue = context->isFramebuffer(framebufferPacked);
10196 }
10197 else
10198 {
10199 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>();
10200 }
10201 ANGLE_CAPTURE(IsFramebufferOES, isCallValid, context, framebufferPacked, returnValue);
10202 }
10203 else
10204 {
10205 GenerateContextLostErrorOnCurrentGlobalContext();
10206 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>();
10207 }
10208 return returnValue;
10209 }
10210
GL_IsRenderbufferOES(GLuint renderbuffer)10211 GLboolean GL_APIENTRY GL_IsRenderbufferOES(GLuint renderbuffer)
10212 {
10213 Context *context = GetValidGlobalContext();
10214 EVENT(context, GLIsRenderbufferOES, "context = %d, renderbuffer = %u", CID(context),
10215 renderbuffer);
10216
10217 GLboolean returnValue;
10218 if (context)
10219 {
10220 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
10221 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10222 bool isCallValid =
10223 (context->skipValidation() ||
10224 ValidateIsRenderbufferOES(context, angle::EntryPoint::GLIsRenderbufferOES,
10225 renderbufferPacked));
10226 if (isCallValid)
10227 {
10228 returnValue = context->isRenderbuffer(renderbufferPacked);
10229 }
10230 else
10231 {
10232 returnValue =
10233 GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>();
10234 }
10235 ANGLE_CAPTURE(IsRenderbufferOES, isCallValid, context, renderbufferPacked, returnValue);
10236 }
10237 else
10238 {
10239 GenerateContextLostErrorOnCurrentGlobalContext();
10240 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>();
10241 }
10242 return returnValue;
10243 }
10244
GL_RenderbufferStorageOES(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)10245 void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target,
10246 GLenum internalformat,
10247 GLsizei width,
10248 GLsizei height)
10249 {
10250 Context *context = GetValidGlobalContext();
10251 EVENT(context, GLRenderbufferStorageOES,
10252 "context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context),
10253 GLenumToString(GLenumGroup::RenderbufferTarget, target),
10254 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height);
10255
10256 if (context)
10257 {
10258 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10259 bool isCallValid =
10260 (context->skipValidation() ||
10261 ValidateRenderbufferStorageOES(context, angle::EntryPoint::GLRenderbufferStorageOES,
10262 target, internalformat, width, height));
10263 if (isCallValid)
10264 {
10265 context->renderbufferStorage(target, internalformat, width, height);
10266 }
10267 ANGLE_CAPTURE(RenderbufferStorageOES, isCallValid, context, target, internalformat, width,
10268 height);
10269 }
10270 else
10271 {
10272 GenerateContextLostErrorOnCurrentGlobalContext();
10273 }
10274 }
10275
10276 // GL_OES_geometry_shader
GL_FramebufferTextureOES(GLenum target,GLenum attachment,GLuint texture,GLint level)10277 void GL_APIENTRY GL_FramebufferTextureOES(GLenum target,
10278 GLenum attachment,
10279 GLuint texture,
10280 GLint level)
10281 {
10282 Context *context = GetValidGlobalContext();
10283 EVENT(context, GLFramebufferTextureOES,
10284 "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context),
10285 GLenumToString(GLenumGroup::FramebufferTarget, target),
10286 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
10287
10288 if (context)
10289 {
10290 TextureID texturePacked = PackParam<TextureID>(texture);
10291 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10292 bool isCallValid =
10293 (context->skipValidation() ||
10294 ValidateFramebufferTextureOES(context, angle::EntryPoint::GLFramebufferTextureOES,
10295 target, attachment, texturePacked, level));
10296 if (isCallValid)
10297 {
10298 context->framebufferTexture(target, attachment, texturePacked, level);
10299 }
10300 ANGLE_CAPTURE(FramebufferTextureOES, isCallValid, context, target, attachment,
10301 texturePacked, level);
10302 }
10303 else
10304 {
10305 GenerateContextLostErrorOnCurrentGlobalContext();
10306 }
10307 }
10308
10309 // GL_OES_get_program_binary
GL_GetProgramBinaryOES(GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)10310 void GL_APIENTRY GL_GetProgramBinaryOES(GLuint program,
10311 GLsizei bufSize,
10312 GLsizei *length,
10313 GLenum *binaryFormat,
10314 void *binary)
10315 {
10316 Context *context = GetValidGlobalContext();
10317 EVENT(context, GLGetProgramBinaryOES,
10318 "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
10319 ", binaryFormat = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR "",
10320 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
10321 (uintptr_t)binary);
10322
10323 if (context)
10324 {
10325 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
10326 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10327 bool isCallValid =
10328 (context->skipValidation() ||
10329 ValidateGetProgramBinaryOES(context, angle::EntryPoint::GLGetProgramBinaryOES,
10330 programPacked, bufSize, length, binaryFormat, binary));
10331 if (isCallValid)
10332 {
10333 context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
10334 }
10335 ANGLE_CAPTURE(GetProgramBinaryOES, isCallValid, context, programPacked, bufSize, length,
10336 binaryFormat, binary);
10337 }
10338 else
10339 {
10340 GenerateContextLostErrorOnCurrentGlobalContext();
10341 }
10342 }
10343
GL_ProgramBinaryOES(GLuint program,GLenum binaryFormat,const void * binary,GLint length)10344 void GL_APIENTRY GL_ProgramBinaryOES(GLuint program,
10345 GLenum binaryFormat,
10346 const void *binary,
10347 GLint length)
10348 {
10349 Context *context = GetValidGlobalContext();
10350 EVENT(context, GLProgramBinaryOES,
10351 "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d",
10352 CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat),
10353 (uintptr_t)binary, length);
10354
10355 if (context)
10356 {
10357 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
10358 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10359 bool isCallValid = (context->skipValidation() ||
10360 ValidateProgramBinaryOES(context, angle::EntryPoint::GLProgramBinaryOES,
10361 programPacked, binaryFormat, binary, length));
10362 if (isCallValid)
10363 {
10364 context->programBinary(programPacked, binaryFormat, binary, length);
10365 }
10366 ANGLE_CAPTURE(ProgramBinaryOES, isCallValid, context, programPacked, binaryFormat, binary,
10367 length);
10368 }
10369 else
10370 {
10371 GenerateContextLostErrorOnCurrentGlobalContext();
10372 }
10373 }
10374
10375 // GL_OES_mapbuffer
GL_GetBufferPointervOES(GLenum target,GLenum pname,void ** params)10376 void GL_APIENTRY GL_GetBufferPointervOES(GLenum target, GLenum pname, void **params)
10377 {
10378 Context *context = GetValidGlobalContext();
10379 EVENT(context, GLGetBufferPointervOES,
10380 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10381 GLenumToString(GLenumGroup::BufferTargetARB, target),
10382 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
10383
10384 if (context)
10385 {
10386 BufferBinding targetPacked = PackParam<BufferBinding>(target);
10387 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10388 bool isCallValid =
10389 (context->skipValidation() ||
10390 ValidateGetBufferPointervOES(context, angle::EntryPoint::GLGetBufferPointervOES,
10391 targetPacked, pname, params));
10392 if (isCallValid)
10393 {
10394 context->getBufferPointerv(targetPacked, pname, params);
10395 }
10396 ANGLE_CAPTURE(GetBufferPointervOES, isCallValid, context, targetPacked, pname, params);
10397 }
10398 else
10399 {
10400 GenerateContextLostErrorOnCurrentGlobalContext();
10401 }
10402 }
10403
GL_MapBufferOES(GLenum target,GLenum access)10404 void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access)
10405 {
10406 Context *context = GetValidGlobalContext();
10407 EVENT(context, GLMapBufferOES, "context = %d, target = %s, access = %s", CID(context),
10408 GLenumToString(GLenumGroup::BufferTargetARB, target),
10409 GLenumToString(GLenumGroup::BufferAccessARB, access));
10410
10411 void *returnValue;
10412 if (context)
10413 {
10414 BufferBinding targetPacked = PackParam<BufferBinding>(target);
10415 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10416 bool isCallValid = (context->skipValidation() ||
10417 ValidateMapBufferOES(context, angle::EntryPoint::GLMapBufferOES,
10418 targetPacked, access));
10419 if (isCallValid)
10420 {
10421 returnValue = context->mapBuffer(targetPacked, access);
10422 }
10423 else
10424 {
10425 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>();
10426 }
10427 ANGLE_CAPTURE(MapBufferOES, isCallValid, context, targetPacked, access, returnValue);
10428 }
10429 else
10430 {
10431 GenerateContextLostErrorOnCurrentGlobalContext();
10432 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>();
10433 }
10434 return returnValue;
10435 }
10436
GL_UnmapBufferOES(GLenum target)10437 GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target)
10438 {
10439 Context *context = GetValidGlobalContext();
10440 EVENT(context, GLUnmapBufferOES, "context = %d, target = %s", CID(context),
10441 GLenumToString(GLenumGroup::DefaultGroup, target));
10442
10443 GLboolean returnValue;
10444 if (context)
10445 {
10446 BufferBinding targetPacked = PackParam<BufferBinding>(target);
10447 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10448 bool isCallValid =
10449 (context->skipValidation() ||
10450 ValidateUnmapBufferOES(context, angle::EntryPoint::GLUnmapBufferOES, targetPacked));
10451 if (isCallValid)
10452 {
10453 returnValue = context->unmapBuffer(targetPacked);
10454 }
10455 else
10456 {
10457 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>();
10458 }
10459 ANGLE_CAPTURE(UnmapBufferOES, isCallValid, context, targetPacked, returnValue);
10460 }
10461 else
10462 {
10463 GenerateContextLostErrorOnCurrentGlobalContext();
10464 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>();
10465 }
10466 return returnValue;
10467 }
10468
10469 // GL_OES_matrix_palette
GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex)10470 void GL_APIENTRY GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex)
10471 {
10472 Context *context = GetValidGlobalContext();
10473 EVENT(context, GLCurrentPaletteMatrixOES, "context = %d, matrixpaletteindex = %u", CID(context),
10474 matrixpaletteindex);
10475
10476 if (context)
10477 {
10478 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10479 bool isCallValid =
10480 (context->skipValidation() ||
10481 ValidateCurrentPaletteMatrixOES(context, angle::EntryPoint::GLCurrentPaletteMatrixOES,
10482 matrixpaletteindex));
10483 if (isCallValid)
10484 {
10485 context->currentPaletteMatrix(matrixpaletteindex);
10486 }
10487 ANGLE_CAPTURE(CurrentPaletteMatrixOES, isCallValid, context, matrixpaletteindex);
10488 }
10489 else
10490 {
10491 GenerateContextLostErrorOnCurrentGlobalContext();
10492 }
10493 }
10494
GL_LoadPaletteFromModelViewMatrixOES()10495 void GL_APIENTRY GL_LoadPaletteFromModelViewMatrixOES()
10496 {
10497 Context *context = GetValidGlobalContext();
10498 EVENT(context, GLLoadPaletteFromModelViewMatrixOES, "context = %d", CID(context));
10499
10500 if (context)
10501 {
10502 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10503 bool isCallValid = (context->skipValidation() ||
10504 ValidateLoadPaletteFromModelViewMatrixOES(
10505 context, angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES));
10506 if (isCallValid)
10507 {
10508 context->loadPaletteFromModelViewMatrix();
10509 }
10510 ANGLE_CAPTURE(LoadPaletteFromModelViewMatrixOES, isCallValid, context);
10511 }
10512 else
10513 {
10514 GenerateContextLostErrorOnCurrentGlobalContext();
10515 }
10516 }
10517
GL_MatrixIndexPointerOES(GLint size,GLenum type,GLsizei stride,const void * pointer)10518 void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size,
10519 GLenum type,
10520 GLsizei stride,
10521 const void *pointer)
10522 {
10523 Context *context = GetValidGlobalContext();
10524 EVENT(context, GLMatrixIndexPointerOES,
10525 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
10526 CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
10527 (uintptr_t)pointer);
10528
10529 if (context)
10530 {
10531 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10532 bool isCallValid =
10533 (context->skipValidation() ||
10534 ValidateMatrixIndexPointerOES(context, angle::EntryPoint::GLMatrixIndexPointerOES,
10535 size, type, stride, pointer));
10536 if (isCallValid)
10537 {
10538 context->matrixIndexPointer(size, type, stride, pointer);
10539 }
10540 ANGLE_CAPTURE(MatrixIndexPointerOES, isCallValid, context, size, type, stride, pointer);
10541 }
10542 else
10543 {
10544 GenerateContextLostErrorOnCurrentGlobalContext();
10545 }
10546 }
10547
GL_WeightPointerOES(GLint size,GLenum type,GLsizei stride,const void * pointer)10548 void GL_APIENTRY GL_WeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
10549 {
10550 Context *context = GetValidGlobalContext();
10551 EVENT(context, GLWeightPointerOES,
10552 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
10553 CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride,
10554 (uintptr_t)pointer);
10555
10556 if (context)
10557 {
10558 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10559 bool isCallValid = (context->skipValidation() ||
10560 ValidateWeightPointerOES(context, angle::EntryPoint::GLWeightPointerOES,
10561 size, type, stride, pointer));
10562 if (isCallValid)
10563 {
10564 context->weightPointer(size, type, stride, pointer);
10565 }
10566 ANGLE_CAPTURE(WeightPointerOES, isCallValid, context, size, type, stride, pointer);
10567 }
10568 else
10569 {
10570 GenerateContextLostErrorOnCurrentGlobalContext();
10571 }
10572 }
10573
10574 // GL_OES_packed_depth_stencil
10575
10576 // GL_OES_point_size_array
GL_PointSizePointerOES(GLenum type,GLsizei stride,const void * pointer)10577 void GL_APIENTRY GL_PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
10578 {
10579 Context *context = GetValidGlobalContext();
10580 EVENT(context, GLPointSizePointerOES,
10581 "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
10582 GLenumToString(GLenumGroup::DefaultGroup, type), stride, (uintptr_t)pointer);
10583
10584 if (context)
10585 {
10586 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
10587 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10588 bool isCallValid =
10589 (context->skipValidation() ||
10590 ValidatePointSizePointerOES(context, angle::EntryPoint::GLPointSizePointerOES,
10591 typePacked, stride, pointer));
10592 if (isCallValid)
10593 {
10594 context->pointSizePointer(typePacked, stride, pointer);
10595 }
10596 ANGLE_CAPTURE(PointSizePointerOES, isCallValid, context, typePacked, stride, pointer);
10597 }
10598 else
10599 {
10600 GenerateContextLostErrorOnCurrentGlobalContext();
10601 }
10602 }
10603
10604 // GL_OES_point_sprite
10605
10606 // GL_OES_primitive_bounding_box
GL_PrimitiveBoundingBoxOES(GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)10607 void GL_APIENTRY GL_PrimitiveBoundingBoxOES(GLfloat minX,
10608 GLfloat minY,
10609 GLfloat minZ,
10610 GLfloat minW,
10611 GLfloat maxX,
10612 GLfloat maxY,
10613 GLfloat maxZ,
10614 GLfloat maxW)
10615 {
10616 Context *context = GetValidGlobalContext();
10617 EVENT(context, GLPrimitiveBoundingBoxOES,
10618 "context = %d, minX = %f, minY = %f, minZ = %f, minW = %f, maxX = %f, maxY = %f, maxZ = "
10619 "%f, maxW = %f",
10620 CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
10621
10622 if (context)
10623 {
10624 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10625 bool isCallValid =
10626 (context->skipValidation() ||
10627 ValidatePrimitiveBoundingBoxOES(context, angle::EntryPoint::GLPrimitiveBoundingBoxOES,
10628 minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
10629 if (isCallValid)
10630 {
10631 context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
10632 }
10633 ANGLE_CAPTURE(PrimitiveBoundingBoxOES, isCallValid, context, minX, minY, minZ, minW, maxX,
10634 maxY, maxZ, maxW);
10635 }
10636 else
10637 {
10638 GenerateContextLostErrorOnCurrentGlobalContext();
10639 }
10640 }
10641
10642 // GL_OES_query_matrix
GL_QueryMatrixxOES(GLfixed * mantissa,GLint * exponent)10643 GLbitfield GL_APIENTRY GL_QueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
10644 {
10645 Context *context = GetValidGlobalContext();
10646 EVENT(context, GLQueryMatrixxOES,
10647 "context = %d, mantissa = 0x%016" PRIxPTR ", exponent = 0x%016" PRIxPTR "", CID(context),
10648 (uintptr_t)mantissa, (uintptr_t)exponent);
10649
10650 GLbitfield returnValue;
10651 if (context)
10652 {
10653 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10654 bool isCallValid = (context->skipValidation() ||
10655 ValidateQueryMatrixxOES(context, angle::EntryPoint::GLQueryMatrixxOES,
10656 mantissa, exponent));
10657 if (isCallValid)
10658 {
10659 returnValue = context->queryMatrixx(mantissa, exponent);
10660 }
10661 else
10662 {
10663 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>();
10664 }
10665 ANGLE_CAPTURE(QueryMatrixxOES, isCallValid, context, mantissa, exponent, returnValue);
10666 }
10667 else
10668 {
10669 GenerateContextLostErrorOnCurrentGlobalContext();
10670 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>();
10671 }
10672 return returnValue;
10673 }
10674
10675 // GL_OES_rgb8_rgba8
10676
10677 // GL_OES_sample_shading
GL_MinSampleShadingOES(GLfloat value)10678 void GL_APIENTRY GL_MinSampleShadingOES(GLfloat value)
10679 {
10680 Context *context = GetValidGlobalContext();
10681 EVENT(context, GLMinSampleShadingOES, "context = %d, value = %f", CID(context), value);
10682
10683 if (context)
10684 {
10685 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10686 bool isCallValid =
10687 (context->skipValidation() ||
10688 ValidateMinSampleShadingOES(context, angle::EntryPoint::GLMinSampleShadingOES, value));
10689 if (isCallValid)
10690 {
10691 context->minSampleShading(value);
10692 }
10693 ANGLE_CAPTURE(MinSampleShadingOES, isCallValid, context, value);
10694 }
10695 else
10696 {
10697 GenerateContextLostErrorOnCurrentGlobalContext();
10698 }
10699 }
10700
10701 // GL_OES_sample_variables
10702
10703 // GL_OES_shader_image_atomic
10704
10705 // GL_OES_shader_io_blocks
10706
10707 // GL_OES_shader_multisample_interpolation
10708
10709 // GL_OES_standard_derivatives
10710
10711 // GL_OES_surfaceless_context
10712
10713 // GL_OES_texture_3D
GL_CompressedTexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)10714 void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target,
10715 GLint level,
10716 GLenum internalformat,
10717 GLsizei width,
10718 GLsizei height,
10719 GLsizei depth,
10720 GLint border,
10721 GLsizei imageSize,
10722 const void *data)
10723 {
10724 Context *context = GetValidGlobalContext();
10725 EVENT(context, GLCompressedTexImage3DOES,
10726 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
10727 "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "",
10728 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
10729 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
10730 imageSize, (uintptr_t)data);
10731
10732 if (context)
10733 {
10734 TextureTarget targetPacked = PackParam<TextureTarget>(target);
10735 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10736 bool isCallValid =
10737 (context->skipValidation() ||
10738 ValidateCompressedTexImage3DOES(context, angle::EntryPoint::GLCompressedTexImage3DOES,
10739 targetPacked, level, internalformat, width, height,
10740 depth, border, imageSize, data));
10741 if (isCallValid)
10742 {
10743 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
10744 border, imageSize, data);
10745 }
10746 ANGLE_CAPTURE(CompressedTexImage3DOES, isCallValid, context, targetPacked, level,
10747 internalformat, width, height, depth, border, imageSize, data);
10748 }
10749 else
10750 {
10751 GenerateContextLostErrorOnCurrentGlobalContext();
10752 }
10753 }
10754
GL_CompressedTexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)10755 void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target,
10756 GLint level,
10757 GLint xoffset,
10758 GLint yoffset,
10759 GLint zoffset,
10760 GLsizei width,
10761 GLsizei height,
10762 GLsizei depth,
10763 GLenum format,
10764 GLsizei imageSize,
10765 const void *data)
10766 {
10767 Context *context = GetValidGlobalContext();
10768 EVENT(context, GLCompressedTexSubImage3DOES,
10769 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
10770 "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "",
10771 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
10772 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
10773 imageSize, (uintptr_t)data);
10774
10775 if (context)
10776 {
10777 TextureTarget targetPacked = PackParam<TextureTarget>(target);
10778 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10779 bool isCallValid =
10780 (context->skipValidation() ||
10781 ValidateCompressedTexSubImage3DOES(
10782 context, angle::EntryPoint::GLCompressedTexSubImage3DOES, targetPacked, level,
10783 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data));
10784 if (isCallValid)
10785 {
10786 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
10787 height, depth, format, imageSize, data);
10788 }
10789 ANGLE_CAPTURE(CompressedTexSubImage3DOES, isCallValid, context, targetPacked, level,
10790 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
10791 }
10792 else
10793 {
10794 GenerateContextLostErrorOnCurrentGlobalContext();
10795 }
10796 }
10797
GL_CopyTexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)10798 void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target,
10799 GLint level,
10800 GLint xoffset,
10801 GLint yoffset,
10802 GLint zoffset,
10803 GLint x,
10804 GLint y,
10805 GLsizei width,
10806 GLsizei height)
10807 {
10808 Context *context = GetValidGlobalContext();
10809 EVENT(context, GLCopyTexSubImage3DOES,
10810 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = "
10811 "%d, y = %d, width = %d, height = %d",
10812 CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset,
10813 zoffset, x, y, width, height);
10814
10815 if (context)
10816 {
10817 TextureTarget targetPacked = PackParam<TextureTarget>(target);
10818 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10819 bool isCallValid = (context->skipValidation() ||
10820 ValidateCopyTexSubImage3DOES(
10821 context, angle::EntryPoint::GLCopyTexSubImage3DOES, targetPacked,
10822 level, xoffset, yoffset, zoffset, x, y, width, height));
10823 if (isCallValid)
10824 {
10825 context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
10826 height);
10827 }
10828 ANGLE_CAPTURE(CopyTexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset,
10829 yoffset, zoffset, x, y, width, height);
10830 }
10831 else
10832 {
10833 GenerateContextLostErrorOnCurrentGlobalContext();
10834 }
10835 }
10836
GL_FramebufferTexture3DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)10837 void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target,
10838 GLenum attachment,
10839 GLenum textarget,
10840 GLuint texture,
10841 GLint level,
10842 GLint zoffset)
10843 {
10844 Context *context = GetValidGlobalContext();
10845 EVENT(context, GLFramebufferTexture3DOES,
10846 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
10847 "zoffset = %d",
10848 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
10849 GLenumToString(GLenumGroup::FramebufferAttachment, attachment),
10850 GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset);
10851
10852 if (context)
10853 {
10854 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
10855 TextureID texturePacked = PackParam<TextureID>(texture);
10856 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10857 bool isCallValid = (context->skipValidation() ||
10858 ValidateFramebufferTexture3DOES(
10859 context, angle::EntryPoint::GLFramebufferTexture3DOES, target,
10860 attachment, textargetPacked, texturePacked, level, zoffset));
10861 if (isCallValid)
10862 {
10863 context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
10864 zoffset);
10865 }
10866 ANGLE_CAPTURE(FramebufferTexture3DOES, isCallValid, context, target, attachment,
10867 textargetPacked, texturePacked, level, zoffset);
10868 }
10869 else
10870 {
10871 GenerateContextLostErrorOnCurrentGlobalContext();
10872 }
10873 }
10874
GL_TexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)10875 void GL_APIENTRY GL_TexImage3DOES(GLenum target,
10876 GLint level,
10877 GLenum internalformat,
10878 GLsizei width,
10879 GLsizei height,
10880 GLsizei depth,
10881 GLint border,
10882 GLenum format,
10883 GLenum type,
10884 const void *pixels)
10885 {
10886 Context *context = GetValidGlobalContext();
10887 EVENT(context, GLTexImage3DOES,
10888 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
10889 "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
10890 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
10891 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
10892 GLenumToString(GLenumGroup::PixelFormat, format),
10893 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
10894
10895 if (context)
10896 {
10897 TextureTarget targetPacked = PackParam<TextureTarget>(target);
10898 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10899 bool isCallValid = (context->skipValidation() ||
10900 ValidateTexImage3DOES(context, angle::EntryPoint::GLTexImage3DOES,
10901 targetPacked, level, internalformat, width,
10902 height, depth, border, format, type, pixels));
10903 if (isCallValid)
10904 {
10905 context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
10906 format, type, pixels);
10907 }
10908 ANGLE_CAPTURE(TexImage3DOES, isCallValid, context, targetPacked, level, internalformat,
10909 width, height, depth, border, format, type, pixels);
10910 }
10911 else
10912 {
10913 GenerateContextLostErrorOnCurrentGlobalContext();
10914 }
10915 }
10916
GL_TexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)10917 void GL_APIENTRY GL_TexSubImage3DOES(GLenum target,
10918 GLint level,
10919 GLint xoffset,
10920 GLint yoffset,
10921 GLint zoffset,
10922 GLsizei width,
10923 GLsizei height,
10924 GLsizei depth,
10925 GLenum format,
10926 GLenum type,
10927 const void *pixels)
10928 {
10929 Context *context = GetValidGlobalContext();
10930 EVENT(context, GLTexSubImage3DOES,
10931 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
10932 "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
10933 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
10934 zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
10935 GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
10936
10937 if (context)
10938 {
10939 TextureTarget targetPacked = PackParam<TextureTarget>(target);
10940 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10941 bool isCallValid = (context->skipValidation() ||
10942 ValidateTexSubImage3DOES(context, angle::EntryPoint::GLTexSubImage3DOES,
10943 targetPacked, level, xoffset, yoffset, zoffset,
10944 width, height, depth, format, type, pixels));
10945 if (isCallValid)
10946 {
10947 context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
10948 depth, format, type, pixels);
10949 }
10950 ANGLE_CAPTURE(TexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset, yoffset,
10951 zoffset, width, height, depth, format, type, pixels);
10952 }
10953 else
10954 {
10955 GenerateContextLostErrorOnCurrentGlobalContext();
10956 }
10957 }
10958
10959 // GL_OES_texture_border_clamp
GL_GetSamplerParameterIivOES(GLuint sampler,GLenum pname,GLint * params)10960 void GL_APIENTRY GL_GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
10961 {
10962 Context *context = GetValidGlobalContext();
10963 EVENT(context, GLGetSamplerParameterIivOES,
10964 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10965 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
10966
10967 if (context)
10968 {
10969 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
10970 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10971 bool isCallValid = (context->skipValidation() ||
10972 ValidateGetSamplerParameterIivOES(
10973 context, angle::EntryPoint::GLGetSamplerParameterIivOES,
10974 samplerPacked, pname, params));
10975 if (isCallValid)
10976 {
10977 context->getSamplerParameterIiv(samplerPacked, pname, params);
10978 }
10979 ANGLE_CAPTURE(GetSamplerParameterIivOES, isCallValid, context, samplerPacked, pname,
10980 params);
10981 }
10982 else
10983 {
10984 GenerateContextLostErrorOnCurrentGlobalContext();
10985 }
10986 }
10987
GL_GetSamplerParameterIuivOES(GLuint sampler,GLenum pname,GLuint * params)10988 void GL_APIENTRY GL_GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
10989 {
10990 Context *context = GetValidGlobalContext();
10991 EVENT(context, GLGetSamplerParameterIuivOES,
10992 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10993 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params);
10994
10995 if (context)
10996 {
10997 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
10998 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
10999 bool isCallValid = (context->skipValidation() ||
11000 ValidateGetSamplerParameterIuivOES(
11001 context, angle::EntryPoint::GLGetSamplerParameterIuivOES,
11002 samplerPacked, pname, params));
11003 if (isCallValid)
11004 {
11005 context->getSamplerParameterIuiv(samplerPacked, pname, params);
11006 }
11007 ANGLE_CAPTURE(GetSamplerParameterIuivOES, isCallValid, context, samplerPacked, pname,
11008 params);
11009 }
11010 else
11011 {
11012 GenerateContextLostErrorOnCurrentGlobalContext();
11013 }
11014 }
11015
GL_GetTexParameterIivOES(GLenum target,GLenum pname,GLint * params)11016 void GL_APIENTRY GL_GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
11017 {
11018 Context *context = GetValidGlobalContext();
11019 EVENT(context, GLGetTexParameterIivOES,
11020 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11021 GLenumToString(GLenumGroup::TextureTarget, target),
11022 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
11023
11024 if (context)
11025 {
11026 TextureType targetPacked = PackParam<TextureType>(target);
11027 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11028 bool isCallValid =
11029 (context->skipValidation() ||
11030 ValidateGetTexParameterIivOES(context, angle::EntryPoint::GLGetTexParameterIivOES,
11031 targetPacked, pname, params));
11032 if (isCallValid)
11033 {
11034 context->getTexParameterIiv(targetPacked, pname, params);
11035 }
11036 ANGLE_CAPTURE(GetTexParameterIivOES, isCallValid, context, targetPacked, pname, params);
11037 }
11038 else
11039 {
11040 GenerateContextLostErrorOnCurrentGlobalContext();
11041 }
11042 }
11043
GL_GetTexParameterIuivOES(GLenum target,GLenum pname,GLuint * params)11044 void GL_APIENTRY GL_GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
11045 {
11046 Context *context = GetValidGlobalContext();
11047 EVENT(context, GLGetTexParameterIuivOES,
11048 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11049 GLenumToString(GLenumGroup::TextureTarget, target),
11050 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
11051
11052 if (context)
11053 {
11054 TextureType targetPacked = PackParam<TextureType>(target);
11055 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11056 bool isCallValid =
11057 (context->skipValidation() ||
11058 ValidateGetTexParameterIuivOES(context, angle::EntryPoint::GLGetTexParameterIuivOES,
11059 targetPacked, pname, params));
11060 if (isCallValid)
11061 {
11062 context->getTexParameterIuiv(targetPacked, pname, params);
11063 }
11064 ANGLE_CAPTURE(GetTexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
11065 }
11066 else
11067 {
11068 GenerateContextLostErrorOnCurrentGlobalContext();
11069 }
11070 }
11071
GL_SamplerParameterIivOES(GLuint sampler,GLenum pname,const GLint * param)11072 void GL_APIENTRY GL_SamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
11073 {
11074 Context *context = GetValidGlobalContext();
11075 EVENT(context, GLSamplerParameterIivOES,
11076 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
11077 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
11078
11079 if (context)
11080 {
11081 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
11082 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11083 bool isCallValid =
11084 (context->skipValidation() ||
11085 ValidateSamplerParameterIivOES(context, angle::EntryPoint::GLSamplerParameterIivOES,
11086 samplerPacked, pname, param));
11087 if (isCallValid)
11088 {
11089 context->samplerParameterIiv(samplerPacked, pname, param);
11090 }
11091 ANGLE_CAPTURE(SamplerParameterIivOES, isCallValid, context, samplerPacked, pname, param);
11092 }
11093 else
11094 {
11095 GenerateContextLostErrorOnCurrentGlobalContext();
11096 }
11097 }
11098
GL_SamplerParameterIuivOES(GLuint sampler,GLenum pname,const GLuint * param)11099 void GL_APIENTRY GL_SamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
11100 {
11101 Context *context = GetValidGlobalContext();
11102 EVENT(context, GLSamplerParameterIuivOES,
11103 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
11104 sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param);
11105
11106 if (context)
11107 {
11108 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
11109 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11110 bool isCallValid =
11111 (context->skipValidation() ||
11112 ValidateSamplerParameterIuivOES(context, angle::EntryPoint::GLSamplerParameterIuivOES,
11113 samplerPacked, pname, param));
11114 if (isCallValid)
11115 {
11116 context->samplerParameterIuiv(samplerPacked, pname, param);
11117 }
11118 ANGLE_CAPTURE(SamplerParameterIuivOES, isCallValid, context, samplerPacked, pname, param);
11119 }
11120 else
11121 {
11122 GenerateContextLostErrorOnCurrentGlobalContext();
11123 }
11124 }
11125
GL_TexParameterIivOES(GLenum target,GLenum pname,const GLint * params)11126 void GL_APIENTRY GL_TexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
11127 {
11128 Context *context = GetValidGlobalContext();
11129 EVENT(context, GLTexParameterIivOES,
11130 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11131 GLenumToString(GLenumGroup::TextureTarget, target),
11132 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
11133
11134 if (context)
11135 {
11136 TextureType targetPacked = PackParam<TextureType>(target);
11137 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11138 bool isCallValid =
11139 (context->skipValidation() ||
11140 ValidateTexParameterIivOES(context, angle::EntryPoint::GLTexParameterIivOES,
11141 targetPacked, pname, params));
11142 if (isCallValid)
11143 {
11144 context->texParameterIiv(targetPacked, pname, params);
11145 }
11146 ANGLE_CAPTURE(TexParameterIivOES, isCallValid, context, targetPacked, pname, params);
11147 }
11148 else
11149 {
11150 GenerateContextLostErrorOnCurrentGlobalContext();
11151 }
11152 }
11153
GL_TexParameterIuivOES(GLenum target,GLenum pname,const GLuint * params)11154 void GL_APIENTRY GL_TexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
11155 {
11156 Context *context = GetValidGlobalContext();
11157 EVENT(context, GLTexParameterIuivOES,
11158 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11159 GLenumToString(GLenumGroup::TextureTarget, target),
11160 GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
11161
11162 if (context)
11163 {
11164 TextureType targetPacked = PackParam<TextureType>(target);
11165 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11166 bool isCallValid =
11167 (context->skipValidation() ||
11168 ValidateTexParameterIuivOES(context, angle::EntryPoint::GLTexParameterIuivOES,
11169 targetPacked, pname, params));
11170 if (isCallValid)
11171 {
11172 context->texParameterIuiv(targetPacked, pname, params);
11173 }
11174 ANGLE_CAPTURE(TexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
11175 }
11176 else
11177 {
11178 GenerateContextLostErrorOnCurrentGlobalContext();
11179 }
11180 }
11181
11182 // GL_OES_texture_buffer
GL_TexBufferOES(GLenum target,GLenum internalformat,GLuint buffer)11183 void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint buffer)
11184 {
11185 Context *context = GetValidGlobalContext();
11186 EVENT(context, GLTexBufferOES, "context = %d, target = %s, internalformat = %s, buffer = %u",
11187 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
11188 GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer);
11189
11190 if (context)
11191 {
11192 TextureType targetPacked = PackParam<TextureType>(target);
11193 BufferID bufferPacked = PackParam<BufferID>(buffer);
11194 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11195 bool isCallValid = (context->skipValidation() ||
11196 ValidateTexBufferOES(context, angle::EntryPoint::GLTexBufferOES,
11197 targetPacked, internalformat, bufferPacked));
11198 if (isCallValid)
11199 {
11200 context->texBuffer(targetPacked, internalformat, bufferPacked);
11201 }
11202 ANGLE_CAPTURE(TexBufferOES, isCallValid, context, targetPacked, internalformat,
11203 bufferPacked);
11204 }
11205 else
11206 {
11207 GenerateContextLostErrorOnCurrentGlobalContext();
11208 }
11209 }
11210
GL_TexBufferRangeOES(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)11211 void GL_APIENTRY GL_TexBufferRangeOES(GLenum target,
11212 GLenum internalformat,
11213 GLuint buffer,
11214 GLintptr offset,
11215 GLsizeiptr size)
11216 {
11217 Context *context = GetValidGlobalContext();
11218 EVENT(context, GLTexBufferRangeOES,
11219 "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu",
11220 CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
11221 GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer,
11222 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
11223
11224 if (context)
11225 {
11226 TextureType targetPacked = PackParam<TextureType>(target);
11227 BufferID bufferPacked = PackParam<BufferID>(buffer);
11228 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11229 bool isCallValid =
11230 (context->skipValidation() ||
11231 ValidateTexBufferRangeOES(context, angle::EntryPoint::GLTexBufferRangeOES,
11232 targetPacked, internalformat, bufferPacked, offset, size));
11233 if (isCallValid)
11234 {
11235 context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size);
11236 }
11237 ANGLE_CAPTURE(TexBufferRangeOES, isCallValid, context, targetPacked, internalformat,
11238 bufferPacked, offset, size);
11239 }
11240 else
11241 {
11242 GenerateContextLostErrorOnCurrentGlobalContext();
11243 }
11244 }
11245
11246 // GL_OES_texture_compression_astc
11247
11248 // GL_OES_texture_cube_map
GL_GetTexGenfvOES(GLenum coord,GLenum pname,GLfloat * params)11249 void GL_APIENTRY GL_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
11250 {
11251 Context *context = GetValidGlobalContext();
11252 EVENT(context, GLGetTexGenfvOES,
11253 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11254 GLenumToString(GLenumGroup::TextureCoordName, coord),
11255 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
11256
11257 if (context)
11258 {
11259 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11260 bool isCallValid = (context->skipValidation() ||
11261 ValidateGetTexGenfvOES(context, angle::EntryPoint::GLGetTexGenfvOES,
11262 coord, pname, params));
11263 if (isCallValid)
11264 {
11265 context->getTexGenfv(coord, pname, params);
11266 }
11267 ANGLE_CAPTURE(GetTexGenfvOES, isCallValid, context, coord, pname, params);
11268 }
11269 else
11270 {
11271 GenerateContextLostErrorOnCurrentGlobalContext();
11272 }
11273 }
11274
GL_GetTexGenivOES(GLenum coord,GLenum pname,GLint * params)11275 void GL_APIENTRY GL_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
11276 {
11277 Context *context = GetValidGlobalContext();
11278 EVENT(context, GLGetTexGenivOES,
11279 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11280 GLenumToString(GLenumGroup::TextureCoordName, coord),
11281 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
11282
11283 if (context)
11284 {
11285 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11286 bool isCallValid = (context->skipValidation() ||
11287 ValidateGetTexGenivOES(context, angle::EntryPoint::GLGetTexGenivOES,
11288 coord, pname, params));
11289 if (isCallValid)
11290 {
11291 context->getTexGeniv(coord, pname, params);
11292 }
11293 ANGLE_CAPTURE(GetTexGenivOES, isCallValid, context, coord, pname, params);
11294 }
11295 else
11296 {
11297 GenerateContextLostErrorOnCurrentGlobalContext();
11298 }
11299 }
11300
GL_GetTexGenxvOES(GLenum coord,GLenum pname,GLfixed * params)11301 void GL_APIENTRY GL_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
11302 {
11303 Context *context = GetValidGlobalContext();
11304 EVENT(context, GLGetTexGenxvOES,
11305 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11306 GLenumToString(GLenumGroup::TextureCoordName, coord),
11307 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
11308
11309 if (context)
11310 {
11311 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11312 bool isCallValid = (context->skipValidation() ||
11313 ValidateGetTexGenxvOES(context, angle::EntryPoint::GLGetTexGenxvOES,
11314 coord, pname, params));
11315 if (isCallValid)
11316 {
11317 context->getTexGenxv(coord, pname, params);
11318 }
11319 ANGLE_CAPTURE(GetTexGenxvOES, isCallValid, context, coord, pname, params);
11320 }
11321 else
11322 {
11323 GenerateContextLostErrorOnCurrentGlobalContext();
11324 }
11325 }
11326
GL_TexGenfOES(GLenum coord,GLenum pname,GLfloat param)11327 void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param)
11328 {
11329 Context *context = GetValidGlobalContext();
11330 EVENT(context, GLTexGenfOES, "context = %d, coord = %s, pname = %s, param = %f", CID(context),
11331 GLenumToString(GLenumGroup::TextureCoordName, coord),
11332 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
11333
11334 if (context)
11335 {
11336 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11337 bool isCallValid =
11338 (context->skipValidation() ||
11339 ValidateTexGenfOES(context, angle::EntryPoint::GLTexGenfOES, coord, pname, param));
11340 if (isCallValid)
11341 {
11342 context->texGenf(coord, pname, param);
11343 }
11344 ANGLE_CAPTURE(TexGenfOES, isCallValid, context, coord, pname, param);
11345 }
11346 else
11347 {
11348 GenerateContextLostErrorOnCurrentGlobalContext();
11349 }
11350 }
11351
GL_TexGenfvOES(GLenum coord,GLenum pname,const GLfloat * params)11352 void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
11353 {
11354 Context *context = GetValidGlobalContext();
11355 EVENT(context, GLTexGenfvOES,
11356 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11357 GLenumToString(GLenumGroup::TextureCoordName, coord),
11358 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
11359
11360 if (context)
11361 {
11362 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11363 bool isCallValid =
11364 (context->skipValidation() ||
11365 ValidateTexGenfvOES(context, angle::EntryPoint::GLTexGenfvOES, coord, pname, params));
11366 if (isCallValid)
11367 {
11368 context->texGenfv(coord, pname, params);
11369 }
11370 ANGLE_CAPTURE(TexGenfvOES, isCallValid, context, coord, pname, params);
11371 }
11372 else
11373 {
11374 GenerateContextLostErrorOnCurrentGlobalContext();
11375 }
11376 }
11377
GL_TexGeniOES(GLenum coord,GLenum pname,GLint param)11378 void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param)
11379 {
11380 Context *context = GetValidGlobalContext();
11381 EVENT(context, GLTexGeniOES, "context = %d, coord = %s, pname = %s, param = %d", CID(context),
11382 GLenumToString(GLenumGroup::TextureCoordName, coord),
11383 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
11384
11385 if (context)
11386 {
11387 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11388 bool isCallValid =
11389 (context->skipValidation() ||
11390 ValidateTexGeniOES(context, angle::EntryPoint::GLTexGeniOES, coord, pname, param));
11391 if (isCallValid)
11392 {
11393 context->texGeni(coord, pname, param);
11394 }
11395 ANGLE_CAPTURE(TexGeniOES, isCallValid, context, coord, pname, param);
11396 }
11397 else
11398 {
11399 GenerateContextLostErrorOnCurrentGlobalContext();
11400 }
11401 }
11402
GL_TexGenivOES(GLenum coord,GLenum pname,const GLint * params)11403 void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
11404 {
11405 Context *context = GetValidGlobalContext();
11406 EVENT(context, GLTexGenivOES,
11407 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11408 GLenumToString(GLenumGroup::TextureCoordName, coord),
11409 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
11410
11411 if (context)
11412 {
11413 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11414 bool isCallValid =
11415 (context->skipValidation() ||
11416 ValidateTexGenivOES(context, angle::EntryPoint::GLTexGenivOES, coord, pname, params));
11417 if (isCallValid)
11418 {
11419 context->texGeniv(coord, pname, params);
11420 }
11421 ANGLE_CAPTURE(TexGenivOES, isCallValid, context, coord, pname, params);
11422 }
11423 else
11424 {
11425 GenerateContextLostErrorOnCurrentGlobalContext();
11426 }
11427 }
11428
GL_TexGenxOES(GLenum coord,GLenum pname,GLfixed param)11429 void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
11430 {
11431 Context *context = GetValidGlobalContext();
11432 EVENT(context, GLTexGenxOES, "context = %d, coord = %s, pname = %s, param = 0x%X", CID(context),
11433 GLenumToString(GLenumGroup::TextureCoordName, coord),
11434 GLenumToString(GLenumGroup::TextureGenParameter, pname), param);
11435
11436 if (context)
11437 {
11438 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11439 bool isCallValid =
11440 (context->skipValidation() ||
11441 ValidateTexGenxOES(context, angle::EntryPoint::GLTexGenxOES, coord, pname, param));
11442 if (isCallValid)
11443 {
11444 context->texGenx(coord, pname, param);
11445 }
11446 ANGLE_CAPTURE(TexGenxOES, isCallValid, context, coord, pname, param);
11447 }
11448 else
11449 {
11450 GenerateContextLostErrorOnCurrentGlobalContext();
11451 }
11452 }
11453
GL_TexGenxvOES(GLenum coord,GLenum pname,const GLfixed * params)11454 void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
11455 {
11456 Context *context = GetValidGlobalContext();
11457 EVENT(context, GLTexGenxvOES,
11458 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11459 GLenumToString(GLenumGroup::TextureCoordName, coord),
11460 GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
11461
11462 if (context)
11463 {
11464 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11465 bool isCallValid =
11466 (context->skipValidation() ||
11467 ValidateTexGenxvOES(context, angle::EntryPoint::GLTexGenxvOES, coord, pname, params));
11468 if (isCallValid)
11469 {
11470 context->texGenxv(coord, pname, params);
11471 }
11472 ANGLE_CAPTURE(TexGenxvOES, isCallValid, context, coord, pname, params);
11473 }
11474 else
11475 {
11476 GenerateContextLostErrorOnCurrentGlobalContext();
11477 }
11478 }
11479
11480 // GL_OES_texture_cube_map_array
11481
11482 // GL_OES_texture_float
11483
11484 // GL_OES_texture_float_linear
11485
11486 // GL_OES_texture_half_float
11487
11488 // GL_OES_texture_half_float_linear
11489
11490 // GL_OES_texture_npot
11491
11492 // GL_OES_texture_stencil8
11493
11494 // GL_OES_texture_storage_multisample_2d_array
GL_TexStorage3DMultisampleOES(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)11495 void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target,
11496 GLsizei samples,
11497 GLenum internalformat,
11498 GLsizei width,
11499 GLsizei height,
11500 GLsizei depth,
11501 GLboolean fixedsamplelocations)
11502 {
11503 Context *context = GetValidGlobalContext();
11504 EVENT(context, GLTexStorage3DMultisampleOES,
11505 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
11506 "depth = %d, fixedsamplelocations = %s",
11507 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
11508 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth,
11509 GLbooleanToString(fixedsamplelocations));
11510
11511 if (context)
11512 {
11513 TextureType targetPacked = PackParam<TextureType>(target);
11514 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11515 bool isCallValid =
11516 (context->skipValidation() ||
11517 ValidateTexStorage3DMultisampleOES(
11518 context, angle::EntryPoint::GLTexStorage3DMultisampleOES, targetPacked, samples,
11519 internalformat, width, height, depth, fixedsamplelocations));
11520 if (isCallValid)
11521 {
11522 context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
11523 depth, fixedsamplelocations);
11524 }
11525 ANGLE_CAPTURE(TexStorage3DMultisampleOES, isCallValid, context, targetPacked, samples,
11526 internalformat, width, height, depth, fixedsamplelocations);
11527 }
11528 else
11529 {
11530 GenerateContextLostErrorOnCurrentGlobalContext();
11531 }
11532 }
11533
11534 // GL_OES_vertex_array_object
GL_BindVertexArrayOES(GLuint array)11535 void GL_APIENTRY GL_BindVertexArrayOES(GLuint array)
11536 {
11537 Context *context = GetValidGlobalContext();
11538 EVENT(context, GLBindVertexArrayOES, "context = %d, array = %u", CID(context), array);
11539
11540 if (context)
11541 {
11542 VertexArrayID arrayPacked = PackParam<VertexArrayID>(array);
11543 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11544 bool isCallValid = (context->skipValidation() ||
11545 ValidateBindVertexArrayOES(
11546 context, angle::EntryPoint::GLBindVertexArrayOES, arrayPacked));
11547 if (isCallValid)
11548 {
11549 context->bindVertexArray(arrayPacked);
11550 }
11551 ANGLE_CAPTURE(BindVertexArrayOES, isCallValid, context, arrayPacked);
11552 }
11553 else
11554 {
11555 GenerateContextLostErrorOnCurrentGlobalContext();
11556 }
11557 }
11558
GL_DeleteVertexArraysOES(GLsizei n,const GLuint * arrays)11559 void GL_APIENTRY GL_DeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
11560 {
11561 Context *context = GetValidGlobalContext();
11562 EVENT(context, GLDeleteVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
11563 CID(context), n, (uintptr_t)arrays);
11564
11565 if (context)
11566 {
11567 const VertexArrayID *arraysPacked = PackParam<const VertexArrayID *>(arrays);
11568 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11569 bool isCallValid =
11570 (context->skipValidation() ||
11571 ValidateDeleteVertexArraysOES(context, angle::EntryPoint::GLDeleteVertexArraysOES, n,
11572 arraysPacked));
11573 if (isCallValid)
11574 {
11575 context->deleteVertexArrays(n, arraysPacked);
11576 }
11577 ANGLE_CAPTURE(DeleteVertexArraysOES, isCallValid, context, n, arraysPacked);
11578 }
11579 else
11580 {
11581 GenerateContextLostErrorOnCurrentGlobalContext();
11582 }
11583 }
11584
GL_GenVertexArraysOES(GLsizei n,GLuint * arrays)11585 void GL_APIENTRY GL_GenVertexArraysOES(GLsizei n, GLuint *arrays)
11586 {
11587 Context *context = GetValidGlobalContext();
11588 EVENT(context, GLGenVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
11589 CID(context), n, (uintptr_t)arrays);
11590
11591 if (context)
11592 {
11593 VertexArrayID *arraysPacked = PackParam<VertexArrayID *>(arrays);
11594 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11595 bool isCallValid = (context->skipValidation() ||
11596 ValidateGenVertexArraysOES(
11597 context, angle::EntryPoint::GLGenVertexArraysOES, n, arraysPacked));
11598 if (isCallValid)
11599 {
11600 context->genVertexArrays(n, arraysPacked);
11601 }
11602 ANGLE_CAPTURE(GenVertexArraysOES, isCallValid, context, n, arraysPacked);
11603 }
11604 else
11605 {
11606 GenerateContextLostErrorOnCurrentGlobalContext();
11607 }
11608 }
11609
GL_IsVertexArrayOES(GLuint array)11610 GLboolean GL_APIENTRY GL_IsVertexArrayOES(GLuint array)
11611 {
11612 Context *context = GetValidGlobalContext();
11613 EVENT(context, GLIsVertexArrayOES, "context = %d, array = %u", CID(context), array);
11614
11615 GLboolean returnValue;
11616 if (context)
11617 {
11618 VertexArrayID arrayPacked = PackParam<VertexArrayID>(array);
11619 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11620 bool isCallValid =
11621 (context->skipValidation() ||
11622 ValidateIsVertexArrayOES(context, angle::EntryPoint::GLIsVertexArrayOES, arrayPacked));
11623 if (isCallValid)
11624 {
11625 returnValue = context->isVertexArray(arrayPacked);
11626 }
11627 else
11628 {
11629 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>();
11630 }
11631 ANGLE_CAPTURE(IsVertexArrayOES, isCallValid, context, arrayPacked, returnValue);
11632 }
11633 else
11634 {
11635 GenerateContextLostErrorOnCurrentGlobalContext();
11636 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>();
11637 }
11638 return returnValue;
11639 }
11640
11641 // GL_OES_vertex_half_float
11642
11643 // GL_OES_vertex_type_10_10_10_2
11644
11645 // GL_OVR_multiview
GL_FramebufferTextureMultiviewOVR(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint baseViewIndex,GLsizei numViews)11646 void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target,
11647 GLenum attachment,
11648 GLuint texture,
11649 GLint level,
11650 GLint baseViewIndex,
11651 GLsizei numViews)
11652 {
11653 Context *context = GetValidGlobalContext();
11654 EVENT(context, GLFramebufferTextureMultiviewOVR,
11655 "context = %d, target = %s, attachment = %s, texture = %u, level = %d, baseViewIndex = "
11656 "%d, numViews = %d",
11657 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
11658 GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level,
11659 baseViewIndex, numViews);
11660
11661 if (context)
11662 {
11663 TextureID texturePacked = PackParam<TextureID>(texture);
11664 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
11665 bool isCallValid = (context->skipValidation() ||
11666 ValidateFramebufferTextureMultiviewOVR(
11667 context, angle::EntryPoint::GLFramebufferTextureMultiviewOVR,
11668 target, attachment, texturePacked, level, baseViewIndex, numViews));
11669 if (isCallValid)
11670 {
11671 context->framebufferTextureMultiview(target, attachment, texturePacked, level,
11672 baseViewIndex, numViews);
11673 }
11674 ANGLE_CAPTURE(FramebufferTextureMultiviewOVR, isCallValid, context, target, attachment,
11675 texturePacked, level, baseViewIndex, numViews);
11676 }
11677 else
11678 {
11679 GenerateContextLostErrorOnCurrentGlobalContext();
11680 }
11681 }
11682
11683 // GL_OVR_multiview2
11684 } // extern "C"
11685